Merge branch 'main' of github.com:PostHog/Array into feat/cancel-prompt

Author: jonathanlab

README.md

@@ -126,3 +126,42 @@ Clean up Docker containers:
   }
 }
 ```
+
+## Workspace Environment Variables
+
+Array automatically sets environment variables in all workspace terminals and scripts. These are available in `init`, `start`, and `destroy` scripts, as well as any terminal sessions opened within a workspace.
+
+| Variable | Description | Example |
+|----------|-------------|---------|
+| `ARRAY_WORKSPACE_NAME` | Worktree name, or folder name in root mode | `my-feature-branch` |
+| `ARRAY_WORKSPACE_PATH` | Absolute path to the workspace | `/Users/dev/.array/worktrees/repo/my-feature` |
+| `ARRAY_ROOT_PATH` | Absolute path to the repository root | `/Users/dev/repos/my-project` |
+| `ARRAY_DEFAULT_BRANCH` | Default branch detected from git | `main` |
+| `ARRAY_WORKSPACE_BRANCH` | Initial branch when workspace was created | `array/my-feature` |
+| `ARRAY_WORKSPACE_PORTS` | Comma-separated list of allocated ports | `50000,50001,...,50019` |
+| `ARRAY_WORKSPACE_PORTS_RANGE` | Number of ports allocated | `20` |
+| `ARRAY_WORKSPACE_PORTS_START` | First port in the range | `50000` |
+| `ARRAY_WORKSPACE_PORTS_END` | Last port in the range | `50019` |
+
+Note: `ARRAY_WORKSPACE_BRANCH` reflects the branch at workspace creation time. If you or the agent checks out a different branch, this variable will still show the original branch name.
+
+### Port Allocation
+
+Each workspace is assigned a unique range of 20 ports starting from port 50000. The allocation is deterministic based on the task ID, so the same workspace always receives the same ports across restarts.
+
+### Usage Examples
+
+Use ports in your start scripts:
+```json
+{
+  "scripts": {
+    "start": "npm run dev -- --port $ARRAY_WORKSPACE_PORTS_START"
+  }
+}
+```
+
+Reference the workspace path:
+```bash
+echo "Working in: $ARRAY_WORKSPACE_NAME"
+echo "Root repo: $ARRAY_ROOT_PATH"
+```

apps/array/src/main/lib/shellManager.ts

@@ -21,7 +21,9 @@ function getDefaultShell(): string {
   return process.env.SHELL || "/bin/bash";
 }
 
-function buildShellEnv(): Record<string, string> {
+function buildShellEnv(
+  additionalEnv?: Record<string, string>,
+): Record<string, string> {
   const env = { ...process.env } as Record<string, string>;
 
   if (os.platform() === "darwin" && !process.env.LC_ALL) {
@@ -38,6 +40,10 @@ function buildShellEnv(): Record<string, string> {
   env.COLORTERM = "truecolor";
   env.FORCE_COLOR = "3";
 
+  if (additionalEnv) {
+    Object.assign(env, additionalEnv);
+  }
+
   return env;
 }
 
@@ -46,13 +52,15 @@ export interface CreateSessionOptions {
   webContents: WebContents;
   cwd?: string;
   initialCommand?: string;
+  additionalEnv?: Record<string, string>;
 }
 
 class ShellManagerImpl {
   private sessions = new Map<string, ShellSession>();
 
   createSession(options: CreateSessionOptions): ShellSession {
-    const { sessionId, webContents, cwd, initialCommand } = options;
+    const { sessionId, webContents, cwd, initialCommand, additionalEnv } =
+      options;
 
     const existing = this.sessions.get(sessionId);
     if (existing) {
@@ -74,7 +82,7 @@ class ShellManagerImpl {
       `Creating shell session ${sessionId}: shell=${shell}, cwd=${workingDir}`,
     );
 
-    const env = buildShellEnv();
+    const env = buildShellEnv(additionalEnv);
     const ptyProcess = pty.spawn(shell, ["-l"], {
       name: "xterm-256color",
       cols: 80,

apps/array/src/main/preload.ts

@@ -185,6 +185,7 @@ contextBridge.exposeInMainWorld("electronAPI", {
     apiHost: string;
     projectId: number;
     logUrl?: string;
+    sdkSessionId?: string;
   }): Promise<{ sessionId: string; channel: string } | null> =>
     ipcRenderer.invoke("agent-reconnect", params),
   onAgentEvent: (
@@ -303,9 +304,12 @@ contextBridge.exposeInMainWorld("electronAPI", {
     createVoidIpcListener("updates:ready", listener),
   installUpdate: (): Promise<{ installed: boolean }> =>
     ipcRenderer.invoke("updates:install"),
-  // Shell API
-  shellCreate: (sessionId: string, cwd?: string): Promise<void> =>
-    ipcRenderer.invoke("shell:create", sessionId, cwd),
+  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> =>

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

@@ -106,19 +106,30 @@ export const showTaskContextMenuService = createIpcService({
     worktreePath?: string,
   ): Promise<TaskContextMenuResult> => {
     return new Promise((resolve) => {
+      let pendingDialog = false;
+      let resolved = false;
+
+      const safeResolve = (result: TaskContextMenuResult) => {
+        if (!resolved) {
+          resolved = true;
+          resolve(result);
+        }
+      };
+
       const template: MenuItemConstructorOptions[] = [
         {
           label: "Rename",
-          click: () => resolve({ action: "rename" }),
+          click: () => safeResolve({ action: "rename" }),
         },
         {
           label: "Duplicate",
-          click: () => resolve({ action: "duplicate" }),
+          click: () => safeResolve({ action: "duplicate" }),
         },
         { type: "separator" },
         {
           label: "Delete",
           click: async () => {
+            pendingDialog = true;
             const result = await dialog.showMessageBox({
               type: "question",
               title: "Delete Task",
@@ -132,9 +143,9 @@ export const showTaskContextMenuService = createIpcService({
             });
 
             if (result.response === 1) {
-              resolve({ action: "delete" });
+              safeResolve({ action: "delete" });
             } else {
-              resolve({ action: null });
+              safeResolve({ action: null });
             }
           },
         },
@@ -145,12 +156,19 @@ export const showTaskContextMenuService = createIpcService({
           template.push({ type: "separator" });
           const externalAppsItems = await buildExternalAppsMenuItems(
             worktreePath,
-            resolve,
+            safeResolve,
           );
           template.push(...externalAppsItems);
         }
 
-        showContextMenu(template, { action: null }).then(resolve);
+        const menu = Menu.buildFromTemplate(template);
+        menu.popup({
+          callback: () => {
+            if (!pendingDialog) {
+              safeResolve({ action: null });
+            }
+          },
+        });
       };
 
       setupMenu();
@@ -167,10 +185,21 @@ export const showFolderContextMenuService = createIpcService({
     folderPath?: string,
   ): Promise<FolderContextMenuResult> => {
     return new Promise((resolve) => {
+      let pendingDialog = false;
+      let resolved = false;
+
+      const safeResolve = (result: FolderContextMenuResult) => {
+        if (!resolved) {
+          resolved = true;
+          resolve(result);
+        }
+      };
+
       const template: MenuItemConstructorOptions[] = [
         {
           label: "Remove folder",
           click: async () => {
+            pendingDialog = true;
             const result = await dialog.showMessageBox({
               type: "question",
               title: "Remove Folder",
@@ -183,9 +212,9 @@ export const showFolderContextMenuService = createIpcService({
             });
 
             if (result.response === 1) {
-              resolve({ action: "remove" });
+              safeResolve({ action: "remove" });
             } else {
-              resolve({ action: null });
+              safeResolve({ action: null });
             }
           },
         },
@@ -196,12 +225,19 @@ export const showFolderContextMenuService = createIpcService({
           template.push({ type: "separator" });
           const externalAppsItems = await buildExternalAppsMenuItems(
             folderPath,
-            resolve,
+            safeResolve,
           );
           template.push(...externalAppsItems);
         }
 
-        showContextMenu(template, { action: null }).then(resolve);
+        const menu = Menu.buildFromTemplate(template);
+        menu.popup({
+          callback: () => {
+            if (!pendingDialog) {
+              safeResolve({ action: null });
+            }
+          },
+        });
       };
 
       setupMenu();

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

@@ -77,7 +77,7 @@ export const getRemoteUrl = async (
   }
 };
 
-const getCurrentBranch = async (
+export const getCurrentBranch = async (
   directoryPath: string,
 ): Promise<string | undefined> => {
   try {
@@ -90,7 +90,9 @@ const getCurrentBranch = async (
   }
 };
 
-const getDefaultBranch = async (directoryPath: string): Promise<string> => {
+export const getDefaultBranch = async (
+  directoryPath: string,
+): Promise<string> => {
   try {
     // Try to get the default branch from origin
     const { stdout } = await execAsync(

apps/array/src/main/services/session-manager.ts

@@ -122,6 +122,7 @@ export interface SessionConfig {
   repoPath: string;
   credentials: PostHogCredentials;
   logUrl?: string; // For reconnection from S3
+  sdkSessionId?: string; // SDK session ID for resuming Claude Code context
 }
 
 export interface ManagedSession {
@@ -171,7 +172,8 @@ export class SessionManager {
     config: SessionConfig,
     isReconnect: boolean,
   ): Promise<ManagedSession | null> {
-    const { taskId, taskRunId, repoPath, credentials, logUrl } = config;
+    const { taskId, taskRunId, repoPath, credentials, logUrl, sdkSessionId } =
+      config;
 
     const existing = this.sessions.get(taskRunId);
     if (existing) {
@@ -214,9 +216,12 @@ export class SessionManager {
           sessionId: taskRunId,
           cwd: repoPath,
           mcpServers: [],
-          _meta: logUrl
-            ? { persistence: { taskId, runId: taskRunId, logUrl } }
-            : undefined,
+          _meta: {
+            ...(logUrl && {
+              persistence: { taskId, runId: taskRunId, logUrl },
+            }),
+            ...(sdkSessionId && { sdkSessionId }),
+          },
         });
       } else {
         await connection.newSession({
@@ -452,6 +457,7 @@ interface AgentSessionParams {
   apiHost: string;
   projectId: number;
   logUrl?: string;
+  sdkSessionId?: string;
 }
 
 type SessionResponse = { sessionId: string; channel: string };
@@ -480,6 +486,7 @@ function toSessionConfig(params: AgentSessionParams): SessionConfig {
       projectId: params.projectId,
     },
     logUrl: params.logUrl,
+    sdkSessionId: params.sdkSessionId,
   };
 }
 

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

@@ -1,16 +1,38 @@
 import { createIpcHandler } from "../lib/ipcHandler";
 import { shellManager } from "../lib/shellManager";
+import { foldersStore } from "./store";
+import { buildWorkspaceEnv } from "./workspace/workspaceEnv";
 
 const handle = createIpcHandler("shell");
 
 export function registerShellIpc(): void {
-  handle("shell:create", (event, sessionId: string, cwd?: string) => {
-    shellManager.createSession({
-      sessionId,
-      webContents: event.sender,
-      cwd,
-    });
-  });
+  handle(
+    "shell:create",
+    async (event, sessionId: string, cwd?: string, taskId?: string) => {
+      let additionalEnv: Record<string, string> | undefined;
+
+      if (taskId) {
+        const associations = foldersStore.get("taskAssociations", []);
+        const association = associations.find((a) => a.taskId === taskId);
+        if (association && association.mode !== "cloud") {
+          additionalEnv = await buildWorkspaceEnv({
+            taskId,
+            folderPath: association.folderPath,
+            worktreePath: association.worktree?.worktreePath ?? null,
+            worktreeName: association.worktree?.worktreeName ?? null,
+            mode: association.mode,
+          });
+        }
+      }
+
+      shellManager.createSession({
+        sessionId,
+        webContents: event.sender,
+        cwd,
+        additionalEnv,
+      });
+    },
+  );
 
   handle("shell:write", (_event, sessionId: string, data: string) => {
     shellManager.write(sessionId, data);

apps/array/src/main/services/workspace/configLoader.ts

@@ -59,8 +59,6 @@ export async function loadConfig(
     return { config: null, source: null };
   }
 
-  // No config found
-  log.debug(`No array.json config found for workspace ${worktreeName}`);
   return { config: null, source: null };
 }