@shipers-dev/multi 0.1.0

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@shipers-dev/multi",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "multi-agent": "./dist/index.js"
+  },
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "build": "bun build src/index.ts --outdir=dist --target=bun"
+  },
+  "dependencies": {
+    "@multi/lib": "workspace:*",
+    "@zed-industries/agent-client-protocol": "^0.4.5",
+    "@zed-industries/claude-code-acp": "^0.16.2"
+  }
+}

package/src/acp-runner.ts

@@ -0,0 +1,211 @@
+// 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 '@zed-industries/agent-client-protocol';
+import type { Client, SessionNotification, RequestPermissionRequest, RequestPermissionResponse, ReadTextFileRequest, ReadTextFileResponse, WriteTextFileRequest, WriteTextFileResponse } from '@zed-industries/agent-client-protocol';
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { dirname } from 'path';
+import { apiClient } from './client';
+
+export type AcpEvent =
+  | { event_type: 'progress'; payload: any }
+  | { event_type: 'assistant_text'; payload: { text: string } }
+  | { event_type: 'tool_call'; payload: { id: string; tool: string; kind?: string; status?: string; input?: any; locations?: any[] } }
+  | { event_type: 'tool_result'; payload: { tool_use_id: string; content: string } }
+  | { event_type: 'result'; payload: { result?: string; duration_ms?: number; total_cost_usd?: number; stopReason?: string } }
+  | { event_type: 'error'; payload: { message: string } };
+
+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
+  onEvent: (ev: AcpEvent) => void | Promise<void>;
+  onSession?: (sessionId: string) => void | Promise<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];
+  const child = Bun.spawn(argv, {
+    stdio: ['pipe', 'pipe', 'inherit'],
+    cwd: opts.cwd || process.cwd(),
+    env: { ...cleanEnv, ACP_PERMISSION_MODE: 'default' },
+  });
+
+  // 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
+
+  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);
+    },
+    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: ${String(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: ${String(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. ${String(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 res = await conn.prompt({
+      sessionId: activeSessionId!,
+      prompt: [{ type: 'text', text: opts.prompt }],
+    } as any);
+
+    await opts.onEvent({ event_type: 'result', payload: { stopReason: (res as any).stopReason } });
+    return { stopReason: (res as any).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) await o.onEvent({ event_type: 'assistant_text', payload: { text } });
+        break;
+      }
+      case 'tool_call':
+      case 'tool_call_update': {
+        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): Promise<RequestPermissionResponse> {
+    const tc: any = params.toolCall || {};
+    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 };
+
+    // Poll every 500ms up to 5 min
+    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) {
+        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/client.ts

@@ -0,0 +1,40 @@
+interface ApiResponse<T = unknown> {
+  success: boolean;
+  data?: T;
+  error?: string;
+}
+
+async function request<T>(url: string, options?: RequestInit): Promise<ApiResponse<T>> {
+  try {
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        'Content-Type': 'application/json',
+        ...options?.headers,
+      },
+    });
+
+    const raw = await response.json();
+
+    if (!response.ok) {
+      return { success: false, error: (raw as any)?.error || `HTTP ${response.status}` };
+    }
+
+    const data = (raw && typeof raw === 'object' && 'results' in (raw as any))
+      ? (raw as any).results
+      : raw;
+
+    return { success: true, data };
+  } 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) =>
+    request<T>(url, { method: 'POST', body: JSON.stringify(body) }),
+  patch: <T = unknown>(url: string, body: unknown) =>
+    request<T>(url, { method: 'PATCH', body: JSON.stringify(body) }),
+  delete: <T = unknown>(url: string) => request<T>(url, { method: 'DELETE' }),
+};

package/src/detect.ts

@@ -0,0 +1,70 @@
+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;
+  }
+}