feat: Add IDE opening functionality to Worktrees UI

apps/frontend/src/main/ipc-handlers/settings-handlers.ts

@@ -299,4 +299,88 @@ export function registerSettingsHandlers(
       await shell.openExternal(url);
     }
   );
+
+  ipcMain.handle(
+    IPC_CHANNELS.SHELL_OPEN_PATH,
+    async (_, folderPath: string): Promise<void> => {
+      await shell.openPath(folderPath);
+    }
+  );
+
+  ipcMain.handle(
+    IPC_CHANNELS.SHELL_OPEN_IN_IDE,
+    async (_, folderPath: string, ide?: 'cursor' | 'vscode' | 'finder'): Promise<IPCResult> => {
+      try {
+        // Validate path exists
+        if (!existsSync(folderPath)) {
+          return { success: false, error: `Path does not exist: ${folderPath}` };
+        }
+
+        // Determine which IDE to use
+        const ideToUse = ide || 'cursor'; // Default to Cursor
+
+        if (ideToUse === 'finder') {
+          // Open in Finder (macOS) or Explorer (Windows)
+          await shell.openPath(folderPath);
+          return { success: true };
+        }
+
+        // Try to open in the specified IDE
+        const commands: Record<string, string[]> = {
+          cursor: ['cursor', '.'],
+          vscode: ['code', '.']
+        };
+
+        const [cmd, ...args] = commands[ideToUse] || commands.cursor;
+
+        try {
+          // Use execSync to run the command - this opens the IDE
+          execSync(`${cmd} ${args.join(' ')}`, {
+            cwd: folderPath,
+            stdio: 'ignore',
+            timeout: 5000
+          });
+          return { success: true };
+        } catch (execError) {
+          // If the command fails, try alternative approaches
+          console.warn(`[SHELL_OPEN_IN_IDE] ${cmd} command failed:`, execError);
+
+          // On macOS, try using 'open' command with the app
+          if (process.platform === 'darwin') {
+            const appNames: Record<string, string[]> = {
+              cursor: ['Cursor', 'Cursor.app'],
+              vscode: ['Visual Studio Code', 'Visual Studio Code.app', 'VSCode', 'Code']
+            };
+
+            const apps = appNames[ideToUse] || appNames.cursor;
+            for (const appName of apps) {
+              try {
+                execSync(`open -a "${appName}" "${folderPath}"`, {
+                  stdio: 'ignore',
+                  timeout: 5000
+                });
+                return { success: true };
+              } catch {
+                // Try next app name
+                continue;
+              }
+            }
+          }
+
+          // Fallback: open in Finder/Explorer
+          console.warn(`[SHELL_OPEN_IN_IDE] Falling back to system file browser`);
+          await shell.openPath(folderPath);
+          return {
+            success: true,
+            error: `${ideToUse} not found. Opened in file browser instead.`
+          };
+        }
+      } catch (error) {
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : 'Failed to open in IDE'
+        };
+      }
+    }
+  );
 }

apps/frontend/src/preload/api/modules/shell-api.ts

@@ -1,17 +1,28 @@
 import { IPC_CHANNELS } from '../../../shared/constants';
 import { invokeIpc } from './ipc-utils';
 
+/**
+ * IDE types supported for opening folders
+ */
+export type IDEType = 'cursor' | 'vscode' | 'finder';
+
 /**
  * Shell Operations API
  */
 export interface ShellAPI {
   openExternal: (url: string) => Promise<void>;
+  openPath: (path: string) => Promise<void>;
+  openInIde: (path: string, ide?: IDEType) => Promise<{ success: boolean; error?: string }>;
 }
 
 /**
  * Creates the Shell Operations API implementation
  */
 export const createShellAPI = (): ShellAPI => ({
   openExternal: (url: string): Promise<void> =>
-    invokeIpc(IPC_CHANNELS.SHELL_OPEN_EXTERNAL, url)
+    invokeIpc(IPC_CHANNELS.SHELL_OPEN_EXTERNAL, url),
+  openPath: (path: string): Promise<void> =>
+    invokeIpc(IPC_CHANNELS.SHELL_OPEN_PATH, path),
+  openInIde: (path: string, ide?: IDEType): Promise<{ success: boolean; error?: string }> =>
+    invokeIpc(IPC_CHANNELS.SHELL_OPEN_IN_IDE, path, ide)
 });

apps/frontend/src/renderer/components/Worktrees.tsx

@@ -12,7 +12,9 @@ import {
   Minus,
   ChevronRight,
   Check,
-  X
+  X,
+  Code2,
+  ExternalLink
 } from 'lucide-react';
 import { Button } from './ui/button';
 import { Badge } from './ui/badge';
@@ -305,13 +307,41 @@ export function Worktrees({ projectId }: WorktreesProps) {
                       <Button
                         variant="outline"
                         size="sm"
-                        onClick={() => {
-                          // Copy worktree path to clipboard
-                          navigator.clipboard.writeText(worktree.path);
+                        onClick={async () => {
+                          // Open in Cursor (default IDE)
+                          const result = await window.electronAPI.openInIde(worktree.path, 'cursor');
+                          if (!result.success) {
+                            setError(result.error || 'Failed to open in Cursor');
+                          }
+                        }}
+                      >
+                        <Code2 className="h-3.5 w-3.5 mr-1.5" />
+                        Open in Cursor
+                      </Button>
+                      <Button
+                        variant="outline"
+                        size="sm"
+                        onClick={async () => {
+                          // Open in VS Code
+                          const result = await window.electronAPI.openInIde(worktree.path, 'vscode');
+                          if (!result.success) {
+                            setError(result.error || 'Failed to open in VS Code');
+                          }
+                        }}
+                      >
+                        <ExternalLink className="h-3.5 w-3.5 mr-1.5" />
+                        VS Code
+                      </Button>
+                      <Button
+                        variant="outline"
+                        size="sm"
+                        onClick={async () => {
+                          // Open in Finder
+                          await window.electronAPI.openInIde(worktree.path, 'finder');
                         }}
                       >
                         <FolderOpen className="h-3.5 w-3.5 mr-1.5" />
-                        Copy Path
+                        Finder
                       </Button>
                       <Button
                         variant="outline"

apps/frontend/src/renderer/lib/mocks/settings-mock.ts

@@ -24,5 +24,18 @@ export const settingsMock = {
   // App Update Event Listeners (no-op in browser mode)
   onAppUpdateAvailable: () => () => {},
   onAppUpdateDownloaded: () => () => {},
-  onAppUpdateProgress: () => () => {}
+  onAppUpdateProgress: () => () => {},
+
+  // Shell Operations (limited functionality in browser mode)
+  openExternal: async (url: string) => {
+    console.warn('[browser-mock] openExternal called with:', url);
+    window.open(url, '_blank');
+  },
+  openPath: async (path: string) => {
+    console.warn('[browser-mock] openPath called with:', path);
+  },
+  openInIde: async (path: string, ide?: string) => {
+    console.warn('[browser-mock] openInIde called with:', path, ide);
+    return { success: false, error: 'IDE opening not supported in browser mode' };
+  }
 };

apps/frontend/src/shared/constants/ipc.ts

@@ -117,6 +117,8 @@ export const IPC_CHANNELS = {
 
   // Shell operations
   SHELL_OPEN_EXTERNAL: 'shell:openExternal',
+  SHELL_OPEN_PATH: 'shell:openPath',           // Open folder in Finder/Explorer
+  SHELL_OPEN_IN_IDE: 'shell:openInIde',        // Open folder in VS Code/Cursor
 
   // Roadmap operations
   ROADMAP_GET: 'roadmap:get',

apps/frontend/src/shared/types/ipc.ts

@@ -448,6 +448,8 @@ export interface ElectronAPI {
 
   // Shell operations
   openExternal: (url: string) => Promise<void>;
+  openPath: (path: string) => Promise<void>;
+  openInIde: (path: string, ide?: 'cursor' | 'vscode' | 'finder') => Promise<IPCResult>;
 
   // Auto Claude source environment operations
   getSourceEnv: () => Promise<IPCResult<SourceEnvConfig>>;