@shipers-dev/multi 0.12.0 → 0.12.1

package/dist/index.js

@@ -16272,18 +16272,23 @@ import { join as join4, dirname as dirname3 } from "path";
 // package.json
 var package_default = {
   name: "@shipers-dev/multi",
-  version: "0.12.0",
+  version: "0.12.1",
   type: "module",
   bin: {
     "multi-agent": "./dist/index.js"
   },
+  files: [
+    "dist"
+  ],
   scripts: {
     dev: "bun run src/index.ts",
     build: "bun build src/index.ts --outdir=dist --target=bun"
   },
   dependencies: {
     "@agentclientprotocol/sdk": "^0.20.0",
-    "@agentclientprotocol/claude-agent-acp": "^0.31.0",
+    "@agentclientprotocol/claude-agent-acp": "^0.31.0"
+  },
+  devDependencies: {
     "@multi/lib": "workspace:*"
   }
 };

package/package.json

@@ -1,17 +1,22 @@
 {
   "name": "@shipers-dev/multi",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "type": "module",
   "bin": {
     "multi-agent": "./dist/index.js"
   },
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "dev": "bun run src/index.ts",
     "build": "bun build src/index.ts --outdir=dist --target=bun"
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "^0.20.0",
-    "@agentclientprotocol/claude-agent-acp": "^0.31.0",
+    "@agentclientprotocol/claude-agent-acp": "^0.31.0"
+  },
+  "devDependencies": {
     "@multi/lib": "workspace:*"
   }
 }

package/src/acp-runner.ts

@@ -1,274 +0,0 @@
-// ACP runner — speaks Agent Client Protocol to an agent adapter (claude-code-acp etc).
-// Spawns the adapter as a subprocess over stdio, converts ACP events → our StreamEvent shape
-// and handles client-side callbacks (requestPermission forwarded to server, fs read/write local).
-
-import { ClientSideConnection, ndJsonStream } from '@agentclientprotocol/sdk';
-import type { Client, SessionNotification, RequestPermissionRequest, RequestPermissionResponse, ReadTextFileRequest, ReadTextFileResponse, WriteTextFileRequest, WriteTextFileResponse } from '@agentclientprotocol/sdk';
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
-import { dirname } from 'path';
-import { apiClient } from './client';
-
-function fmtErr(e: any): string {
-  if (e == null) return 'unknown error';
-  if (typeof e === 'string') return e;
-  if (e instanceof Error) return e.message;
-  if (typeof e === 'object') {
-    const inner = e.error ?? e.cause ?? e;
-    const msg = inner?.message ?? e.message ?? e.reason ?? e.statusText;
-    const code = inner?.code ?? e.code ?? e.status;
-    if (msg) return code ? `${msg} (code ${code})` : String(msg);
-    try { return JSON.stringify(e).slice(0, 500); } catch {}
-  }
-  return String(e);
-}
-
-import type { CliStreamEmit } from '@multi/lib';
-export type AcpEvent = CliStreamEmit;
-
-export type AcpRunOpts = {
-  apiUrl: string;
-  issueId: string;
-  deviceId: string;
-  prompt: string;
-  cwd?: string;
-  sessionId?: string | null;
-  adapterBin: string | string[]; // command + args to spawn ACP agent
-  autonomy?: 'manual' | 'ask' | 'auto';
-  onEvent: (ev: AcpEvent) => void | Promise<void>;
-  onSession?: (sessionId: string) => void | Promise<void>;
-  onSpawn?: (child: any) => void;
-};
-
-export async function runAcp(opts: AcpRunOpts): Promise<{ stopReason: string; sessionId: string }> {
-  const cleanEnv: Record<string, string> = {};
-  for (const [k, v] of Object.entries(process.env)) {
-    if (v === undefined) continue;
-    if (k === 'CLAUDECODE' || k.startsWith('CLAUDE_CODE_')) continue;
-    cleanEnv[k] = v;
-  }
-  const argv = Array.isArray(opts.adapterBin) ? opts.adapterBin : [opts.adapterBin];
-  // Daemon has no TTY — default to bypass (claude's --dangerously-skip-permissions equivalent).
-  // Set MULTI_CLAUDE_SAFE=1 to restore interactive permission prompts.
-  const permMode = process.env.MULTI_CLAUDE_SAFE === '1' ? 'default' : 'bypassPermissions';
-  const child = Bun.spawn(argv, {
-    stdio: ['pipe', 'pipe', 'inherit'],
-    cwd: opts.cwd || process.cwd(),
-    env: { ...cleanEnv, ACP_PERMISSION_MODE: permMode },
-  });
-  try { opts.onSpawn?.(child); } catch {}
-
-  // Adapter expects plain newline-delimited JSON on stdio. Wrap child streams as Web Streams.
-  const output = new WritableStream<Uint8Array>({
-    write(chunk) {
-      (child.stdin as any).write(chunk);
-    },
-    close() { try { (child.stdin as any).end?.(); } catch {} },
-  });
-  const input = child.stdout as ReadableStream<Uint8Array>;
-  const stream = ndJsonStream(output, input);
-
-  let activeSessionId: string | null = opts.sessionId || null;
-  let recording = false; // only forward events after prompt() starts
-  let chunkCount = 0; // assistant_text + tool_call chunks seen during prompt()
-  const alwaysAllow = new Set<string>(); // keys: toolName|kind that user said "always allow"
-
-  const client: Client = {
-    async sessionUpdate(params: SessionNotification): Promise<void> {
-      if (!recording) return; // drop replay chatter during loadSession
-      await handleSessionUpdate(params, opts);
-    },
-    async requestPermission(params: RequestPermissionRequest): Promise<RequestPermissionResponse> {
-      return await handleRequestPermission(params, opts, alwaysAllow);
-    },
-    async readTextFile(params: ReadTextFileRequest): Promise<ReadTextFileResponse> {
-      try {
-        const content = readFileSync(params.path, 'utf8');
-        const sliced = typeof params.line === 'number' && typeof params.limit === 'number'
-          ? content.split('\n').slice(params.line, params.line + params.limit).join('\n')
-          : content;
-        return { content: sliced };
-      } catch (e) {
-        throw new Error(`readTextFile failed: ${fmtErr(e)}`);
-      }
-    },
-    async writeTextFile(params: WriteTextFileRequest): Promise<WriteTextFileResponse> {
-      try {
-        const dir = dirname(params.path);
-        if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-        writeFileSync(params.path, params.content, 'utf8');
-        return {};
-      } catch (e) {
-        throw new Error(`writeTextFile failed: ${fmtErr(e)}`);
-      }
-    },
-  };
-
-  const conn = new ClientSideConnection(() => client, stream);
-
-  try {
-    await conn.initialize({
-      protocolVersion: 1,
-      clientCapabilities: {
-        fs: { readTextFile: true, writeTextFile: true },
-        terminal: false,
-      },
-    } as any);
-
-    if (!activeSessionId) {
-      const { sessionId } = await conn.newSession({
-        cwd: opts.cwd || process.cwd(),
-        mcpServers: [],
-      } as any);
-      activeSessionId = sessionId;
-      if (opts.onSession) await opts.onSession(sessionId);
-      await opts.onEvent({ event_type: 'progress', payload: { message: `ACP session ${sessionId.slice(0, 8)} created` } });
-    } else {
-      try {
-        await conn.loadSession?.({ sessionId: activeSessionId, cwd: opts.cwd || process.cwd(), mcpServers: [] } as any);
-        await opts.onEvent({ event_type: 'progress', payload: { message: `ACP session ${activeSessionId.slice(0, 8)} resumed` } });
-      } catch (e) {
-        await opts.onEvent({ event_type: 'progress', payload: { message: `load_session failed; starting new. ${fmtErr(e)}` } });
-        const { sessionId } = await conn.newSession({ cwd: opts.cwd || process.cwd(), mcpServers: [] } as any);
-        activeSessionId = sessionId;
-        if (opts.onSession) await opts.onSession(sessionId);
-      }
-    }
-
-    recording = true;
-    const runPrompt = async () => {
-      chunkCount = 0;
-      return await conn.prompt({
-        sessionId: activeSessionId!,
-        prompt: [{ type: 'text', text: opts.prompt }],
-      } as any);
-    };
-
-    let res = await runPrompt();
-    let stopReason = (res as any).stopReason;
-
-    // Resumed session that returned zero chunks → session is likely stale in the adapter.
-    // Retry once with a fresh session so user gets an actual response.
-    if (chunkCount === 0 && opts.sessionId) {
-      await opts.onEvent({ event_type: 'progress', payload: { message: `resumed session produced no output (stopReason=${stopReason}); retrying with fresh session` } });
-      try {
-        const fresh = await conn.newSession({ cwd: opts.cwd || process.cwd(), mcpServers: [] } as any);
-        activeSessionId = fresh.sessionId;
-        if (opts.onSession) await opts.onSession(fresh.sessionId);
-        res = await runPrompt();
-        stopReason = (res as any).stopReason;
-      } catch (e) {
-        await opts.onEvent({ event_type: 'error', payload: { message: `retry with fresh session failed: ${fmtErr(e)}` } });
-      }
-    }
-
-    if (chunkCount === 0) {
-      await opts.onEvent({ event_type: 'error', payload: { message: `agent produced no output (stopReason=${stopReason})` } });
-    }
-
-    await opts.onEvent({ event_type: 'result', payload: { stopReason } });
-    return { stopReason, sessionId: activeSessionId! };
-  } finally {
-    try { child.kill(); } catch {}
-  }
-
-  async function handleSessionUpdate(params: SessionNotification, o: AcpRunOpts) {
-    const u: any = params.update;
-    const kind = u.sessionUpdate;
-    switch (kind) {
-      case 'agent_message_chunk':
-      case 'agent_thought_chunk': {
-        const text = extractText(u.content);
-        if (text) { chunkCount++; await o.onEvent({ event_type: 'assistant_text', payload: { text } }); }
-        break;
-      }
-      case 'tool_call':
-      case 'tool_call_update': {
-        chunkCount++;
-        await o.onEvent({ event_type: 'tool_call', payload: {
-          id: u.toolCallId || u.id, tool: u.title || u.toolName || 'tool', kind: u.kind, status: u.status, input: u.rawInput, locations: u.locations,
-        }});
-        // Surface tool_call content (e.g. diff/text/terminal) as tool_result if present
-        if (Array.isArray(u.content)) {
-          for (const c of u.content) {
-            if (c.type === 'content' && c.content?.type === 'text') {
-              await o.onEvent({ event_type: 'tool_result', payload: { tool_use_id: u.toolCallId || u.id, content: c.content.text.slice(0, 4000) } });
-            } else if (c.type === 'diff') {
-              const diff = `--- ${c.path}\n${c.oldText || ''}\n+++ ${c.path}\n${c.newText || ''}`.slice(0, 4000);
-              await o.onEvent({ event_type: 'tool_result', payload: { tool_use_id: u.toolCallId || u.id, content: diff } });
-            }
-          }
-        }
-        break;
-      }
-      case 'plan': {
-        const entries = (u.entries || []).map((e: any, i: number) => `${i + 1}. [${e.status || 'pending'}] ${e.content}`).join('\n');
-        if (entries) await o.onEvent({ event_type: 'assistant_text', payload: { text: `**Plan**\n\n${entries}` } });
-        break;
-      }
-      case 'current_mode_update': {
-        await o.onEvent({ event_type: 'progress', payload: { message: `mode=${u.currentModeId}` } });
-        break;
-      }
-      default: break;
-    }
-  }
-
-  async function handleRequestPermission(params: RequestPermissionRequest, o: AcpRunOpts, allowCache: Set<string>): Promise<RequestPermissionResponse> {
-    const tc: any = params.toolCall || {};
-    const toolKey = `${tc.toolName || tc.title || ''}|${tc.kind || ''}`.toLowerCase();
-
-    // Autonomy=auto: auto-approve everything, prefer "always" variant so adapter caches it.
-    if (o.autonomy === 'auto') {
-      const opts = params.options as any[];
-      const alwaysOpt = opts.find(op => /always/i.test(op.name || '') || /allow_always/i.test(op.kind || ''));
-      const allowOpt = opts.find(op => /allow/i.test(op.kind || '') || /allow/i.test(op.name || ''));
-      const chosen = alwaysOpt || allowOpt;
-      if (chosen) return { outcome: { outcome: 'selected', optionId: chosen.optionId } as any };
-    }
-
-    // Auto-approve if user previously chose "always allow" for same tool/kind
-    if (toolKey && allowCache.has(toolKey)) {
-      const allowOpt = (params.options as any[]).find(op => /allow/i.test(op.kind || '') || /allow/i.test(op.name || ''));
-      if (allowOpt) return { outcome: { outcome: 'selected', optionId: allowOpt.optionId } as any };
-    }
-
-    const created = await apiClient.post<any>(`${o.apiUrl}/api/permissions`, {
-      issue_id: o.issueId,
-      device_id: o.deviceId,
-      tool_call_id: tc.id || tc.toolCallId,
-      tool_name: tc.title || tc.toolName,
-      summary: tc.title,
-      options: params.options.map((op: any) => ({ optionId: op.optionId, name: op.name, kind: op.kind })),
-    });
-    const permId = created.data?.id;
-    if (!permId) return { outcome: { outcome: 'cancelled' } as any };
-
-    const deadline = Date.now() + 5 * 60 * 1000;
-    while (Date.now() < deadline) {
-      await new Promise(r => setTimeout(r, 500));
-      const got = await apiClient.get<any>(`${o.apiUrl}/api/permissions/${permId}`);
-      const row = got.data;
-      if (!row) break;
-      if (row.status === 'resolved' && row.chosen) {
-        // If the chosen option is an "always" variant, cache it
-        const chosenOpt = (params.options as any[]).find(op => op.optionId === row.chosen);
-        const isAlways = chosenOpt && (/always/i.test(chosenOpt.name || '') || /allow_always/i.test(chosenOpt.kind || ''));
-        if (isAlways && toolKey) allowCache.add(toolKey);
-        return { outcome: { outcome: 'selected', optionId: row.chosen } as any };
-      }
-      if (row.status === 'cancelled') {
-        return { outcome: { outcome: 'cancelled' } as any };
-      }
-    }
-    return { outcome: { outcome: 'cancelled' } as any };
-  }
-}
-
-function extractText(content: any): string {
-  if (!content) return '';
-  if (typeof content === 'string') return content;
-  if (Array.isArray(content)) return content.map(extractText).join('');
-  if (content.type === 'text' && typeof content.text === 'string') return content.text;
-  if (content.text) return content.text;
-  return '';
-}

package/src/acpx-runner.ts

@@ -1,177 +0,0 @@
-// acpx-runner — delegate to `acpx` CLI for pi/codex/openclaw agents.
-// acpx emits raw ACP JSON-RPC NDJSON on stdout with --format json; we reuse the
-// same parse semantics as our direct ACP runner to produce AcpEvent stream.
-//
-// Requires: `npm install -g acpx` on device host (or npx acpx@latest).
-// Runs with --approve-all for now (no permission UI forwarding).
-
-import type { AcpEvent } from './acp-runner';
-import { appendFileSync } from 'fs';
-import { join } from 'path';
-
-const HOME = process.env.HOME || process.env.USERPROFILE || '.';
-const LOG_PATH = join(HOME, '.multi', 'logs', 'agent.log');
-function dlog(msg: string) {
-  try { appendFileSync(LOG_PATH, `[${new Date().toISOString()}] ${msg}\n`); } catch {}
-}
-
-export interface AcpxRunOpts {
-  agentType: 'pi' | 'codex' | 'openclaw' | 'claude' | string;
-  prompt: string;
-  cwd?: string;
-  sessionName?: string; // reuse same session across follow-ups (e.g. "issue-<id>")
-  onEvent: (ev: AcpEvent) => void | Promise<void>;
-  onSpawn?: (child: any) => void;
-}
-
-export async function runAcpx(opts: AcpxRunOpts): Promise<{ stopReason: string }> {
-  const args = ['acpx', '--format', 'json', '--json-strict', '--approve-all', '--ttl', '0'];
-  if (opts.cwd) args.push('--cwd', opts.cwd);
-  args.push(opts.agentType);
-  // Ensure a session exists for this name (idempotent). ensure = get-or-create.
-  // We run it as a separate invocation, then prompt.
-  if (opts.sessionName) {
-    const ensureArgs = ['acpx', '--ttl', '0', ...(opts.cwd ? ['--cwd', opts.cwd] : []), opts.agentType, 'sessions', 'ensure', '--name', opts.sessionName];
-    dlog(`[acpx] ensure: ${ensureArgs.join(' ')}`);
-    try {
-      const ensure = Bun.spawn(ensureArgs, { stdout: 'pipe', stderr: 'pipe', stdin: 'ignore' });
-      const ensureOut = await new Response(ensure.stdout as any).text();
-      const ensureErr = await new Response(ensure.stderr as any).text();
-      const ensureCode = await ensure.exited;
-      dlog(`[acpx] ensure exit=${ensureCode} stdout=${ensureOut.slice(0, 300)} stderr=${ensureErr.slice(0, 300)}`);
-    } catch (e) {
-      dlog(`[acpx] ensure spawn error: ${String(e)}`);
-    }
-    args.push('prompt', '-s', opts.sessionName);
-  } else {
-    args.push('prompt');
-  }
-  args.push(opts.prompt);
-
-  dlog(`[acpx] prompt: ${args.slice(0, 10).join(' ')} ... (prompt len=${opts.prompt.length})`);
-  const proc = Bun.spawn(args, { stdout: 'pipe', stderr: 'pipe', stdin: 'ignore' });
-  try { opts.onSpawn?.(proc); } catch {}
-  let stopReason = 'end_turn';
-
-  // Forward stderr to our progress stream so we can debug in the UI/logs
-  (async () => {
-    try {
-      const r = (proc.stderr as ReadableStream<Uint8Array>).getReader();
-      const d = new TextDecoder();
-      let sb = '';
-      while (true) {
-        const { value, done } = await r.read();
-        if (done) break;
-        sb += d.decode(value, { stream: true });
-        let nl: number;
-        while ((nl = sb.indexOf('\n')) !== -1) {
-          const ln = sb.slice(0, nl).trim();
-          sb = sb.slice(nl + 1);
-          if (ln) dlog(`[acpx stderr] ${ln.slice(0, 500)}`);
-        }
-      }
-    } catch {}
-  })();
-
-  const reader = (proc.stdout as ReadableStream<Uint8Array>).getReader();
-  const dec = new TextDecoder();
-  let buf = '';
-
-  let lineCount = 0;
-  while (true) {
-    const { value, done } = await reader.read();
-    if (done) break;
-    buf += dec.decode(value, { stream: true });
-    let nl: number;
-    while ((nl = buf.indexOf('\n')) !== -1) {
-      const line = buf.slice(0, nl).trim();
-      buf = buf.slice(nl + 1);
-      if (!line) continue;
-      lineCount++;
-      dlog(`[acpx stdout] ${line.slice(0, 500)}`);
-      const events = parseAcpLine(line, (r) => { stopReason = r; });
-      for (const ev of events) await opts.onEvent(ev);
-    }
-  }
-  dlog(`[acpx] stdout lines total=${lineCount}`);
-  if (buf.trim()) {
-    const events = parseAcpLine(buf.trim(), (r) => { stopReason = r; });
-    for (const ev of events) await opts.onEvent(ev);
-  }
-
-  const code = await proc.exited;
-  if (code !== 0 && code !== 130) {
-    await opts.onEvent({ event_type: 'error', payload: { message: `acpx exited with code ${code}` } });
-  }
-  return { stopReason };
-}
-
-function parseAcpLine(line: string, setStop: (r: string) => void): AcpEvent[] {
-  let msg: any;
-  try { msg = JSON.parse(line); } catch { return []; }
-  const out: AcpEvent[] = [];
-
-  // session/update notification
-  if (msg.method === 'session/update' && msg.params?.update?.sessionUpdate) {
-    return handleSessionUpdate(msg.params);
-  }
-  // prompt result
-  if (msg.id && msg.result && typeof msg.result === 'object' && 'stopReason' in msg.result) {
-    setStop(msg.result.stopReason);
-    out.push({ event_type: 'result', payload: { stopReason: msg.result.stopReason } });
-    return out;
-  }
-  // errors
-  if (msg.error) {
-    out.push({ event_type: 'error', payload: { message: msg.error.message || JSON.stringify(msg.error) } });
-    return out;
-  }
-  return out;
-}
-
-function handleSessionUpdate(params: any): AcpEvent[] {
-  const u = params.update || {};
-  const kind = u.sessionUpdate;
-  const out: AcpEvent[] = [];
-  switch (kind) {
-    case 'agent_message_chunk':
-    case 'agent_thought_chunk': {
-      const text = extractText(u.content);
-      if (text) out.push({ event_type: 'assistant_text', payload: { text } });
-      break;
-    }
-    case 'tool_call':
-    case 'tool_call_update': {
-      out.push({ event_type: 'tool_call', payload: {
-        id: u.toolCallId || u.id, tool: u.title || u.toolName || 'tool',
-        kind: u.kind, status: u.status, input: u.rawInput, locations: u.locations,
-      }});
-      if (Array.isArray(u.content)) {
-        for (const c of u.content) {
-          if (c.type === 'content' && c.content?.type === 'text') {
-            out.push({ event_type: 'tool_result', payload: { tool_use_id: u.toolCallId || u.id, content: String(c.content.text).slice(0, 4000) } });
-          } else if (c.type === 'diff') {
-            const diff = `--- ${c.path}\n${c.oldText || ''}\n+++ ${c.path}\n${c.newText || ''}`.slice(0, 4000);
-            out.push({ event_type: 'tool_result', payload: { tool_use_id: u.toolCallId || u.id, content: diff } });
-          }
-        }
-      }
-      break;
-    }
-    case 'plan': {
-      const entries = (u.entries || []).map((e: any, i: number) => `${i + 1}. [${e.status || 'pending'}] ${e.content}`).join('\n');
-      if (entries) out.push({ event_type: 'assistant_text', payload: { text: `**Plan**\n\n${entries}` } });
-      break;
-    }
-  }
-  return out;
-}
-
-function extractText(content: any): string {
-  if (!content) return '';
-  if (typeof content === 'string') return content;
-  if (Array.isArray(content)) return content.map(extractText).join('');
-  if (content.type === 'text' && typeof content.text === 'string') return content.text;
-  if (content.text) return content.text;
-  return '';
-}

package/src/client.ts

@@ -1,46 +0,0 @@
-interface ApiResponse<T = unknown> {
-  success: boolean;
-  data?: T;
-  error?: string;
-  status?: number;
-}
-
-let authToken: string | null = null;
-
-export function setAuthToken(token: string | null) {
-  authToken = token;
-}
-
-async function request<T>(url: string, options?: RequestInit): Promise<ApiResponse<T>> {
-  try {
-    const headers: Record<string, string> = {
-      'Content-Type': 'application/json',
-      ...(options?.headers as Record<string, string> | undefined),
-    };
-    if (authToken && !headers['Authorization']) headers['Authorization'] = `Bearer ${authToken}`;
-
-    const response = await fetch(url, { ...options, headers });
-    const raw = await response.json().catch(() => ({}));
-
-    if (!response.ok) {
-      return { success: false, error: (raw as any)?.error || `HTTP ${response.status}`, status: response.status };
-    }
-
-    const data = (raw && typeof raw === 'object' && 'results' in (raw as any))
-      ? (raw as any).results
-      : raw;
-
-    return { success: true, data, status: response.status };
-  } catch (error) {
-    return { success: false, error: String(error) };
-  }
-}
-
-export const apiClient = {
-  get: <T = unknown>(url: string) => request<T>(url),
-  post: <T = unknown>(url: string, body: unknown, opts?: { headers?: Record<string, string> }) =>
-    request<T>(url, { method: 'POST', body: JSON.stringify(body), headers: opts?.headers }),
-  patch: <T = unknown>(url: string, body: unknown, opts?: { headers?: Record<string, string> }) =>
-    request<T>(url, { method: 'PATCH', body: JSON.stringify(body), headers: opts?.headers }),
-  delete: <T = unknown>(url: string) => request<T>(url, { method: 'DELETE' }),
-};

package/src/detect.ts

@@ -1,70 +0,0 @@
-export type AgentType = 'claude-code' | 'codex' | 'gemini-cli' | 'openclaw' | 'opencode' | 'pi' | 'custom';
-
-export interface DetectedAgent {
-  type: AgentType;
-  path: string;
-  version?: string;
-}
-
-const AGENT_BINARIES: Record<AgentType, string[]> = {
-  'claude-code': ['claude', 'claude-code', 'claude_code'],
-  'codex': ['codex', 'openai-codex'],
-  'gemini-cli': ['gemini', 'gemini-cli', 'google-gemini'],
-  'openclaw': ['openclaw'],
-  'opencode': ['opencode'],
-  'pi': ['pi'],
-  'custom': [],
-};
-
-export async function detectAgents(): Promise<DetectedAgent[]> {
-  const detected: DetectedAgent[] = [];
-  
-  // Check PATH for known agent binaries
-  const path = Bun.env.PATH?.split(':') || [];
-  
-  for (const [type, binaries] of Object.entries(AGENT_BINARIES)) {
-    if (type === 'custom') continue;
-    
-    for (const binary of binaries) {
-      const found = await which(binary);
-      if (found) {
-        const version = await getVersion(found);
-        detected.push({ type: type as AgentType, path: found, version });
-        break;
-      }
-    }
-  }
-  
-  return detected;
-}
-
-async function which(cmd: string): Promise<string | null> {
-  for (const dir of Bun.env.PATH?.split(':') || []) {
-    const fullPath = `${dir}/${cmd}`;
-    try {
-      const stat = await fileExists(fullPath);
-      if (stat) return fullPath;
-    } catch {
-      // Continue
-    }
-  }
-  return null;
-}
-
-async function fileExists(path: string): Promise<boolean> {
-  try {
-    return await Bun.file(path).exists();
-  } catch {
-    return false;
-  }
-}
-
-async function getVersion(path: string): Promise<string | undefined> {
-  try {
-    const proc = Bun.spawn([path, '--version'], { stdout: 'pipe' });
-    const output = await new Response(proc.stdout).text();
-    return output.trim() || undefined;
-  } catch {
-    return undefined;
-  }
-}