fix(editors): open remote projects in Zed

apps/desktop/src/electron/ElectronShell.test.ts

@@ -88,6 +88,33 @@ describe("ElectronShell", () => {
     }).pipe(Effect.provide(ElectronShell.layer)),
   );
 
+  it.effect("opens Zed's ssh deep link", () =>
+    Effect.gen(function* () {
+      openExternalMock.mockResolvedValue(undefined);
+
+      const electronShell = yield* ElectronShell.ElectronShell;
+      const result = yield* electronShell.openExternal("zed://ssh/example.com/home/user/project");
+
+      assert.equal(result, true);
+      assert.deepEqual(openExternalMock.mock.calls, [["zed://ssh/example.com/home/user/project"]]);
+    }).pipe(Effect.provide(ElectronShell.layer)),
+  );
+
+  it.effect("does not open editor URLs that mix up link shapes", () =>
+    Effect.gen(function* () {
+      openExternalMock.mockResolvedValue(undefined);
+
+      const electronShell = yield* ElectronShell.ElectronShell;
+      const results = yield* Effect.all([
+        electronShell.openExternal("zed://extension/attacker"),
+        electronShell.openExternal("vscode://ssh/example.com/home/user/project"),
+      ]);
+
+      assert.deepEqual(results, [false, false]);
+      assert.equal(openExternalMock.mock.calls.length, 0);
+    }).pipe(Effect.provide(ElectronShell.layer)),
+  );
+
   it.effect("does not open remote editor URLs with userinfo", () =>
     Effect.gen(function* () {
       openExternalMock.mockResolvedValue(undefined);

apps/desktop/src/electron/ElectronShell.ts

@@ -1,6 +1,8 @@
 import {
   REMOTE_CAPABLE_EDITOR_IDS,
+  remoteLinkStyleForEditor,
   remoteSchemeForEditor,
+  type EditorRemoteLinkStyle,
   type SystemSettingsPane,
 } from "@t3tools/contracts";
 import * as Context from "effect/Context";
@@ -24,23 +26,38 @@ const SYSTEM_SETTINGS_URLS: Record<SystemSettingsPane, string> = {
     "x-apple.systempreferences:com.apple.settings.PrivacySecurity.extension?Privacy_AllFiles",
 };
 
-// Remote open-in-editor deep links (`vscode://vscode-remote/ssh-remote+…`)
-// must reach the OS handler; every other non-web scheme stays blocked.
+// Remote open-in-editor deep links (`vscode://vscode-remote/ssh-remote+…` and
+// `zed://ssh/<host>/<path>`) must reach the OS handler; every other non-web
+// scheme stays blocked. Each scheme only unlocks its own editor's link shape,
+// so a Zed link cannot ride in on a VS Code scheme or the reverse.
 const SAFE_WEB_PROTOCOLS = new Set(["http:", "https:"]);
-const REMOTE_EDITOR_PROTOCOLS = new Set(
+const REMOTE_EDITOR_PROTOCOLS = new Map<string, EditorRemoteLinkStyle>(
   REMOTE_CAPABLE_EDITOR_IDS.flatMap((id) => {
     const scheme = remoteSchemeForEditor(id);
-    return scheme === undefined ? [] : [`${scheme}:`];
+    const style = remoteLinkStyleForEditor(id);
+    return scheme === undefined || style === undefined
+      ? []
+      : [[`${scheme}:`, style] as [string, EditorRemoteLinkStyle]];
   }),
 );
 
-const isRemoteEditorUrl = (url: URL) =>
-  REMOTE_EDITOR_PROTOCOLS.has(url.protocol) &&
-  url.username.length === 0 &&
-  url.password.length === 0 &&
-  url.host === "vscode-remote" &&
-  url.pathname.startsWith("/ssh-remote+") &&
-  url.pathname.length > "/ssh-remote+".length;
+// `zed://ssh/<host>/<path>`: a host segment plus a non-empty path.
+const ZED_SSH_PATHNAME = /^\/[^/]+\/.+$/;
+
+const isRemoteEditorUrl = (url: URL) => {
+  const style = REMOTE_EDITOR_PROTOCOLS.get(url.protocol);
+  if (style === undefined || url.username.length > 0 || url.password.length > 0) {
+    return false;
+  }
+  if (style === "zed-ssh") {
+    return url.host === "ssh" && ZED_SSH_PATHNAME.test(url.pathname);
+  }
+  return (
+    url.host === "vscode-remote" &&
+    url.pathname.startsWith("/ssh-remote+") &&
+    url.pathname.length > "/ssh-remote+".length
+  );
+};
 
 export function parseSafeExternalUrl(rawUrl: unknown): Option.Option<string> {
   if (typeof rawUrl !== "string") {

apps/web/src/remoteOpen.test.ts

@@ -141,8 +141,18 @@ describe("buildRemoteOpenUrl", () => {
     ).toBe("vscode://vscode-remote/ssh-remote+sol/C%3A/Users/theo");
   });
 
+  it("builds Zed's ssh deep link", () => {
+    expect(
+      buildRemoteOpenUrl({
+        editor: "zed",
+        host: "sol.tail1234.ts.net",
+        absolutePath: "/home/theo/code/my repo",
+      }),
+    ).toBe("zed://ssh/sol.tail1234.ts.net/home/theo/code/my%20repo");
+  });
+
   it("returns undefined for editors without remote support", () => {
-    expect(buildRemoteOpenUrl({ editor: "zed", host: "sol", absolutePath: "/tmp/x" })).toBe(
+    expect(buildRemoteOpenUrl({ editor: "idea", host: "sol", absolutePath: "/tmp/x" })).toBe(
       undefined,
     );
   });

apps/web/src/remoteOpen.ts

@@ -1,8 +1,8 @@
 /**
  * Remote open-in-editor: when this client is not on the environment's
- * machine, "Open" must hand the OS a `vscode://vscode-remote/ssh-remote+…`
- * deep link (local editor connects over SSH) instead of exec'ing an editor
- * on the environment host.
+ * machine, "Open" must hand the OS an editor deep link
+ * (`vscode://vscode-remote/ssh-remote+…`, `zed://ssh/…`) so the local editor
+ * connects over SSH instead of exec'ing an editor on the environment host.
  *
  * Host precedence: a desktop-SSH environment's real `~/.ssh/config` alias
  * beats server-advertised names; among advertised names the tailnet MagicDNS

packages/contracts/src/editor.ts

@@ -4,18 +4,26 @@ import { TrimmedNonEmptyString } from "./baseSchemas.ts";
 export const EditorLaunchStyle = Schema.Literals(["direct-path", "goto", "line-column"]);
 export type EditorLaunchStyle = typeof EditorLaunchStyle.Type;
 
+/** Deep-link shapes editors use to open a remote workspace over SSH. */
+export type EditorRemoteLinkStyle = "vscode-remote" | "zed-ssh";
+
 type EditorDefinition = {
   readonly id: string;
   readonly label: string;
   readonly commands: readonly [string, ...string[]] | null;
   readonly baseArgs?: readonly string[];
   readonly launchStyle: EditorLaunchStyle;
   /**
-   * URL scheme for editors that support VS Code's remote deep links
-   * (`<scheme>://vscode-remote/ssh-remote+<host><path>`). Only set for VS Code
-   * and forks that ship the Remote-SSH machinery.
+   * URL scheme for editors that can open a remote workspace over SSH. Only set
+   * for editors that ship the remote machinery; see `remoteLinkStyle` for the
+   * shape of the link the scheme expects.
    */
   readonly remoteScheme?: string;
+  /**
+   * Shape of `remoteScheme`'s deep link. Defaults to VS Code's
+   * `<scheme>://vscode-remote/ssh-remote+<host><path>`, which its forks share.
+   */
+  readonly remoteLinkStyle?: EditorRemoteLinkStyle;
 };
 
 export const EDITORS = [
@@ -49,7 +57,14 @@ export const EDITORS = [
     launchStyle: "goto",
     remoteScheme: "vscodium",
   },
-  { id: "zed", label: "Zed", commands: ["zed", "zeditor"], launchStyle: "direct-path" },
+  {
+    id: "zed",
+    label: "Zed",
+    commands: ["zed", "zeditor"],
+    launchStyle: "direct-path",
+    remoteScheme: "zed",
+    remoteLinkStyle: "zed-ssh",
+  },
   { id: "antigravity", label: "Antigravity", commands: ["agy"], launchStyle: "goto" },
   { id: "idea", label: "IntelliJ IDEA", commands: ["idea"], launchStyle: "line-column" },
   { id: "aqua", label: "Aqua", commands: ["aqua"], launchStyle: "line-column" },
@@ -84,7 +99,10 @@ export type LaunchEditorInput = typeof LaunchEditorInput.Type;
 
 const remoteSchemeOf = (editor: EditorDefinition): string | undefined => editor.remoteScheme;
 
-/** Editors that can open a remote workspace via `vscode-remote` deep links. */
+const remoteLinkStyleOf = (editor: EditorDefinition): EditorRemoteLinkStyle | undefined =>
+  editor.remoteScheme === undefined ? undefined : (editor.remoteLinkStyle ?? "vscode-remote");
+
+/** Editors that can open a remote workspace via an SSH deep link. */
 export const REMOTE_CAPABLE_EDITOR_IDS: ReadonlyArray<EditorId> = EDITORS.flatMap((editor) =>
   remoteSchemeOf(editor) !== undefined ? [editor.id] : [],
 );
@@ -94,25 +112,37 @@ export const remoteSchemeForEditor = (id: EditorId): string | undefined => {
   return editor === undefined ? undefined : remoteSchemeOf(editor);
 };
 
+/** Link shape `remoteSchemeForEditor` returns a scheme for, if any. */
+export const remoteLinkStyleForEditor = (id: EditorId): EditorRemoteLinkStyle | undefined => {
+  const editor = EDITORS.find((candidate) => candidate.id === id);
+  return editor === undefined ? undefined : remoteLinkStyleOf(editor);
+};
+
 /**
- * Builds a `<scheme>://vscode-remote/ssh-remote+<host><path>` deep link that
- * opens `absolutePath` on `host` in the local editor over SSH. Returns
- * undefined for editors without remote deep-link support.
+ * Builds the deep link that opens `absolutePath` on `host` in the local editor
+ * over SSH: `<scheme>://vscode-remote/ssh-remote+<host><path>` for VS Code and
+ * its forks, `zed://ssh/<host><path>` for Zed. Returns undefined for editors
+ * without remote deep-link support.
  */
 export const buildRemoteOpenUrl = (input: {
   readonly editor: EditorId;
   readonly host: string;
   readonly absolutePath: string;
 }): string | undefined => {
   const scheme = remoteSchemeForEditor(input.editor);
-  if (scheme === undefined) {
+  const style = remoteLinkStyleForEditor(input.editor);
+  if (scheme === undefined || style === undefined) {
     return undefined;
   }
-  // Windows server paths (`C:\...`) appear as `/C:/...` in vscode-remote URIs.
+  // Windows server paths (`C:\...`) appear as `/C:/...` in the remote URI, and
+  // percent-encoding keeps the drive colon out of Zed's SCP-style host split.
   const posixPath = input.absolutePath.replaceAll("\\", "/");
   const rootedPath = posixPath.startsWith("/") ? posixPath : `/${posixPath}`;
   const encodedPath = rootedPath.split("/").map(encodeURIComponent).join("/");
-  return `${scheme}://vscode-remote/ssh-remote+${encodeURIComponent(input.host)}${encodedPath}`;
+  const encodedHost = encodeURIComponent(input.host);
+  return style === "zed-ssh"
+    ? `${scheme}://ssh/${encodedHost}${encodedPath}`
+    : `${scheme}://vscode-remote/ssh-remote+${encodedHost}${encodedPath}`;
 };
 
 /**