🤖 feat: use deep links for built-in editors in Electron

Author: ibetitsmike

src/browser/utils/chatCommands.test.ts

@@ -594,31 +594,15 @@ describe("handlePlanOpenCommand", () => {
     expect(context.api.workspace.getInfo).toHaveBeenCalledWith({
       workspaceId: "test-workspace-id",
     });
-    expect(context.api.general.openInEditor).toHaveBeenCalledWith({
-      workspaceId: "test-workspace-id",
-      targetPath: "/path/to/plan.md",
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-      editorConfig: expect.any(Object),
-    });
+    // Note: Built-in editors (VS Code/Cursor/Zed) now use deep links directly
+    // via window.open(), not the backend API. The backend API is only used
+    // for custom editors.
   });
 
-  test("shows error toast when editor fails to open", async () => {
-    const context = createMockContext(
-      { success: true, data: { content: "# My Plan", path: "/path/to/plan.md" } },
-      { success: false, error: "No editor configured" }
-    );
-
-    const result = await handlePlanOpenCommand(context);
-
-    expect(result.clearInput).toBe(true);
-    expect(result.toastShown).toBe(true);
-    expect(context.setToast).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: "error",
-        message: "No editor configured",
-      })
-    );
-  });
+  // Note: The "editor fails to open" test was removed because built-in editors
+  // (VS Code/Cursor/Zed) now use deep links that open via window.open() and
+  // always succeed from the app's perspective. Failures happen in the external
+  // editor, not in our code path.
 });
 
 describe("handleCompactCommand", () => {

src/browser/utils/openInEditor.ts

@@ -13,7 +13,6 @@ import {
 import type { RuntimeConfig } from "@/common/types/runtime";
 import { isSSHRuntime, isDockerRuntime } from "@/common/types/runtime";
 import type { APIClient } from "@/browser/contexts/API";
-import { getEditorDeepLinkFallbackUrl } from "@/browser/utils/openInEditorDeepLinkFallback";
 
 export interface OpenInEditorResult {
   success: boolean;
@@ -23,6 +22,13 @@ export interface OpenInEditorResult {
 // Browser mode: window.api is not set (only exists in Electron via preload)
 const isBrowserMode = typeof window !== "undefined" && !window.api;
 
+// Helper for opening URLs - allows testing in Node environment
+function openUrl(url: string): void {
+  if (typeof window !== "undefined" && window.open) {
+    window.open(url, "_blank");
+  }
+}
+
 export async function openInEditor(args: {
   api: APIClient | null | undefined;
   openSettings?: (section?: string) => void;
@@ -88,20 +94,12 @@ export async function openInEditor(args: {
       return { success: false, error: `${editorConfig.editor} does not support Docker containers` };
     }
 
-    window.open(deepLink, "_blank");
+    openUrl(deepLink);
     return { success: true };
   }
 
-  // Browser mode: use deep links instead of backend spawn
-  if (isBrowserMode) {
-    // Custom editor can't work via deep links
-    if (editorConfig.editor === "custom") {
-      return {
-        success: false,
-        error: "Custom editors are not supported in browser mode. Use VS Code, Cursor, or Zed.",
-      };
-    }
-
+  // VS Code / Cursor / Zed: always use deep links (works in browser + Electron)
+  if (editorConfig.editor !== "custom") {
     // Determine SSH host for deep link
     let sshHost: string | undefined;
     if (isSSH && args.runtimeConfig?.type === "ssh") {
@@ -110,7 +108,7 @@ export async function openInEditor(args: {
       if (editorConfig.editor === "zed" && args.runtimeConfig.port != null) {
         sshHost = sshHost + ":" + args.runtimeConfig.port;
       }
-    } else if (!isLocalhost(window.location.hostname)) {
+    } else if (isBrowserMode && !isLocalhost(window.location.hostname)) {
       // Remote server + local workspace: need SSH to reach server's files
       const serverSshHost = await args.api?.server.getSshHost();
       sshHost = serverSshHost ?? window.location.hostname;
@@ -130,11 +128,20 @@ export async function openInEditor(args: {
       };
     }
 
-    window.open(deepLink, "_blank");
+    openUrl(deepLink);
     return { success: true };
   }
 
-  // Electron mode: call the backend API
+  // Custom editor:
+  // - Browser mode: can't spawn processes on the server
+  // - Electron mode: spawn via backend API
+  if (isBrowserMode) {
+    return {
+      success: false,
+      error: "Custom editors are not supported in browser mode. Use VS Code, Cursor, or Zed.",
+    };
+  }
+
   const result = await args.api?.general.openInEditor({
     workspaceId: args.workspaceId,
     targetPath: args.targetPath,
@@ -146,21 +153,6 @@ export async function openInEditor(args: {
   }
 
   if (!result.success) {
-    const deepLink =
-      typeof window === "undefined"
-        ? null
-        : getEditorDeepLinkFallbackUrl({
-            editor: editorConfig.editor,
-            targetPath: args.targetPath,
-            runtimeConfig: args.runtimeConfig,
-            error: result.error,
-          });
-
-    if (deepLink) {
-      window.open(deepLink, "_blank");
-      return { success: true };
-    }
-
     return { success: false, error: result.error };
   }
 

src/browser/utils/openInEditorDeepLinkFallback.test.ts

@@ -1,27 +1,75 @@
 import { describe, expect, test } from "bun:test";
-import { getDetachedSpawnSpec } from "./editorService";
-
-describe("getDetachedSpawnSpec", () => {
-  test("wraps editor command in cmd.exe on Windows", () => {
-    const spec = getDetachedSpawnSpec({
-      platform: "win32",
-      command: "code",
-      args: ["C:\\Users\\Me\\proj"],
+import type { Config } from "@/node/config";
+import type { FrontendWorkspaceMetadata } from "@/common/types/workspace";
+import { EditorService } from "./editorService";
+
+describe("EditorService", () => {
+  test("rejects non-custom editors (renderer must use deep links)", async () => {
+    const editorService = new EditorService({} as Config);
+
+    const result = await editorService.openInEditor("ws1", "/tmp", {
+      editor: "vscode",
     });
 
-    expect(spec).toEqual({
-      command: "cmd.exe",
-      args: ["/d", "/s", "/c", "code", "C:\\Users\\Me\\proj"],
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain("deep links");
+    }
+  });
+
+  test("validates custom editor executable exists before spawning", async () => {
+    const workspace: FrontendWorkspaceMetadata = {
+      id: "ws1",
+      name: "ws1",
+      projectName: "proj",
+      projectPath: "/tmp/proj",
+      createdAt: "2025-01-01T00:00:00.000Z",
+      runtimeConfig: { type: "worktree", srcBaseDir: "/tmp/src" },
+      namedWorkspacePath: "/tmp/src/proj/ws1",
+    };
+
+    const mockConfig: Pick<Config, "getAllWorkspaceMetadata"> = {
+      getAllWorkspaceMetadata: () => Promise.resolve([workspace]),
+    } as unknown as Pick<Config, "getAllWorkspaceMetadata">;
+
+    const editorService = new EditorService(mockConfig as Config);
+
+    const result = await editorService.openInEditor("ws1", "/tmp", {
+      editor: "custom",
+      customCommand: "definitely-not-a-command",
     });
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain("Editor command not found");
+    }
   });
 
-  test("spawns command directly on non-Windows platforms", () => {
-    const spec = getDetachedSpawnSpec({
-      platform: "linux",
-      command: "code",
-      args: ["/home/me/proj"],
+  test("errors on invalid custom editor command quoting", async () => {
+    const workspace: FrontendWorkspaceMetadata = {
+      id: "ws1",
+      name: "ws1",
+      projectName: "proj",
+      projectPath: "/tmp/proj",
+      createdAt: "2025-01-01T00:00:00.000Z",
+      runtimeConfig: { type: "worktree", srcBaseDir: "/tmp/src" },
+      namedWorkspacePath: "/tmp/src/proj/ws1",
+    };
+
+    const mockConfig: Pick<Config, "getAllWorkspaceMetadata"> = {
+      getAllWorkspaceMetadata: () => Promise.resolve([workspace]),
+    } as unknown as Pick<Config, "getAllWorkspaceMetadata">;
+
+    const editorService = new EditorService(mockConfig as Config);
+
+    const result = await editorService.openInEditor("ws1", "/tmp", {
+      editor: "custom",
+      customCommand: '"unterminated',
     });
 
-    expect(spec).toEqual({ command: "code", args: ["/home/me/proj"] });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain("Invalid custom editor command");
+    }
   });
 });