refactor: move shell service to trpc

Author: jonathanlab

ARCHITECTURE.md

@@ -349,7 +349,7 @@ export class MyService extends TypedEventEmitter<MyServiceEvents> {
 
 ### 3. Create Subscriptions in Router
 
-Use a helper to reduce boilerplate:
+Use a helper to reduce boilerplate. For global events (broadcast to all subscribers):
 
 ```typescript
 // src/main/trpc/routers/my-router.ts
@@ -372,17 +372,61 @@ export const myRouter = router({
 });
 ```
 
+For per-instance events (e.g., shell sessions), filter by an identifier:
+
+```typescript
+// Events include an identifier to filter on
+export interface ShellEvents {
+  [ShellEvent.Data]: { sessionId: string; data: string };
+  [ShellEvent.Exit]: { sessionId: string; exitCode: number };
+}
+
+// Router filters events to the specific session
+function subscribeToSession<K extends keyof ShellEvents>(event: K) {
+  return publicProcedure
+    .input(sessionIdInput)
+    .subscription(async function* (opts) {
+      const service = getService();
+      const targetSessionId = opts.input.sessionId;
+
+      for await (const [payload] of on(service, event, { signal: opts.signal })) {
+        const data = payload as ShellEvents[K];
+        if (data.sessionId === targetSessionId) {
+          yield data;
+        }
+      }
+    });
+}
+
+export const shellRouter = router({
+  onData: subscribeToSession(ShellEvent.Data),
+  onExit: subscribeToSession(ShellEvent.Exit),
+});
+```
+
 ### 4. Subscribe in Renderer
 
 ```typescript
-// React component
+// React component - global events
 trpcReact.my.onItemCreated.useSubscription(undefined, {
   enabled: true,
   onData: (item) => {
     // item is typed as { id: string; name: string }
     console.log("Created:", item);
   },
 });
+
+// React component - per-session events
+trpcReact.shell.onData.useSubscription(
+  { sessionId },
+  {
+    enabled: !!sessionId,
+    onData: (event) => {
+      // event is typed as { sessionId: string; data: string }
+      terminal.write(event.data);
+    },
+  },
+);
 ```
 
 ## Code Style

apps/array/src/main/di/container.ts

@@ -6,6 +6,7 @@ import { ExternalAppsService } from "../services/external-apps/service.js";
 import { FileWatcherService } from "../services/file-watcher/service.js";
 import { FsService } from "../services/fs/service.js";
 import { GitService } from "../services/git/service.js";
+import { ShellService } from "../services/shell/service.js";
 import { MAIN_TOKENS } from "./tokens.js";
 
 export const container = new Container({
@@ -18,3 +19,4 @@ container.bind(MAIN_TOKENS.ExternalAppsService).to(ExternalAppsService);
 container.bind(MAIN_TOKENS.FileWatcherService).to(FileWatcherService);
 container.bind(MAIN_TOKENS.FsService).to(FsService);
 container.bind(MAIN_TOKENS.GitService).to(GitService);
+container.bind(MAIN_TOKENS.ShellService).to(ShellService);

apps/array/src/main/di/tokens.ts

@@ -12,4 +12,5 @@ export const MAIN_TOKENS = Object.freeze({
   FileWatcherService: Symbol.for("Main.FileWatcherService"),
   FsService: Symbol.for("Main.FsService"),
   GitService: Symbol.for("Main.GitService"),
+  ShellService: Symbol.for("Main.ShellService"),
 });

apps/array/src/main/index.ts

@@ -43,7 +43,6 @@ import {
   shutdownPostHog,
   trackAppEvent,
 } from "./services/posthog-analytics.js";
-import { registerShellIpc } from "./services/shell.js";
 import { registerAutoUpdater } from "./services/updates.js";
 import { registerWorkspaceIpc } from "./services/workspace/index.js";
 
@@ -297,5 +296,4 @@ registerOAuthHandlers();
 registerGitIpc();
 registerAgentIpc(taskControllers, () => mainWindow);
 registerFoldersIpc(() => mainWindow);
-registerShellIpc();
 registerWorkspaceIpc(() => mainWindow);

apps/array/src/main/preload.ts

@@ -197,28 +197,6 @@ contextBridge.exposeInMainWorld("electronAPI", {
   ): (() => void) => createIpcListener("updates:status", listener),
   onCheckForUpdatesMenu: (listener: () => void): (() => void) =>
     createVoidIpcListener("check-for-updates-menu", listener),
-  shellCreate: (
-    sessionId: string,
-    cwd?: string,
-    taskId?: string,
-  ): Promise<void> =>
-    ipcRenderer.invoke("shell:create", sessionId, cwd, taskId),
-  shellWrite: (sessionId: string, data: string): Promise<void> =>
-    ipcRenderer.invoke("shell:write", sessionId, data),
-  shellResize: (sessionId: string, cols: number, rows: number): Promise<void> =>
-    ipcRenderer.invoke("shell:resize", sessionId, cols, rows),
-  shellCheck: (sessionId: string): Promise<boolean> =>
-    ipcRenderer.invoke("shell:check", sessionId),
-  shellDestroy: (sessionId: string): Promise<void> =>
-    ipcRenderer.invoke("shell:destroy", sessionId),
-  shellGetProcess: (sessionId: string): Promise<string | null> =>
-    ipcRenderer.invoke("shell:get-process", sessionId),
-  onShellData: (
-    sessionId: string,
-    listener: (data: string) => void,
-  ): (() => void) => createIpcListener(`shell:data:${sessionId}`, listener),
-  onShellExit: (sessionId: string, listener: () => void): (() => void) =>
-    createVoidIpcListener(`shell:exit:${sessionId}`, listener),
   folders: {
     getFolders: (): Promise<RegisteredFolder[]> =>
       ipcRenderer.invoke("get-folders"),
@@ -278,9 +256,4 @@ contextBridge.exposeInMainWorld("electronAPI", {
       }>,
     ): (() => void) => createIpcListener("workspace:warning", listener),
   },
-  shellExecute: (
-    cwd: string,
-    command: string,
-  ): Promise<{ stdout: string; stderr: string; exitCode: number }> =>
-    ipcRenderer.invoke("shell:execute", cwd, command),
 });

apps/array/src/main/services/index.ts

@@ -9,6 +9,5 @@ import "./oauth.js";
 import "./posthog-analytics.js";
 import "./session-manager.js";
 import "./settingsStore.js";
-import "./shell.js";
 import "./transcription-prompts.js";
 import "./updates.js";

apps/array/src/main/services/shell.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+
+export const sessionIdInput = z.object({
+  sessionId: z.string(),
+});
+
+export const createInput = sessionIdInput.extend({
+  cwd: z.string().optional(),
+  taskId: z.string().optional(),
+});
+
+export const writeInput = sessionIdInput.extend({
+  data: z.string(),
+});
+
+export const resizeInput = sessionIdInput.extend({
+  cols: z.number(),
+  rows: z.number(),
+});
+
+export const executeInput = z.object({
+  cwd: z.string(),
+  command: z.string(),
+});
+
+export const executeOutput = z.object({
+  stdout: z.string(),
+  stderr: z.string(),
+  exitCode: z.number(),
+});
+
+export type SessionIdInput = z.infer<typeof sessionIdInput>;
+export type CreateInput = z.infer<typeof createInput>;
+export type WriteInput = z.infer<typeof writeInput>;
+export type ResizeInput = z.infer<typeof resizeInput>;
+export type ExecuteInput = z.infer<typeof executeInput>;
+export type ExecuteOutput = z.infer<typeof executeOutput>;
+
+export const ShellEvent = {
+  Data: "data",
+  Exit: "exit",
+} as const;
+
+export interface ShellEvents {
+  [ShellEvent.Data]: { sessionId: string; data: string };
+  [ShellEvent.Exit]: { sessionId: string; exitCode: number };
+}