@xelauvas/xela-cli 0.1.0

package/src/utils/computerUse/wrapper.tsx

@@ -0,0 +1,336 @@
+/**
+ * The `.call()` override — thin adapter between `ToolUseContext` and
+ * `bindSessionContext`. Spread into the MCP tool object in `client.ts`
+ * (same pattern as Chrome's rendering overrides, plus `.call()`).
+ *
+ * The wrapper-closure logic (build overrides fresh, lock gate, permission
+ * merge, screenshot stash) lives in `@ant/computer-use-mcp`'s
+ * `bindSessionContext`. This file binds it once per process,
+ * caches the dispatcher, and updates a per-call ref for the pieces of
+ * `ToolUseContext` that vary per-call (`abortController`, `setToolJSX`,
+ * `sendOSNotification`). AppState accessors are read through the ref too —
+ * they're likely stable but we don't depend on that.
+ *
+ * External callers reach this via the lazy require thunk in `client.ts`, gated
+ * on `feature('CHICAGO_MCP')`. Runtime enablement is controlled by the
+ * GrowthBook gate `tengu_malort_pedway` (see gates.ts).
+ */
+
+import { bindSessionContext, type ComputerUseSessionContext, type CuCallToolResult, type CuPermissionRequest, type CuPermissionResponse, DEFAULT_GRANT_FLAGS, type ScreenshotDims } from '@ant/computer-use-mcp';
+import * as React from 'react';
+import { getSessionId } from '../../bootstrap/state.js';
+import { ComputerUseApproval } from '../../components/permissions/ComputerUseApproval/ComputerUseApproval.js';
+import type { Tool, ToolUseContext } from '../../Tool.js';
+import { logForDebugging } from '../debug.js';
+import { checkComputerUseLock, tryAcquireComputerUseLock } from './computerUseLock.js';
+import { registerEscHotkey } from './escHotkey.js';
+import { getChicagoCoordinateMode } from './gates.js';
+import { getComputerUseHostAdapter } from './hostAdapter.js';
+import { getComputerUseMCPRenderingOverrides } from './toolRendering.js';
+type CallOverride = Pick<Tool, 'call'>['call'];
+type Binding = {
+  ctx: ComputerUseSessionContext;
+  dispatch: (name: string, args: unknown) => Promise<CuCallToolResult>;
+};
+
+/**
+ * Cached binding — built on first `.call()`, reused for process lifetime.
+ * The dispatcher's closure-held screenshot blob persists across calls.
+ *
+ * `currentToolUseContext` is updated on every call. Every getter/callback in
+ * `ctx` reads through it, so the per-call pieces (`abortController`,
+ * `setToolJSX`, `sendOSNotification`) are always current.
+ *
+ * Module-level `let` is a deliberate exception to the no-module-scope-state
+ * rule (src/CLAUDE.md): the dispatcher closure must persist across calls so
+ * its internal screenshot blob survives, but `ToolUseContext` is per-call.
+ * Tests will need to either inject the cache or run serially.
+ */
+let binding: Binding | undefined;
+let currentToolUseContext: ToolUseContext | undefined;
+function tuc(): ToolUseContext {
+  // Safe: `binding` is only populated when `currentToolUseContext` is set.
+  // Called only from within `ctx` callbacks, which only fire during dispatch.
+  return currentToolUseContext!;
+}
+function formatLockHeld(holder: string): string {
+  return `Computer use is in use by another Claude session (${holder.slice(0, 8)}…). Wait for that session to finish or run /exit there.`;
+}
+export function buildSessionContext(): ComputerUseSessionContext {
+  return {
+    // ── Read state fresh via the per-call ref ─────────────────────────────
+    getAllowedApps: () => tuc().getAppState().computerUseMcpState?.allowedApps ?? [],
+    getGrantFlags: () => tuc().getAppState().computerUseMcpState?.grantFlags ?? DEFAULT_GRANT_FLAGS,
+    // cc-2 has no Settings page for user-denied apps yet.
+    getUserDeniedBundleIds: () => [],
+    getSelectedDisplayId: () => tuc().getAppState().computerUseMcpState?.selectedDisplayId,
+    getDisplayPinnedByModel: () => tuc().getAppState().computerUseMcpState?.displayPinnedByModel ?? false,
+    getDisplayResolvedForApps: () => tuc().getAppState().computerUseMcpState?.displayResolvedForApps,
+    getLastScreenshotDims: (): ScreenshotDims | undefined => {
+      const d = tuc().getAppState().computerUseMcpState?.lastScreenshotDims;
+      return d ? {
+        ...d,
+        displayId: d.displayId ?? 0,
+        originX: d.originX ?? 0,
+        originY: d.originY ?? 0
+      } : undefined;
+    },
+    // ── Write-backs ────────────────────────────────────────────────────────
+    // `setToolJSX` is guaranteed present — the gate in `main.tsx` excludes
+    // non-interactive sessions. The package's `_dialogSignal` (tool-finished
+    // dismissal) is irrelevant here: `setToolJSX` blocks the tool call, so
+    // the dialog can't outlive it. Ctrl+C is what matters, and
+    // `runPermissionDialog` wires that from the per-call ref's abortController.
+    onPermissionRequest: (req, _dialogSignal) => runPermissionDialog(req),
+    // Package does the merge (dedupe + truthy-only flags). We just persist.
+    onAllowedAppsChanged: (apps, flags) => tuc().setAppState(prev => {
+      const cu = prev.computerUseMcpState;
+      const prevApps = cu?.allowedApps;
+      const prevFlags = cu?.grantFlags;
+      const sameApps = prevApps?.length === apps.length && apps.every((a, i) => prevApps[i]?.bundleId === a.bundleId);
+      const sameFlags = prevFlags?.clipboardRead === flags.clipboardRead && prevFlags?.clipboardWrite === flags.clipboardWrite && prevFlags?.systemKeyCombos === flags.systemKeyCombos;
+      return sameApps && sameFlags ? prev : {
+        ...prev,
+        computerUseMcpState: {
+          ...cu,
+          allowedApps: [...apps],
+          grantFlags: flags
+        }
+      };
+    }),
+    onAppsHidden: ids => {
+      if (ids.length === 0) return;
+      tuc().setAppState(prev => {
+        const cu = prev.computerUseMcpState;
+        const existing = cu?.hiddenDuringTurn;
+        if (existing && ids.every(id => existing.has(id))) return prev;
+        return {
+          ...prev,
+          computerUseMcpState: {
+            ...cu,
+            hiddenDuringTurn: new Set([...(existing ?? []), ...ids])
+          }
+        };
+      });
+    },
+    // Resolver writeback only fires under a pin when Swift fell back to main
+    // (pinned display unplugged) — the pin is semantically dead, so clear it
+    // and the app-set key so the chase chain runs next time. When autoResolve
+    // was true, onDisplayResolvedForApps re-sets the key in the same tick.
+    onResolvedDisplayUpdated: id => tuc().setAppState(prev => {
+      const cu = prev.computerUseMcpState;
+      if (cu?.selectedDisplayId === id && !cu.displayPinnedByModel && cu.displayResolvedForApps === undefined) {
+        return prev;
+      }
+      return {
+        ...prev,
+        computerUseMcpState: {
+          ...cu,
+          selectedDisplayId: id,
+          displayPinnedByModel: false,
+          displayResolvedForApps: undefined
+        }
+      };
+    }),
+    // switch_display(name) pins; switch_display("auto") unpins and clears the
+    // app-set key so the next screenshot auto-resolves fresh.
+    onDisplayPinned: id => tuc().setAppState(prev => {
+      const cu = prev.computerUseMcpState;
+      const pinned = id !== undefined;
+      const nextResolvedFor = pinned ? cu?.displayResolvedForApps : undefined;
+      if (cu?.selectedDisplayId === id && cu?.displayPinnedByModel === pinned && cu?.displayResolvedForApps === nextResolvedFor) {
+        return prev;
+      }
+      return {
+        ...prev,
+        computerUseMcpState: {
+          ...cu,
+          selectedDisplayId: id,
+          displayPinnedByModel: pinned,
+          displayResolvedForApps: nextResolvedFor
+        }
+      };
+    }),
+    onDisplayResolvedForApps: key => tuc().setAppState(prev => {
+      const cu = prev.computerUseMcpState;
+      if (cu?.displayResolvedForApps === key) return prev;
+      return {
+        ...prev,
+        computerUseMcpState: {
+          ...cu,
+          displayResolvedForApps: key
+        }
+      };
+    }),
+    onScreenshotCaptured: dims => tuc().setAppState(prev => {
+      const cu = prev.computerUseMcpState;
+      const p = cu?.lastScreenshotDims;
+      return p?.width === dims.width && p?.height === dims.height && p?.displayWidth === dims.displayWidth && p?.displayHeight === dims.displayHeight && p?.displayId === dims.displayId && p?.originX === dims.originX && p?.originY === dims.originY ? prev : {
+        ...prev,
+        computerUseMcpState: {
+          ...cu,
+          lastScreenshotDims: dims
+        }
+      };
+    }),
+    // ── Lock — async, direct file-lock calls ───────────────────────────────
+    // No `lockHolderForGate` dance: the package's gate is async now. It
+    // awaits `checkCuLock`, and on `holder: undefined` + non-deferring tool
+    // awaits `acquireCuLock`. `defersLockAcquire` is the PACKAGE's set —
+    // the local copy is gone.
+    checkCuLock: async () => {
+      const c = await checkComputerUseLock();
+      switch (c.kind) {
+        case 'free':
+          return {
+            holder: undefined,
+            isSelf: false
+          };
+        case 'held_by_self':
+          return {
+            holder: getSessionId(),
+            isSelf: true
+          };
+        case 'blocked':
+          return {
+            holder: c.by,
+            isSelf: false
+          };
+      }
+    },
+    // Called only when checkCuLock returned `holder: undefined`. The O_EXCL
+    // acquire is atomic — if another process grabbed it in the gap (rare),
+    // throw so the tool fails instead of proceeding without the lock.
+    // `fresh: false` (re-entrant) shouldn't happen given check said free,
+    // but is possible under parallel tool-use interleaving — don't spam the
+    // notification in that case.
+    acquireCuLock: async () => {
+      const r = await tryAcquireComputerUseLock();
+      if (r.kind === 'blocked') {
+        throw new Error(formatLockHeld(r.by));
+      }
+      if (r.fresh) {
+        // Global Escape → abort. Consumes the event (PI defense — prompt
+        // injection can't dismiss dialogs with Escape). The CGEventTap's
+        // CFRunLoopSource is processed by the drainRunLoop pump, so this
+        // holds a pump retain until unregisterEscHotkey() in cleanup.ts.
+        const escRegistered = registerEscHotkey(() => {
+          logForDebugging('[cu-esc] user escape, aborting turn');
+          tuc().abortController.abort();
+        });
+        tuc().sendOSNotification?.({
+          message: escRegistered ? 'Claude is using your computer · press Esc to stop' : 'Claude is using your computer · press Ctrl+C to stop',
+          notificationType: 'computer_use_enter'
+        });
+      }
+    },
+    formatLockHeldMessage: formatLockHeld
+  };
+}
+function getOrBind(): Binding {
+  if (binding) return binding;
+  const ctx = buildSessionContext();
+  binding = {
+    ctx,
+    dispatch: bindSessionContext(getComputerUseHostAdapter(), getChicagoCoordinateMode(), ctx)
+  };
+  return binding;
+}
+
+/**
+ * Returns the full override object for a single `mcp__computer-use__{toolName}`
+ * tool: rendering overrides from `toolRendering.tsx` plus a `.call()` that
+ * dispatches through the cached binder.
+ */
+type ComputerUseMCPToolOverrides = ReturnType<typeof getComputerUseMCPRenderingOverrides> & {
+  call: CallOverride;
+};
+export function getComputerUseMCPToolOverrides(toolName: string): ComputerUseMCPToolOverrides {
+  const call: CallOverride = async (args, context: ToolUseContext) => {
+    currentToolUseContext = context;
+    const {
+      dispatch
+    } = getOrBind();
+    const {
+      telemetry,
+      ...result
+    } = await dispatch(toolName, args);
+    if (telemetry?.error_kind) {
+      logForDebugging(`[Computer Use MCP] ${toolName} error_kind=${telemetry.error_kind}`);
+    }
+
+    // MCP content blocks → Anthropic API blocks. CU only produces text and
+    // pre-sized JPEG (executor.ts computeTargetDims → targetImageSize), so
+    // unlike the generic MCP path there's no resize needed — the MCP image
+    // shape just maps to the API's base64-source shape. The package's result
+    // type admits audio/resource too, but CU's handleToolCall never emits
+    // those; the fallthrough coerces them to empty text.
+    const data = Array.isArray(result.content) ? result.content.map(item => item.type === 'image' ? {
+      type: 'image' as const,
+      source: {
+        type: 'base64' as const,
+        media_type: item.mimeType ?? 'image/jpeg',
+        data: item.data
+      }
+    } : {
+      type: 'text' as const,
+      text: item.type === 'text' ? item.text : ''
+    }) : result.content;
+    return {
+      data
+    };
+  };
+  return {
+    ...getComputerUseMCPRenderingOverrides(toolName),
+    call
+  };
+}
+
+/**
+ * Render the approval dialog mid-call via `setToolJSX` + `Promise`, wait for
+ * the user. Mirrors `spawnMultiAgent.ts:419-436` (the `It2SetupPrompt` pattern).
+ *
+ * The merge-into-AppState that used to live here (dedupe + truthy-only flags)
+ * is now in the package's `bindSessionContext` → `onAllowedAppsChanged`.
+ */
+async function runPermissionDialog(req: CuPermissionRequest): Promise<CuPermissionResponse> {
+  const context = tuc();
+  const setToolJSX = context.setToolJSX;
+  if (!setToolJSX) {
+    // Shouldn't happen — main.tsx gate excludes non-interactive. Fail safe.
+    return {
+      granted: [],
+      denied: [],
+      flags: DEFAULT_GRANT_FLAGS
+    };
+  }
+  try {
+    return await new Promise<CuPermissionResponse>((resolve, reject) => {
+      const signal = context.abortController.signal;
+      // If already aborted, addEventListener won't fire — reject now so the
+      // promise doesn't hang waiting for a user who Ctrl+C'd.
+      if (signal.aborted) {
+        reject(new Error('Computer Use permission dialog aborted'));
+        return;
+      }
+      const onAbort = (): void => {
+        signal.removeEventListener('abort', onAbort);
+        reject(new Error('Computer Use permission dialog aborted'));
+      };
+      signal.addEventListener('abort', onAbort);
+      setToolJSX({
+        jsx: React.createElement(ComputerUseApproval, {
+          request: req,
+          onDone: (resp: CuPermissionResponse) => {
+            signal.removeEventListener('abort', onAbort);
+            resolve(resp);
+          }
+        }),
+        shouldHidePromptInput: true
+      });
+    });
+  } finally {
+    setToolJSX(null);
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["bindSessionContext","ComputerUseSessionContext","CuCallToolResult","CuPermissionRequest","CuPermissionResponse","DEFAULT_GRANT_FLAGS","ScreenshotDims","React","getSessionId","ComputerUseApproval","Tool","ToolUseContext","logForDebugging","checkComputerUseLock","tryAcquireComputerUseLock","registerEscHotkey","getChicagoCoordinateMode","getComputerUseHostAdapter","getComputerUseMCPRenderingOverrides","CallOverride","Pick","Binding","ctx","dispatch","name","args","Promise","binding","currentToolUseContext","tuc","formatLockHeld","holder","slice","buildSessionContext","getAllowedApps","getAppState","computerUseMcpState","allowedApps","getGrantFlags","grantFlags","getUserDeniedBundleIds","getSelectedDisplayId","selectedDisplayId","getDisplayPinnedByModel","displayPinnedByModel","getDisplayResolvedForApps","displayResolvedForApps","getLastScreenshotDims","d","lastScreenshotDims","displayId","originX","originY","undefined","onPermissionRequest","req","_dialogSignal","runPermissionDialog","onAllowedAppsChanged","apps","flags","setAppState","prev","cu","prevApps","prevFlags","sameApps","length","every","a","i","bundleId","sameFlags","clipboardRead","clipboardWrite","systemKeyCombos","onAppsHidden","ids","existing","hiddenDuringTurn","id","has","Set","onResolvedDisplayUpdated","onDisplayPinned","pinned","nextResolvedFor","onDisplayResolvedForApps","key","onScreenshotCaptured","dims","p","width","height","displayWidth","displayHeight","checkCuLock","c","kind","isSelf","by","acquireCuLock","r","Error","fresh","escRegistered","abortController","abort","sendOSNotification","message","notificationType","formatLockHeldMessage","getOrBind","ComputerUseMCPToolOverrides","ReturnType","call","getComputerUseMCPToolOverrides","toolName","context","telemetry","result","error_kind","data","Array","isArray","content","map","item","type","const","source","media_type","mimeType","text","setToolJSX","granted","denied","resolve","reject","signal","aborted","onAbort","removeEventListener","addEventListener","jsx","createElement","request","onDone","resp","shouldHidePromptInput"],"sources":["wrapper.tsx"],"sourcesContent":["/**\n * The `.call()` override — thin adapter between `ToolUseContext` and\n * `bindSessionContext`. Spread into the MCP tool object in `client.ts`\n * (same pattern as Chrome's rendering overrides, plus `.call()`).\n *\n * The wrapper-closure logic (build overrides fresh, lock gate, permission\n * merge, screenshot stash) lives in `@ant/computer-use-mcp`'s\n * `bindSessionContext`. This file binds it once per process,\n * caches the dispatcher, and updates a per-call ref for the pieces of\n * `ToolUseContext` that vary per-call (`abortController`, `setToolJSX`,\n * `sendOSNotification`). AppState accessors are read through the ref too —\n * they're likely stable but we don't depend on that.\n *\n * External callers reach this via the lazy require thunk in `client.ts`, gated\n * on `feature('CHICAGO_MCP')`. Runtime enablement is controlled by the\n * GrowthBook gate `tengu_malort_pedway` (see gates.ts).\n */\n\nimport {\n  bindSessionContext,\n  type ComputerUseSessionContext,\n  type CuCallToolResult,\n  type CuPermissionRequest,\n  type CuPermissionResponse,\n  DEFAULT_GRANT_FLAGS,\n  type ScreenshotDims,\n} from '@ant/computer-use-mcp'\nimport * as React from 'react'\nimport { getSessionId } from '../../bootstrap/state.js'\nimport { ComputerUseApproval } from '../../components/permissions/ComputerUseApproval/ComputerUseApproval.js'\nimport type { Tool, ToolUseContext } from '../../Tool.js'\nimport { logForDebugging } from '../debug.js'\nimport {\n  checkComputerUseLock,\n  tryAcquireComputerUseLock,\n} from './computerUseLock.js'\nimport { registerEscHotkey } from './escHotkey.js'\nimport { getChicagoCoordinateMode } from './gates.js'\nimport { getComputerUseHostAdapter } from './hostAdapter.js'\nimport { getComputerUseMCPRenderingOverrides } from './toolRendering.js'\n\ntype CallOverride = Pick<Tool, 'call'>['call']\n\ntype Binding = {\n  ctx: ComputerUseSessionContext\n  dispatch: (name: string, args: unknown) => Promise<CuCallToolResult>\n}\n\n/**\n * Cached binding — built on first `.call()`, reused for process lifetime.\n * The dispatcher's closure-held screenshot blob persists across calls.\n *\n * `currentToolUseContext` is updated on every call. Every getter/callback in\n * `ctx` reads through it, so the per-call pieces (`abortController`,\n * `setToolJSX`, `sendOSNotification`) are always current.\n *\n * Module-level `let` is a deliberate exception to the no-module-scope-state\n * rule (src/CLAUDE.md): the dispatcher closure must persist across calls so\n * its internal screenshot blob survives, but `ToolUseContext` is per-call.\n * Tests will need to either inject the cache or run serially.\n */\nlet binding: Binding | undefined\nlet currentToolUseContext: ToolUseContext | undefined\n\nfunction tuc(): ToolUseContext {\n  // Safe: `binding` is only populated when `currentToolUseContext` is set.\n  // Called only from within `ctx` callbacks, which only fire during dispatch.\n  return currentToolUseContext!\n}\n\nfunction formatLockHeld(holder: string): string {\n  return `Computer use is in use by another Claude session (${holder.slice(0, 8)}…). Wait for that session to finish or run /exit there.`\n}\n\nexport function buildSessionContext(): ComputerUseSessionContext {\n  return {\n    // ── Read state fresh via the per-call ref ─────────────────────────────\n    getAllowedApps: () =>\n      tuc().getAppState().computerUseMcpState?.allowedApps ?? [],\n    getGrantFlags: () =>\n      tuc().getAppState().computerUseMcpState?.grantFlags ??\n      DEFAULT_GRANT_FLAGS,\n    // cc-2 has no Settings page for user-denied apps yet.\n    getUserDeniedBundleIds: () => [],\n    getSelectedDisplayId: () =>\n      tuc().getAppState().computerUseMcpState?.selectedDisplayId,\n    getDisplayPinnedByModel: () =>\n      tuc().getAppState().computerUseMcpState?.displayPinnedByModel ?? false,\n    getDisplayResolvedForApps: () =>\n      tuc().getAppState().computerUseMcpState?.displayResolvedForApps,\n    getLastScreenshotDims: (): ScreenshotDims | undefined => {\n      const d = tuc().getAppState().computerUseMcpState?.lastScreenshotDims\n      return d\n        ? {\n            ...d,\n            displayId: d.displayId ?? 0,\n            originX: d.originX ?? 0,\n            originY: d.originY ?? 0,\n          }\n        : undefined\n    },\n\n    // ── Write-backs ────────────────────────────────────────────────────────\n    // `setToolJSX` is guaranteed present — the gate in `main.tsx` excludes\n    // non-interactive sessions. The package's `_dialogSignal` (tool-finished\n    // dismissal) is irrelevant here: `setToolJSX` blocks the tool call, so\n    // the dialog can't outlive it. Ctrl+C is what matters, and\n    // `runPermissionDialog` wires that from the per-call ref's abortController.\n    onPermissionRequest: (req, _dialogSignal) => runPermissionDialog(req),\n\n    // Package does the merge (dedupe + truthy-only flags). We just persist.\n    onAllowedAppsChanged: (apps, flags) =>\n      tuc().setAppState(prev => {\n        const cu = prev.computerUseMcpState\n        const prevApps = cu?.allowedApps\n        const prevFlags = cu?.grantFlags\n        const sameApps =\n          prevApps?.length === apps.length &&\n          apps.every((a, i) => prevApps[i]?.bundleId === a.bundleId)\n        const sameFlags =\n          prevFlags?.clipboardRead === flags.clipboardRead &&\n          prevFlags?.clipboardWrite === flags.clipboardWrite &&\n          prevFlags?.systemKeyCombos === flags.systemKeyCombos\n        return sameApps && sameFlags\n          ? prev\n          : {\n              ...prev,\n              computerUseMcpState: {\n                ...cu,\n                allowedApps: [...apps],\n                grantFlags: flags,\n              },\n            }\n      }),\n\n    onAppsHidden: ids => {\n      if (ids.length === 0) return\n      tuc().setAppState(prev => {\n        const cu = prev.computerUseMcpState\n        const existing = cu?.hiddenDuringTurn\n        if (existing && ids.every(id => existing.has(id))) return prev\n        return {\n          ...prev,\n          computerUseMcpState: {\n            ...cu,\n            hiddenDuringTurn: new Set([...(existing ?? []), ...ids]),\n          },\n        }\n      })\n    },\n\n    // Resolver writeback only fires under a pin when Swift fell back to main\n    // (pinned display unplugged) — the pin is semantically dead, so clear it\n    // and the app-set key so the chase chain runs next time. When autoResolve\n    // was true, onDisplayResolvedForApps re-sets the key in the same tick.\n    onResolvedDisplayUpdated: id =>\n      tuc().setAppState(prev => {\n        const cu = prev.computerUseMcpState\n        if (\n          cu?.selectedDisplayId === id &&\n          !cu.displayPinnedByModel &&\n          cu.displayResolvedForApps === undefined\n        ) {\n          return prev\n        }\n        return {\n          ...prev,\n          computerUseMcpState: {\n            ...cu,\n            selectedDisplayId: id,\n            displayPinnedByModel: false,\n            displayResolvedForApps: undefined,\n          },\n        }\n      }),\n\n    // switch_display(name) pins; switch_display(\"auto\") unpins and clears the\n    // app-set key so the next screenshot auto-resolves fresh.\n    onDisplayPinned: id =>\n      tuc().setAppState(prev => {\n        const cu = prev.computerUseMcpState\n        const pinned = id !== undefined\n        const nextResolvedFor = pinned ? cu?.displayResolvedForApps : undefined\n        if (\n          cu?.selectedDisplayId === id &&\n          cu?.displayPinnedByModel === pinned &&\n          cu?.displayResolvedForApps === nextResolvedFor\n        ) {\n          return prev\n        }\n        return {\n          ...prev,\n          computerUseMcpState: {\n            ...cu,\n            selectedDisplayId: id,\n            displayPinnedByModel: pinned,\n            displayResolvedForApps: nextResolvedFor,\n          },\n        }\n      }),\n\n    onDisplayResolvedForApps: key =>\n      tuc().setAppState(prev => {\n        const cu = prev.computerUseMcpState\n        if (cu?.displayResolvedForApps === key) return prev\n        return {\n          ...prev,\n          computerUseMcpState: { ...cu, displayResolvedForApps: key },\n        }\n      }),\n\n    onScreenshotCaptured: dims =>\n      tuc().setAppState(prev => {\n        const cu = prev.computerUseMcpState\n        const p = cu?.lastScreenshotDims\n        return p?.width === dims.width &&\n          p?.height === dims.height &&\n          p?.displayWidth === dims.displayWidth &&\n          p?.displayHeight === dims.displayHeight &&\n          p?.displayId === dims.displayId &&\n          p?.originX === dims.originX &&\n          p?.originY === dims.originY\n          ? prev\n          : {\n              ...prev,\n              computerUseMcpState: { ...cu, lastScreenshotDims: dims },\n            }\n      }),\n\n    // ── Lock — async, direct file-lock calls ───────────────────────────────\n    // No `lockHolderForGate` dance: the package's gate is async now. It\n    // awaits `checkCuLock`, and on `holder: undefined` + non-deferring tool\n    // awaits `acquireCuLock`. `defersLockAcquire` is the PACKAGE's set —\n    // the local copy is gone.\n    checkCuLock: async () => {\n      const c = await checkComputerUseLock()\n      switch (c.kind) {\n        case 'free':\n          return { holder: undefined, isSelf: false }\n        case 'held_by_self':\n          return { holder: getSessionId(), isSelf: true }\n        case 'blocked':\n          return { holder: c.by, isSelf: false }\n      }\n    },\n\n    // Called only when checkCuLock returned `holder: undefined`. The O_EXCL\n    // acquire is atomic — if another process grabbed it in the gap (rare),\n    // throw so the tool fails instead of proceeding without the lock.\n    // `fresh: false` (re-entrant) shouldn't happen given check said free,\n    // but is possible under parallel tool-use interleaving — don't spam the\n    // notification in that case.\n    acquireCuLock: async () => {\n      const r = await tryAcquireComputerUseLock()\n      if (r.kind === 'blocked') {\n        throw new Error(formatLockHeld(r.by))\n      }\n      if (r.fresh) {\n        // Global Escape → abort. Consumes the event (PI defense — prompt\n        // injection can't dismiss dialogs with Escape). The CGEventTap's\n        // CFRunLoopSource is processed by the drainRunLoop pump, so this\n        // holds a pump retain until unregisterEscHotkey() in cleanup.ts.\n        const escRegistered = registerEscHotkey(() => {\n          logForDebugging('[cu-esc] user escape, aborting turn')\n          tuc().abortController.abort()\n        })\n        tuc().sendOSNotification?.({\n          message: escRegistered\n            ? 'Claude is using your computer · press Esc to stop'\n            : 'Claude is using your computer · press Ctrl+C to stop',\n          notificationType: 'computer_use_enter',\n        })\n      }\n    },\n\n    formatLockHeldMessage: formatLockHeld,\n  }\n}\n\nfunction getOrBind(): Binding {\n  if (binding) return binding\n  const ctx = buildSessionContext()\n  binding = {\n    ctx,\n    dispatch: bindSessionContext(\n      getComputerUseHostAdapter(),\n      getChicagoCoordinateMode(),\n      ctx,\n    ),\n  }\n  return binding\n}\n\n/**\n * Returns the full override object for a single `mcp__computer-use__{toolName}`\n * tool: rendering overrides from `toolRendering.tsx` plus a `.call()` that\n * dispatches through the cached binder.\n */\ntype ComputerUseMCPToolOverrides = ReturnType<\n  typeof getComputerUseMCPRenderingOverrides\n> & {\n  call: CallOverride\n}\n\nexport function getComputerUseMCPToolOverrides(\n  toolName: string,\n): ComputerUseMCPToolOverrides {\n  const call: CallOverride = async (args, context: ToolUseContext) => {\n    currentToolUseContext = context\n    const { dispatch } = getOrBind()\n\n    const { telemetry, ...result } = await dispatch(toolName, args)\n\n    if (telemetry?.error_kind) {\n      logForDebugging(\n        `[Computer Use MCP] ${toolName} error_kind=${telemetry.error_kind}`,\n      )\n    }\n\n    // MCP content blocks → Anthropic API blocks. CU only produces text and\n    // pre-sized JPEG (executor.ts computeTargetDims → targetImageSize), so\n    // unlike the generic MCP path there's no resize needed — the MCP image\n    // shape just maps to the API's base64-source shape. The package's result\n    // type admits audio/resource too, but CU's handleToolCall never emits\n    // those; the fallthrough coerces them to empty text.\n    const data = Array.isArray(result.content)\n      ? result.content.map(item =>\n          item.type === 'image'\n            ? {\n                type: 'image' as const,\n                source: {\n                  type: 'base64' as const,\n                  media_type: item.mimeType ?? 'image/jpeg',\n                  data: item.data,\n                },\n              }\n            : {\n                type: 'text' as const,\n                text: item.type === 'text' ? item.text : '',\n              },\n        )\n      : result.content\n    return { data }\n  }\n\n  return {\n    ...getComputerUseMCPRenderingOverrides(toolName),\n    call,\n  }\n}\n\n/**\n * Render the approval dialog mid-call via `setToolJSX` + `Promise`, wait for\n * the user. Mirrors `spawnMultiAgent.ts:419-436` (the `It2SetupPrompt` pattern).\n *\n * The merge-into-AppState that used to live here (dedupe + truthy-only flags)\n * is now in the package's `bindSessionContext` → `onAllowedAppsChanged`.\n */\nasync function runPermissionDialog(\n  req: CuPermissionRequest,\n): Promise<CuPermissionResponse> {\n  const context = tuc()\n  const setToolJSX = context.setToolJSX\n  if (!setToolJSX) {\n    // Shouldn't happen — main.tsx gate excludes non-interactive. Fail safe.\n    return { granted: [], denied: [], flags: DEFAULT_GRANT_FLAGS }\n  }\n\n  try {\n    return await new Promise<CuPermissionResponse>((resolve, reject) => {\n      const signal = context.abortController.signal\n      // If already aborted, addEventListener won't fire — reject now so the\n      // promise doesn't hang waiting for a user who Ctrl+C'd.\n      if (signal.aborted) {\n        reject(new Error('Computer Use permission dialog aborted'))\n        return\n      }\n      const onAbort = (): void => {\n        signal.removeEventListener('abort', onAbort)\n        reject(new Error('Computer Use permission dialog aborted'))\n      }\n      signal.addEventListener('abort', onAbort)\n\n      setToolJSX({\n        jsx: React.createElement(ComputerUseApproval, {\n          request: req,\n          onDone: (resp: CuPermissionResponse) => {\n            signal.removeEventListener('abort', onAbort)\n            resolve(resp)\n          },\n        }),\n        shouldHidePromptInput: true,\n      })\n    })\n  } finally {\n    setToolJSX(null)\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/src/utils/concurrentSessions.ts

@@ -0,0 +1,204 @@
+import { feature } from 'bun:bundle'
+import { chmod, mkdir, readdir, readFile, unlink, writeFile } from 'fs/promises'
+import { join } from 'path'
+import {
+  getOriginalCwd,
+  getSessionId,
+  onSessionSwitch,
+} from '../bootstrap/state.js'
+import { registerCleanup } from './cleanupRegistry.js'
+import { logForDebugging } from './debug.js'
+import { getClaudeConfigHomeDir } from './envUtils.js'
+import { errorMessage, isFsInaccessible } from './errors.js'
+import { isProcessRunning } from './genericProcessUtils.js'
+import { getPlatform } from './platform.js'
+import { jsonParse, jsonStringify } from './slowOperations.js'
+import { getAgentId } from './teammate.js'
+
+export type SessionKind = 'interactive' | 'bg' | 'daemon' | 'daemon-worker'
+export type SessionStatus = 'busy' | 'idle' | 'waiting'
+
+function getSessionsDir(): string {
+  return join(getClaudeConfigHomeDir(), 'sessions')
+}
+
+/**
+ * Kind override from env. Set by the spawner (`claude --bg`, daemon
+ * supervisor) so the child can register without the parent having to
+ * write the file for it — cleanup-on-exit wiring then works for free.
+ * Gated so the env-var string is DCE'd from external builds.
+ */
+function envSessionKind(): SessionKind | undefined {
+  if (feature('BG_SESSIONS')) {
+    const k = process.env.CLAUDE_CODE_SESSION_KIND
+    if (k === 'bg' || k === 'daemon' || k === 'daemon-worker') return k
+  }
+  return undefined
+}
+
+/**
+ * True when this REPL is running inside a `claude --bg` tmux session.
+ * Exit paths (/exit, ctrl+c, ctrl+d) should detach the attached client
+ * instead of killing the process.
+ */
+export function isBgSession(): boolean {
+  return envSessionKind() === 'bg'
+}
+
+/**
+ * Write a PID file for this session and register cleanup.
+ *
+ * Registers all top-level sessions — interactive CLI, SDK (vscode, desktop,
+ * typescript, python, -p), bg/daemon spawns — so `claude ps` sees everything
+ * the user might be running. Skips only teammates/subagents, which would
+ * conflate swarm usage with genuine concurrency and pollute ps with noise.
+ *
+ * Returns true if registered, false if skipped.
+ * Errors logged to debug, never thrown.
+ */
+export async function registerSession(): Promise<boolean> {
+  if (getAgentId() != null) return false
+
+  const kind: SessionKind = envSessionKind() ?? 'interactive'
+  const dir = getSessionsDir()
+  const pidFile = join(dir, `${process.pid}.json`)
+
+  registerCleanup(async () => {
+    try {
+      await unlink(pidFile)
+    } catch {
+      // ENOENT is fine (already deleted or never written)
+    }
+  })
+
+  try {
+    await mkdir(dir, { recursive: true, mode: 0o700 })
+    await chmod(dir, 0o700)
+    await writeFile(
+      pidFile,
+      jsonStringify({
+        pid: process.pid,
+        sessionId: getSessionId(),
+        cwd: getOriginalCwd(),
+        startedAt: Date.now(),
+        kind,
+        entrypoint: process.env.CLAUDE_CODE_ENTRYPOINT,
+        ...(feature('UDS_INBOX')
+          ? { messagingSocketPath: process.env.CLAUDE_CODE_MESSAGING_SOCKET }
+          : {}),
+        ...(feature('BG_SESSIONS')
+          ? {
+              name: process.env.CLAUDE_CODE_SESSION_NAME,
+              logPath: process.env.CLAUDE_CODE_SESSION_LOG,
+              agent: process.env.CLAUDE_CODE_AGENT,
+            }
+          : {}),
+      }),
+    )
+    // --resume / /resume mutates getSessionId() via switchSession. Without
+    // this, the PID file's sessionId goes stale and `claude ps` sparkline
+    // reads the wrong transcript.
+    onSessionSwitch(id => {
+      void updatePidFile({ sessionId: id })
+    })
+    return true
+  } catch (e) {
+    logForDebugging(`[concurrentSessions] register failed: ${errorMessage(e)}`)
+    return false
+  }
+}
+
+/**
+ * Update this session's name in its PID registry file so ListPeers
+ * can surface it. Best-effort: silently no-op if name is falsy, the
+ * file doesn't exist (session not registered), or read/write fails.
+ */
+async function updatePidFile(patch: Record<string, unknown>): Promise<void> {
+  const pidFile = join(getSessionsDir(), `${process.pid}.json`)
+  try {
+    const data = jsonParse(await readFile(pidFile, 'utf8')) as Record<
+      string,
+      unknown
+    >
+    await writeFile(pidFile, jsonStringify({ ...data, ...patch }))
+  } catch (e) {
+    logForDebugging(
+      `[concurrentSessions] updatePidFile failed: ${errorMessage(e)}`,
+    )
+  }
+}
+
+export async function updateSessionName(
+  name: string | undefined,
+): Promise<void> {
+  if (!name) return
+  await updatePidFile({ name })
+}
+
+/**
+ * Record this session's Remote Control session ID so peer enumeration can
+ * dedup: a session reachable over both UDS and bridge should only appear
+ * once (local wins). Cleared on bridge teardown so stale IDs don't
+ * suppress a legitimately-remote session after reconnect.
+ */
+export async function updateSessionBridgeId(
+  bridgeSessionId: string | null,
+): Promise<void> {
+  await updatePidFile({ bridgeSessionId })
+}
+
+/**
+ * Push live activity state for `claude ps`. Fire-and-forget from REPL's
+ * status-change effect — a dropped write just means ps falls back to
+ * transcript-tail derivation for one refresh.
+ */
+export async function updateSessionActivity(patch: {
+  status?: SessionStatus
+  waitingFor?: string
+}): Promise<void> {
+  if (!feature('BG_SESSIONS')) return
+  await updatePidFile({ ...patch, updatedAt: Date.now() })
+}
+
+/**
+ * Count live concurrent CLI sessions (including this one).
+ * Filters out stale PID files (crashed sessions) and deletes them.
+ * Returns 0 on any error (conservative).
+ */
+export async function countConcurrentSessions(): Promise<number> {
+  const dir = getSessionsDir()
+  let files: string[]
+  try {
+    files = await readdir(dir)
+  } catch (e) {
+    if (!isFsInaccessible(e)) {
+      logForDebugging(`[concurrentSessions] readdir failed: ${errorMessage(e)}`)
+    }
+    return 0
+  }
+
+  let count = 0
+  for (const file of files) {
+    // Strict filename guard: only `<pid>.json` is a candidate. parseInt's
+    // lenient prefix-parsing means `2026-03-14_notes.md` would otherwise
+    // parse as PID 2026 and get swept as stale — silent user data loss.
+    // See anthropics/claude-code#34210.
+    if (!/^\d+\.json$/.test(file)) continue
+    const pid = parseInt(file.slice(0, -5), 10)
+    if (pid === process.pid) {
+      count++
+      continue
+    }
+    if (isProcessRunning(pid)) {
+      count++
+    } else if (getPlatform() !== 'wsl') {
+      // Stale file from a crashed session — sweep it. Skip on WSL: if
+      // ~/.claude/sessions/ is shared with Windows-native Claude (symlink
+      // or CLAUDE_CONFIG_DIR), a Windows PID won't be probeable from WSL
+      // and we'd falsely delete a live session's file. This is just
+      // telemetry so conservative undercount is acceptable.
+      void unlink(join(dir, file)).catch(() => {})
+    }
+  }
+  return count
+}