fix: add scripts IPC infrastructure after rebase

- Add WORKSPACE_LIST_SCRIPTS and WORKSPACE_EXECUTE_SCRIPT IPC channels
- Add listScripts and executeScript to IPCApi interface
- Add IPC handlers in ipcMain.ts for scripts discovery and execution
- Add preload and browser API bindings for scripts
- Fix test imports (WorkspaceChatMessage, DeleteMessage from ipc.ts)
- Fix WorkspaceStore.test.ts mock setup for correct callback pattern
- Add script stubs to App.stories.tsx mocks

This restores scripts functionality after the oRPC system was removed
from main. Scripts are now accessible via standard IPC channels.

Change-Id: I10cf7e1201020efdbc0ffde0d6a89a0464d0d7a7
Signed-off-by: Thomas Kosiewski <tk@coder.com>

Author: ThomasK33

src/browser/App.stories.tsx

@@ -85,6 +85,12 @@ function setupMockAPI(options: {
           success: true,
           data: { success: true, output: "", exitCode: 0, wall_duration_ms: 0 },
         }),
+      listScripts: () => Promise.resolve({ success: true, data: [] }),
+      executeScript: () =>
+        Promise.resolve({
+          success: true,
+          data: { success: true, output: "", exitCode: 0, wall_duration_ms: 0 },
+        }),
     },
     projects: {
       list: () => Promise.resolve(Array.from(mockProjects.entries())),
@@ -1255,6 +1261,12 @@ main
                   data: { success: true, output: "", exitCode: 0, wall_duration_ms: 0 },
                 });
               },
+              listScripts: () => Promise.resolve({ success: true, data: [] }),
+              executeScript: () =>
+                Promise.resolve({
+                  success: true,
+                  data: { success: true, output: "", exitCode: 0, wall_duration_ms: 0 },
+                }),
             },
           },
         });
@@ -1463,6 +1475,12 @@ These tables should render cleanly without any disruptive copy or download actio
                   success: true,
                   data: { success: true, output: "", exitCode: 0, wall_duration_ms: 0 },
                 }),
+              listScripts: () => Promise.resolve({ success: true, data: [] }),
+              executeScript: () =>
+                Promise.resolve({
+                  success: true,
+                  data: { success: true, output: "", exitCode: 0, wall_duration_ms: 0 },
+                }),
             },
           },
         });

src/browser/api.ts

@@ -274,6 +274,10 @@ const webApi: IPCApi = {
     executeBash: (workspaceId, script, options) =>
       invokeIPC(IPC_CHANNELS.WORKSPACE_EXECUTE_BASH, workspaceId, script, options),
     openTerminal: (workspaceId) => invokeIPC(IPC_CHANNELS.WORKSPACE_OPEN_TERMINAL, workspaceId),
+    listScripts: (workspaceId) =>
+      invokeIPC(IPC_CHANNELS.WORKSPACE_LIST_SCRIPTS, workspaceId),
+    executeScript: (workspaceId, scriptName, args) =>
+      invokeIPC(IPC_CHANNELS.WORKSPACE_EXECUTE_SCRIPT, workspaceId, scriptName, args),
     activity: {
       list: async (): Promise<Record<string, WorkspaceActivitySnapshot>> => {
         const response = await invokeIPC<Record<string, unknown>>(

src/browser/stores/WorkspaceStore.test.ts

@@ -1,5 +1,5 @@
 import type { FrontendWorkspaceMetadata } from "@/common/types/workspace";
-import type { WorkspaceChatMessage } from "@/common/orpc/types";
+import type { WorkspaceChatMessage } from "@/common/types/ipc";
 import { createMuxMessage } from "@/common/types/message";
 import type { BashToolResult } from "@/common/types/tools";
 import { DEFAULT_RUNTIME_CONFIG } from "@/common/constants/workspace";
@@ -43,14 +43,8 @@ global.window = mockWindow as unknown as Window & typeof globalThis;
 // Mock dispatchEvent
 global.window.dispatchEvent = jest.fn();
 
-// Helper to get IPC callback in a type-safe way
-function getOnChatCallback<T = { type: string }>(): (data: T) => void {
-  const mock = mockWindow.api.workspace.onChat as jest.Mock<
-    () => void,
-    [string, (data: T) => void]
-  >;
-  return mock.mock.calls[0][1];
-}
+// Reference to mock for easier access
+const mockOnChat = mockWindow.api.workspace.onChat as jest.Mock;
 
 // Helper to create and add a workspace
 function createAndAddWorkspace(
@@ -72,36 +66,24 @@ function createAndAddWorkspace(
 }
 
 // Helper to get callback from mock for pushing messages
-let pendingMessages: WorkspaceChatMessage[] = [];
-let resolvers: Array<(msg: WorkspaceChatMessage) => void> = [];
-
-function getOnChatCallback<T extends WorkspaceChatMessage>(): (msg: T) => void {
-  return (msg: T) => {
-    if (resolvers.length > 0) {
-      const resolver = resolvers.shift()!;
-      resolver(msg);
-    } else {
-      pendingMessages.push(msg);
-    }
-  };
-}
 
-// Set up mock to use push-based message queue
-mockOnChat.mockImplementation(async function* (): AsyncGenerator<
-  WorkspaceChatMessage,
-  void,
-  unknown
-> {
-  while (true) {
-    if (pendingMessages.length > 0) {
-      yield pendingMessages.shift()!;
-    } else {
-      const msg = await new Promise<WorkspaceChatMessage>((resolve) => {
-        resolvers.push(resolve);
-      });
-      yield msg;
-    }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getOnChatCallback<T = any>(): (msg: T) => void {
+  if (!currentChatCallback) {
+    throw new Error("No chat callback registered - was addWorkspace called?");
   }
+  return currentChatCallback as (msg: T) => void;
+}
+
+// Track current chat callback for tests to push messages
+let currentChatCallback: ((msg: WorkspaceChatMessage) => void) | null = null;
+
+// Set up mock to capture the callback and allow tests to push messages
+mockOnChat.mockImplementation((_workspaceId: string, callback: (msg: WorkspaceChatMessage) => void) => {
+  currentChatCallback = callback;
+  return () => {
+    currentChatCallback = null;
+  };
 });
 
 describe("WorkspaceStore", () => {
@@ -112,8 +94,7 @@ describe("WorkspaceStore", () => {
     jest.clearAllMocks();
     mockExecuteBash.mockClear();
     mockOnChat.mockClear();
-    pendingMessages = [];
-    resolvers = [];
+    currentChatCallback = null;
     mockOnModelUsed = jest.fn();
     store = new WorkspaceStore(mockOnModelUsed);
   });
@@ -279,16 +260,15 @@ describe("WorkspaceStore", () => {
         runtimeConfig: DEFAULT_RUNTIME_CONFIG,
       };
 
-      // Add workspace
+      // Add workspace - this will set currentChatCallback
       store.addWorkspace(metadata1);
-      const unsubscribeSpy = jest.fn();
-      (mockWindow.api.workspace.onChat as jest.Mock).mockReturnValue(unsubscribeSpy);
 
       // Sync with empty map (removes all workspaces)
+      // This should unsubscribe from the workspace
       store.syncWorkspaces(new Map());
 
-      // Note: The unsubscribe function from the first add won't be captured
-      // since we mocked it before. In real usage, this would be called.
+      // Verify workspace was removed by checking states
+      expect(store.getAllStates().size).toBe(0);
     });
   });
 

src/browser/utils/messages/StreamingMessageAggregator.test.ts

@@ -1,6 +1,6 @@
 import { createMuxMessage } from "@/common/types/message";
 import type { BashToolResult } from "@/common/types/tools";
-import type { DeleteMessage } from "@/common/orpc/types";
+import type { DeleteMessage } from "@/common/types/ipc";
 import { describe, test, expect } from "bun:test";
 import { StreamingMessageAggregator } from "./StreamingMessageAggregator";
 

src/common/constants/ipc-constants.ts

@@ -35,6 +35,8 @@ export const IPC_CHANNELS = {
   WORKSPACE_STREAM_HISTORY: "workspace:streamHistory",
   WORKSPACE_GET_INFO: "workspace:getInfo",
   WORKSPACE_EXECUTE_BASH: "workspace:executeBash",
+  WORKSPACE_LIST_SCRIPTS: "workspace:listScripts",
+  WORKSPACE_EXECUTE_SCRIPT: "workspace:executeScript",
   WORKSPACE_OPEN_TERMINAL: "workspace:openTerminal",
   WORKSPACE_CHAT_GET_HISTORY: "workspace:chat:getHistory",
   WORKSPACE_CHAT_GET_FULL_REPLAY: "workspace:chat:getFullReplay",

src/common/types/ipc.ts

@@ -1,4 +1,5 @@
 import type { Result } from "./result";
+import type { ScriptInfo } from "@/utils/scripts/discovery";
 import type {
   FrontendWorkspaceMetadata,
   WorkspaceMetadata,
@@ -338,6 +339,12 @@ export interface IPCApi {
       }
     ): Promise<Result<BashToolResult, string>>;
     openTerminal(workspacePath: string): Promise<void>;
+    listScripts(workspaceId: string): Promise<Result<ScriptInfo[], string>>;
+    executeScript(
+      workspaceId: string,
+      scriptName: string,
+      args?: string[]
+    ): Promise<Result<BashToolResult, string>>;
 
     // Event subscriptions (renderer-only)
     // These methods are designed to send current state immediately upon subscription,

src/desktop/preload.ts

@@ -96,6 +96,10 @@ const api: IPCApi = {
     openTerminal: (workspaceId) => {
       return ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_OPEN_TERMINAL, workspaceId);
     },
+    listScripts: (workspaceId) =>
+      ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_LIST_SCRIPTS, workspaceId),
+    executeScript: (workspaceId, scriptName, args) =>
+      ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_EXECUTE_SCRIPT, workspaceId, scriptName, args),
 
     onChat: (workspaceId: string, callback) => {
       const channel = getChatChannel(workspaceId);

src/node/services/ipcMain.ts

@@ -39,6 +39,8 @@ import { InitStateManager } from "@/node/services/initStateManager";
 import { createRuntime } from "@/node/runtime/runtimeFactory";
 import type { RuntimeConfig } from "@/common/types/runtime";
 import { isSSHRuntime } from "@/common/types/runtime";
+import { listScripts } from "@/utils/scripts/discovery";
+import { runWorkspaceScript } from "@/node/services/scriptRunner";
 import { validateProjectPath } from "@/node/utils/pathUtils";
 import { PTYService } from "@/node/services/ptyService";
 import type { TerminalWindowManager } from "@/desktop/terminalWindowManager";
@@ -1426,6 +1428,75 @@ export class IpcMain {
       }
     });
 
+    // Scripts IPC handlers
+    ipcMain.handle(
+      IPC_CHANNELS.WORKSPACE_LIST_SCRIPTS,
+      async (_event, workspaceId: string) => {
+        try {
+          const metadataResult = await this.aiService.getWorkspaceMetadata(workspaceId);
+          if (!metadataResult.success) {
+            return Err(`Failed to get workspace metadata: ${metadataResult.error}`);
+          }
+
+          const metadata = metadataResult.data;
+          const runtimeConfig = metadata.runtimeConfig ?? DEFAULT_RUNTIME_CONFIG;
+          const runtime = createRuntime(runtimeConfig);
+          const workspacePath = runtime.getWorkspacePath(metadata.projectPath, metadata.name);
+
+          const scripts = await listScripts(runtime, workspacePath);
+          return Ok(scripts);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return Err(`Failed to list scripts: ${message}`);
+        }
+      }
+    );
+
+    ipcMain.handle(
+      IPC_CHANNELS.WORKSPACE_EXECUTE_SCRIPT,
+      async (
+        _event,
+        workspaceId: string,
+        scriptName: string,
+        args?: string[]
+      ) => {
+        try {
+          const metadataResult = await this.aiService.getWorkspaceMetadata(workspaceId);
+          if (!metadataResult.success) {
+            return Err(`Failed to get workspace metadata: ${metadataResult.error}`);
+          }
+
+          const metadata = metadataResult.data;
+          const runtimeConfig = metadata.runtimeConfig ?? DEFAULT_RUNTIME_CONFIG;
+          const runtime = createRuntime(runtimeConfig);
+          const workspacePath = runtime.getWorkspacePath(metadata.projectPath, metadata.name);
+
+          // Load project secrets
+          const projectSecrets = this.config.getProjectSecrets(metadata.projectPath);
+
+          const result = await runWorkspaceScript(
+            runtime,
+            workspacePath,
+            scriptName,
+            args ?? [],
+            {
+              secrets: secretsToRecord(projectSecrets),
+              timeoutSecs: 300,
+            }
+          );
+
+          if (!result.success) {
+            return Err(result.error);
+          }
+
+          return Ok(result.data.toolResult);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return Err(`Failed to execute script: ${message}`);
+        }
+      }
+    );
+
     // Debug IPC - only for testing
     ipcMain.handle(
       IPC_CHANNELS.DEBUG_TRIGGER_STREAM_ERROR,