@xelauvas/xela-cli 0.1.0

package/src/utils/computerUse/gates.ts

@@ -0,0 +1,72 @@
+import type { CoordinateMode, CuSubGates } from '@ant/computer-use-mcp/types'
+
+import { getDynamicConfig_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js'
+import { getSubscriptionType } from '../auth.js'
+import { isEnvTruthy } from '../envUtils.js'
+
+type ChicagoConfig = CuSubGates & {
+  enabled: boolean
+  coordinateMode: CoordinateMode
+}
+
+const DEFAULTS: ChicagoConfig = {
+  enabled: false,
+  pixelValidation: false,
+  clipboardPasteMultiline: true,
+  mouseAnimation: true,
+  hideBeforeAction: true,
+  autoTargetDisplay: true,
+  clipboardGuard: true,
+  coordinateMode: 'pixels',
+}
+
+// Spread over defaults so a partial JSON ({"enabled": true} alone) inherits the
+// rest. The generic on getDynamicConfig is a type assertion, not a validator —
+// GB returning a partial object would otherwise surface undefined fields.
+function readConfig(): ChicagoConfig {
+  return {
+    ...DEFAULTS,
+    ...getDynamicConfig_CACHED_MAY_BE_STALE<Partial<ChicagoConfig>>(
+      'tengu_malort_pedway',
+      DEFAULTS,
+    ),
+  }
+}
+
+// Max/Pro only for external rollout. Ant bypass so dogfooding continues
+// regardless of subscription tier — not all ants are max/pro, and per
+// CLAUDE.md:281, USER_TYPE !== 'ant' branches get zero antfooding.
+function hasRequiredSubscription(): boolean {
+  if (process.env.USER_TYPE === 'ant') return true
+  const tier = getSubscriptionType()
+  return tier === 'max' || tier === 'pro'
+}
+
+export function getChicagoEnabled(): boolean {
+  // Disable for ants whose shell inherited monorepo dev config.
+  // MONOREPO_ROOT_DIR is exported by config/local/zsh/zshrc, which
+  // laptop-setup.sh wires into ~/.zshrc — its presence is the cheap
+  // proxy for "has monorepo access". Override: ALLOW_ANT_COMPUTER_USE_MCP=1.
+  if (
+    process.env.USER_TYPE === 'ant' &&
+    process.env.MONOREPO_ROOT_DIR &&
+    !isEnvTruthy(process.env.ALLOW_ANT_COMPUTER_USE_MCP)
+  ) {
+    return false
+  }
+  return hasRequiredSubscription() && readConfig().enabled
+}
+
+export function getChicagoSubGates(): CuSubGates {
+  const { enabled: _e, coordinateMode: _c, ...subGates } = readConfig()
+  return subGates
+}
+
+// Frozen at first read — setup.ts builds tool descriptions and executor.ts
+// scales coordinates off the same value. A live read here lets a mid-session
+// GB flip tell the model "pixels" while transforming clicks as normalized.
+let frozenCoordinateMode: CoordinateMode | undefined
+export function getChicagoCoordinateMode(): CoordinateMode {
+  frozenCoordinateMode ??= readConfig().coordinateMode
+  return frozenCoordinateMode
+}

package/src/utils/computerUse/hostAdapter.ts

@@ -0,0 +1,69 @@
+import type {
+  ComputerUseHostAdapter,
+  Logger,
+} from '@ant/computer-use-mcp/types'
+import { format } from 'util'
+import { logForDebugging } from '../debug.js'
+import { COMPUTER_USE_MCP_SERVER_NAME } from './common.js'
+import { createCliExecutor } from './executor.js'
+import { getChicagoEnabled, getChicagoSubGates } from './gates.js'
+import { requireComputerUseSwift } from './swiftLoader.js'
+
+class DebugLogger implements Logger {
+  silly(message: string, ...args: unknown[]): void {
+    logForDebugging(format(message, ...args), { level: 'debug' })
+  }
+  debug(message: string, ...args: unknown[]): void {
+    logForDebugging(format(message, ...args), { level: 'debug' })
+  }
+  info(message: string, ...args: unknown[]): void {
+    logForDebugging(format(message, ...args), { level: 'info' })
+  }
+  warn(message: string, ...args: unknown[]): void {
+    logForDebugging(format(message, ...args), { level: 'warn' })
+  }
+  error(message: string, ...args: unknown[]): void {
+    logForDebugging(format(message, ...args), { level: 'error' })
+  }
+}
+
+let cached: ComputerUseHostAdapter | undefined
+
+/**
+ * Process-lifetime singleton. Built once on first CU tool call; native modules
+ * (both `@ant/computer-use-input` and `@ant/computer-use-swift`) are loaded
+ * here via the executor factory, which throws on load failure — there is no
+ * degraded mode.
+ */
+export function getComputerUseHostAdapter(): ComputerUseHostAdapter {
+  if (cached) return cached
+  cached = {
+    serverName: COMPUTER_USE_MCP_SERVER_NAME,
+    logger: new DebugLogger(),
+    executor: createCliExecutor({
+      getMouseAnimationEnabled: () => getChicagoSubGates().mouseAnimation,
+      getHideBeforeActionEnabled: () => getChicagoSubGates().hideBeforeAction,
+    }),
+    ensureOsPermissions: async () => {
+      const cu = requireComputerUseSwift()
+      const accessibility = cu.tcc.checkAccessibility()
+      const screenRecording = cu.tcc.checkScreenRecording()
+      return accessibility && screenRecording
+        ? { granted: true }
+        : { granted: false, accessibility, screenRecording }
+    },
+    isDisabled: () => !getChicagoEnabled(),
+    getSubGates: getChicagoSubGates,
+    // cleanup.ts always unhides at turn end — no user preference to disable it.
+    getAutoUnhideEnabled: () => true,
+
+    // Pixel-validation JPEG decode+crop. MUST be synchronous (the package
+    // does `patch1.equals(patch2)` directly on the return value). Cowork uses
+    // Electron's `nativeImage` (sync); our `image-processor-napi` is
+    // sharp-compatible and async-only. Returning null → validation skipped,
+    // click proceeds — the designed fallback per `PixelCompareResult.skipped`.
+    // The sub-gate defaults to false anyway.
+    cropRawPatch: () => null,
+  }
+  return cached
+}

package/src/utils/computerUse/inputLoader.ts

@@ -0,0 +1,30 @@
+import type {
+  ComputerUseInput,
+  ComputerUseInputAPI,
+} from '@ant/computer-use-input'
+
+let cached: ComputerUseInputAPI | undefined
+
+/**
+ * Package's js/index.js reads COMPUTER_USE_INPUT_NODE_PATH (baked by
+ * build-with-plugins.ts on darwin targets, unset otherwise — falls through to
+ * the node_modules prebuilds/ path).
+ *
+ * The package exports a discriminated union on `isSupported` — narrowed here
+ * once so callers get the bare `ComputerUseInputAPI` without re-checking.
+ *
+ * key()/keys() dispatch enigo work onto DispatchQueue.main via
+ * dispatch2::run_on_main, then block a tokio worker on a channel. Under
+ * Electron (CFRunLoop drains the main queue) this works; under libuv
+ * (Node/bun) the main queue never drains and the promise hangs. The executor
+ * calls these inside drainRunLoop().
+ */
+export function requireComputerUseInput(): ComputerUseInputAPI {
+  if (cached) return cached
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const input = require('@ant/computer-use-input') as ComputerUseInput
+  if (!input.isSupported) {
+    throw new Error('@ant/computer-use-input is not supported on this platform')
+  }
+  return (cached = input)
+}

package/src/utils/computerUse/mcpServer.ts

@@ -0,0 +1,106 @@
+import {
+  buildComputerUseTools,
+  createComputerUseMcpServer,
+} from '@ant/computer-use-mcp'
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import { ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js'
+import { homedir } from 'os'
+
+import { shutdownDatadog } from '../../services/analytics/datadog.js'
+import { shutdown1PEventLogging } from '../../services/analytics/firstPartyEventLogger.js'
+import { initializeAnalyticsSink } from '../../services/analytics/sink.js'
+import { enableConfigs } from '../config.js'
+import { logForDebugging } from '../debug.js'
+import { filterAppsForDescription } from './appNames.js'
+import { getChicagoCoordinateMode } from './gates.js'
+import { getComputerUseHostAdapter } from './hostAdapter.js'
+
+const APP_ENUM_TIMEOUT_MS = 1000
+
+/**
+ * Enumerate installed apps, timed. Fails soft — if Spotlight is slow or
+ * claude-swift throws, the tool description just omits the list. Resolution
+ * happens at call time regardless; the model just doesn't get hints.
+ */
+async function tryGetInstalledAppNames(): Promise<string[] | undefined> {
+  const adapter = getComputerUseHostAdapter()
+  const enumP = adapter.executor.listInstalledApps()
+  let timer: ReturnType<typeof setTimeout> | undefined
+  const timeoutP = new Promise<undefined>(resolve => {
+    timer = setTimeout(resolve, APP_ENUM_TIMEOUT_MS, undefined)
+  })
+  const installed = await Promise.race([enumP, timeoutP])
+    .catch(() => undefined)
+    .finally(() => clearTimeout(timer))
+  if (!installed) {
+    // The enumeration continues in the background — swallow late rejections.
+    void enumP.catch(() => {})
+    logForDebugging(
+      `[Computer Use MCP] app enumeration exceeded ${APP_ENUM_TIMEOUT_MS}ms or failed; tool description omits list`,
+    )
+    return undefined
+  }
+  return filterAppsForDescription(installed, homedir())
+}
+
+/**
+ * Construct the in-process server. Delegates to the package's
+ * `createComputerUseMcpServer` for the Server object + stub CallTool handler,
+ * then REPLACES the ListTools handler with one that includes installed-app
+ * names in the `request_access` description (the package's factory doesn't
+ * take `installedAppNames`, and Cowork builds its own tool array in
+ * serverDef.ts for the same reason).
+ *
+ * Async so the 1s app-enumeration timeout doesn't block startup — called from
+ * an `await import()` in `client.ts` on first CU connection, not `main.tsx`.
+ *
+ * Real dispatch still goes through `wrapper.tsx`'s `.call()` override; this
+ * server exists only to answer ListTools.
+ */
+export async function createComputerUseMcpServerForCli(): Promise<
+  ReturnType<typeof createComputerUseMcpServer>
+> {
+  const adapter = getComputerUseHostAdapter()
+  const coordinateMode = getChicagoCoordinateMode()
+  const server = createComputerUseMcpServer(adapter, coordinateMode)
+
+  const installedAppNames = await tryGetInstalledAppNames()
+  const tools = buildComputerUseTools(
+    adapter.executor.capabilities,
+    coordinateMode,
+    installedAppNames,
+  )
+  server.setRequestHandler(ListToolsRequestSchema, async () =>
+    adapter.isDisabled() ? { tools: [] } : { tools },
+  )
+
+  return server
+}
+
+/**
+ * Subprocess entrypoint for `--computer-use-mcp`. Mirror of
+ * `runClaudeInChromeMcpServer` — stdio transport, exit on stdin close,
+ * flush analytics before exit.
+ */
+export async function runComputerUseMcpServer(): Promise<void> {
+  enableConfigs()
+  initializeAnalyticsSink()
+
+  const server = await createComputerUseMcpServerForCli()
+  const transport = new StdioServerTransport()
+
+  let exiting = false
+  const shutdownAndExit = async (): Promise<void> => {
+    if (exiting) return
+    exiting = true
+    await Promise.all([shutdown1PEventLogging(), shutdownDatadog()])
+    // eslint-disable-next-line custom-rules/no-process-exit
+    process.exit(0)
+  }
+  process.stdin.on('end', () => void shutdownAndExit())
+  process.stdin.on('error', () => void shutdownAndExit())
+
+  logForDebugging('[Computer Use MCP] Starting MCP server')
+  await server.connect(transport)
+  logForDebugging('[Computer Use MCP] MCP server started')
+}

package/src/utils/computerUse/setup.ts

@@ -0,0 +1,53 @@
+import { buildComputerUseTools } from '@ant/computer-use-mcp'
+import { join } from 'path'
+import { fileURLToPath } from 'url'
+import { buildMcpToolName } from '../../services/mcp/mcpStringUtils.js'
+import type { ScopedMcpServerConfig } from '../../services/mcp/types.js'
+
+import { isInBundledMode } from '../bundledMode.js'
+import { CLI_CU_CAPABILITIES, COMPUTER_USE_MCP_SERVER_NAME } from './common.js'
+import { getChicagoCoordinateMode } from './gates.js'
+
+/**
+ * Build the dynamic MCP config + allowed tool names. Mirror of
+ * `setupClaudeInChrome`. The `mcp__computer-use__*` tools are added to
+ * `allowedTools` so they bypass the normal permission prompt — the package's
+ * `request_access` handles approval for the whole session.
+ *
+ * The MCP layer isn't ceremony: the API backend detects `mcp__computer-use__*`
+ * tool names and emits a CU availability hint into the system prompt
+ * (COMPUTER_USE_MCP_AVAILABILITY_HINT in the anthropic repo). Built-in tools
+ * with different names wouldn't trigger it. Cowork uses the same names for the
+ * same reason (apps/desktop/src/main/local-agent-mode/systemPrompt.ts:314).
+ */
+export function setupComputerUseMCP(): {
+  mcpConfig: Record<string, ScopedMcpServerConfig>
+  allowedTools: string[]
+} {
+  const allowedTools = buildComputerUseTools(
+    CLI_CU_CAPABILITIES,
+    getChicagoCoordinateMode(),
+  ).map(t => buildMcpToolName(COMPUTER_USE_MCP_SERVER_NAME, t.name))
+
+  // command/args are never spawned — client.ts intercepts by name and
+  // uses the in-process server. The config just needs to exist with
+  // type 'stdio' to hit the right branch. Mirrors Chrome's setup.
+  const args = isInBundledMode()
+    ? ['--computer-use-mcp']
+    : [
+        join(fileURLToPath(import.meta.url), '..', 'cli.js'),
+        '--computer-use-mcp',
+      ]
+
+  return {
+    mcpConfig: {
+      [COMPUTER_USE_MCP_SERVER_NAME]: {
+        type: 'stdio',
+        command: process.execPath,
+        args,
+        scope: 'dynamic',
+      } as const,
+    },
+    allowedTools,
+  }
+}

package/src/utils/computerUse/swiftLoader.ts

@@ -0,0 +1,23 @@
+import type { ComputerUseAPI } from '@ant/computer-use-swift'
+
+let cached: ComputerUseAPI | undefined
+
+/**
+ * Package's js/index.js reads COMPUTER_USE_SWIFT_NODE_PATH (baked by
+ * build-with-plugins.ts on darwin targets, unset otherwise — falls through to
+ * the node_modules prebuilds/ path). We cache the loaded native module.
+ *
+ * The four @MainActor methods (captureExcluding, captureRegion,
+ * apps.listInstalled, resolvePrepareCapture) dispatch to DispatchQueue.main
+ * and will hang under libuv unless CFRunLoop is pumped — call sites wrap
+ * these in drainRunLoop().
+ */
+export function requireComputerUseSwift(): ComputerUseAPI {
+  if (process.platform !== 'darwin') {
+    throw new Error('@ant/computer-use-swift is macOS-only')
+  }
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  return (cached ??= require('@ant/computer-use-swift') as ComputerUseAPI)
+}
+
+export type { ComputerUseAPI }

package/src/utils/computerUse/toolRendering.tsx

@@ -0,0 +1,125 @@
+import * as React from 'react';
+import { MessageResponse } from '../../components/MessageResponse.js';
+import { Text } from '../../ink.js';
+import { truncateToWidth } from '../format.js';
+import type { MCPToolResult } from '../mcpValidation.js';
+type CuToolInput = Record<string, unknown> & {
+  coordinate?: [number, number];
+  start_coordinate?: [number, number];
+  text?: string;
+  apps?: Array<{
+    displayName?: string;
+  }>;
+  region?: [number, number, number, number];
+  direction?: string;
+  amount?: number;
+  duration?: number;
+};
+function fmtCoord(c: [number, number] | undefined): string {
+  return c ? `(${c[0]}, ${c[1]})` : '';
+}
+const RESULT_SUMMARY: Readonly<Partial<Record<string, string>>> = {
+  screenshot: 'Captured',
+  zoom: 'Captured',
+  request_access: 'Access updated',
+  left_click: 'Clicked',
+  right_click: 'Clicked',
+  middle_click: 'Clicked',
+  double_click: 'Clicked',
+  triple_click: 'Clicked',
+  type: 'Typed',
+  key: 'Pressed',
+  hold_key: 'Pressed',
+  scroll: 'Scrolled',
+  left_click_drag: 'Dragged',
+  open_application: 'Opened'
+};
+
+/**
+ * Rendering overrides for `mcp__computer-use__*` tools. Spread into the MCP
+ * tool object in `client.ts` after the default `userFacingName`, so these win.
+ * Mirror of `getClaudeInChromeMCPToolOverrides`.
+ */
+export function getComputerUseMCPRenderingOverrides(toolName: string): {
+  userFacingName: () => string;
+  renderToolUseMessage: (input: Record<string, unknown>, options: {
+    verbose: boolean;
+  }) => React.ReactNode;
+  renderToolResultMessage: (output: MCPToolResult, progressMessages: unknown[], options: {
+    verbose: boolean;
+  }) => React.ReactNode;
+} {
+  return {
+    userFacingName() {
+      return `Computer Use[${toolName}]`;
+    },
+    // AssistantToolUseMessage.tsx contract: null hides the ENTIRE row, '' shows
+    // the tool name without "(args)". Every path below returns '' when there's
+    // nothing to show — never null.
+    renderToolUseMessage(input: CuToolInput) {
+      switch (toolName) {
+        case 'screenshot':
+        case 'left_mouse_down':
+        case 'left_mouse_up':
+        case 'cursor_position':
+        case 'list_granted_applications':
+        case 'read_clipboard':
+          return '';
+        case 'left_click':
+        case 'right_click':
+        case 'middle_click':
+        case 'double_click':
+        case 'triple_click':
+        case 'mouse_move':
+          return fmtCoord(input.coordinate);
+        case 'left_click_drag':
+          return input.start_coordinate ? `${fmtCoord(input.start_coordinate)} → ${fmtCoord(input.coordinate)}` : `to ${fmtCoord(input.coordinate)}`;
+        case 'type':
+          return typeof input.text === 'string' ? `"${truncateToWidth(input.text, 40)}"` : '';
+        case 'key':
+        case 'hold_key':
+          return typeof input.text === 'string' ? input.text : '';
+        case 'scroll':
+          return [input.direction, input.amount && `×${input.amount}`, input.coordinate && `at ${fmtCoord(input.coordinate)}`].filter(Boolean).join(' ');
+        case 'zoom':
+          {
+            const r = input.region;
+            return Array.isArray(r) && r.length === 4 ? `[${r[0]}, ${r[1]}, ${r[2]}, ${r[3]}]` : '';
+          }
+        case 'wait':
+          return typeof input.duration === 'number' ? `${input.duration}s` : '';
+        case 'write_clipboard':
+          return typeof input.text === 'string' ? `"${truncateToWidth(input.text, 40)}"` : '';
+        case 'open_application':
+          return typeof input.bundle_id === 'string' ? String(input.bundle_id) : '';
+        case 'request_access':
+          {
+            const apps = input.apps;
+            if (!Array.isArray(apps)) return '';
+            const names = apps.map(a => typeof a?.displayName === 'string' ? a.displayName : '').filter(Boolean);
+            return names.join(', ');
+          }
+        case 'computer_batch':
+          {
+            const actions = input.actions;
+            return Array.isArray(actions) ? `${actions.length} actions` : '';
+          }
+        default:
+          return '';
+      }
+    },
+    renderToolResultMessage(output, _progress, {
+      verbose
+    }) {
+      if (verbose || typeof output !== 'object' || output === null) return null;
+
+      // Non-verbose: one-line dim summary, like Chrome's pattern.
+      const summary = RESULT_SUMMARY[toolName];
+      if (!summary) return null;
+      return <MessageResponse height={1}>
+          <Text dimColor>{summary}</Text>
+        </MessageResponse>;
+    }
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","MessageResponse","Text","truncateToWidth","MCPToolResult","CuToolInput","Record","coordinate","start_coordinate","text","apps","Array","displayName","region","direction","amount","duration","fmtCoord","c","RESULT_SUMMARY","Readonly","Partial","screenshot","zoom","request_access","left_click","right_click","middle_click","double_click","triple_click","type","key","hold_key","scroll","left_click_drag","open_application","getComputerUseMCPRenderingOverrides","toolName","userFacingName","renderToolUseMessage","input","options","verbose","ReactNode","renderToolResultMessage","output","progressMessages","filter","Boolean","join","r","isArray","length","bundle_id","String","names","map","a","actions","_progress","summary"],"sources":["toolRendering.tsx"],"sourcesContent":["import * as React from 'react'\nimport { MessageResponse } from '../../components/MessageResponse.js'\nimport { Text } from '../../ink.js'\nimport { truncateToWidth } from '../format.js'\nimport type { MCPToolResult } from '../mcpValidation.js'\n\ntype CuToolInput = Record<string, unknown> & {\n  coordinate?: [number, number]\n  start_coordinate?: [number, number]\n  text?: string\n  apps?: Array<{ displayName?: string }>\n  region?: [number, number, number, number]\n  direction?: string\n  amount?: number\n  duration?: number\n}\n\nfunction fmtCoord(c: [number, number] | undefined): string {\n  return c ? `(${c[0]}, ${c[1]})` : ''\n}\n\nconst RESULT_SUMMARY: Readonly<Partial<Record<string, string>>> = {\n  screenshot: 'Captured',\n  zoom: 'Captured',\n  request_access: 'Access updated',\n  left_click: 'Clicked',\n  right_click: 'Clicked',\n  middle_click: 'Clicked',\n  double_click: 'Clicked',\n  triple_click: 'Clicked',\n  type: 'Typed',\n  key: 'Pressed',\n  hold_key: 'Pressed',\n  scroll: 'Scrolled',\n  left_click_drag: 'Dragged',\n  open_application: 'Opened',\n}\n\n/**\n * Rendering overrides for `mcp__computer-use__*` tools. Spread into the MCP\n * tool object in `client.ts` after the default `userFacingName`, so these win.\n * Mirror of `getClaudeInChromeMCPToolOverrides`.\n */\nexport function getComputerUseMCPRenderingOverrides(toolName: string): {\n  userFacingName: () => string\n  renderToolUseMessage: (\n    input: Record<string, unknown>,\n    options: { verbose: boolean },\n  ) => React.ReactNode\n  renderToolResultMessage: (\n    output: MCPToolResult,\n    progressMessages: unknown[],\n    options: { verbose: boolean },\n  ) => React.ReactNode\n} {\n  return {\n    userFacingName() {\n      return `Computer Use[${toolName}]`\n    },\n\n    // AssistantToolUseMessage.tsx contract: null hides the ENTIRE row, '' shows\n    // the tool name without \"(args)\". Every path below returns '' when there's\n    // nothing to show — never null.\n    renderToolUseMessage(input: CuToolInput) {\n      switch (toolName) {\n        case 'screenshot':\n        case 'left_mouse_down':\n        case 'left_mouse_up':\n        case 'cursor_position':\n        case 'list_granted_applications':\n        case 'read_clipboard':\n          return ''\n\n        case 'left_click':\n        case 'right_click':\n        case 'middle_click':\n        case 'double_click':\n        case 'triple_click':\n        case 'mouse_move':\n          return fmtCoord(input.coordinate)\n\n        case 'left_click_drag':\n          return input.start_coordinate\n            ? `${fmtCoord(input.start_coordinate)} → ${fmtCoord(input.coordinate)}`\n            : `to ${fmtCoord(input.coordinate)}`\n\n        case 'type':\n          return typeof input.text === 'string'\n            ? `\"${truncateToWidth(input.text, 40)}\"`\n            : ''\n\n        case 'key':\n        case 'hold_key':\n          return typeof input.text === 'string' ? input.text : ''\n\n        case 'scroll':\n          return [\n            input.direction,\n            input.amount && `×${input.amount}`,\n            input.coordinate && `at ${fmtCoord(input.coordinate)}`,\n          ]\n            .filter(Boolean)\n            .join(' ')\n\n        case 'zoom': {\n          const r = input.region\n          return Array.isArray(r) && r.length === 4\n            ? `[${r[0]}, ${r[1]}, ${r[2]}, ${r[3]}]`\n            : ''\n        }\n\n        case 'wait':\n          return typeof input.duration === 'number' ? `${input.duration}s` : ''\n\n        case 'write_clipboard':\n          return typeof input.text === 'string'\n            ? `\"${truncateToWidth(input.text, 40)}\"`\n            : ''\n\n        case 'open_application':\n          return typeof input.bundle_id === 'string'\n            ? String(input.bundle_id)\n            : ''\n\n        case 'request_access': {\n          const apps = input.apps\n          if (!Array.isArray(apps)) return ''\n          const names = apps\n            .map(a => (typeof a?.displayName === 'string' ? a.displayName : ''))\n            .filter(Boolean)\n          return names.join(', ')\n        }\n\n        case 'computer_batch': {\n          const actions = input.actions\n          return Array.isArray(actions) ? `${actions.length} actions` : ''\n        }\n\n        default:\n          return ''\n      }\n    },\n\n    renderToolResultMessage(output, _progress, { verbose }) {\n      if (verbose || typeof output !== 'object' || output === null) return null\n\n      // Non-verbose: one-line dim summary, like Chrome's pattern.\n      const summary = RESULT_SUMMARY[toolName]\n      if (!summary) return null\n      return (\n        <MessageResponse height={1}>\n          <Text dimColor>{summary}</Text>\n        </MessageResponse>\n      )\n    },\n  }\n}\n"],"mappings":"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","ignoreList":[]}