@shipers-dev/multi 0.1.0

package/src/index.ts

@@ -0,0 +1,801 @@
+#!/usr/bin/env bun
+
+import { detectAgents } from './detect';
+import { apiClient } from './client';
+import { runAcp } from './acp-runner';
+import { parseArgs } from 'util';
+import { mkdirSync, existsSync, writeFileSync, readFileSync, appendFileSync, unlinkSync } from 'fs';
+import { join, dirname } from 'path';
+
+const HOME = process.env.HOME || process.env.USERPROFILE || '.';
+const MULTI_DIR = join(HOME, '.multi');
+const CONFIG_PATH = join(MULTI_DIR, 'config.json');
+const PID_PATH = join(MULTI_DIR, 'agent.pid');
+const LOG_PATH = join(MULTI_DIR, 'logs', 'agent.log');
+const SKILLS_DIR = join(MULTI_DIR, 'skills');
+const STOP_PATH = join(MULTI_DIR, 'stop.flag');
+
+const COMMANDS = {
+  setup: 'Register this device with a workspace',
+  connect: 'Connect device to realtime hub and execute assigned tasks',
+  link: 'Link this device to an agent (agent_id required)',
+  status: 'Show current status',
+  stop: 'Stop the running daemon',
+  logs: 'View execution logs',
+} as const;
+
+type Command = keyof typeof COMMANDS;
+
+function ensureDirs() {
+  for (const d of [MULTI_DIR, join(MULTI_DIR, 'logs'), SKILLS_DIR]) {
+    if (!existsSync(d)) mkdirSync(d, { recursive: true });
+  }
+}
+
+function log(msg: string) {
+  ensureDirs();
+  const line = `[${new Date().toISOString()}] ${msg}\n`;
+  appendFileSync(LOG_PATH, line);
+  process.stdout.write(line);
+}
+
+async function main() {
+  const args = parseArgs({
+    args: Bun.argv,
+    options: {
+      help: { type: 'boolean', default: false },
+      name: { type: 'string' },
+      workspace: { type: 'string' },
+      agent: { type: 'string' },
+      api: { type: 'string' },
+    },
+    allowPositionals: true,
+  });
+
+  const [command] = args.positionals.slice(2) as Command[];
+
+  if (args.values.help || !command) {
+    printHelp();
+    process.exit(0);
+  }
+
+  const apiUrl = args.values.api || process.env.MULTI_API_URL || 'https://multi-api.adnb3r.workers.dev';
+  const config = loadConfig();
+
+  switch (command) {
+    case 'setup':
+      await cmdSetup(args.values.name, args.values.workspace, apiUrl);
+      break;
+    case 'connect':
+    case 'start':
+      await cmdConnect(apiUrl, config);
+      break;
+    case 'link':
+      await cmdLink(apiUrl, config, args.values.agent);
+      break;
+    case 'status':
+      await cmdStatus(apiUrl, config);
+      break;
+    case 'stop':
+      await cmdStop();
+      break;
+    case 'logs':
+      await cmdLogs();
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      printHelp();
+      process.exit(1);
+  }
+}
+
+function printHelp() {
+  console.log(`
+multi-agent - Device CLI for Multi platform
+
+Usage: multi-agent <command> [options]
+
+Commands:
+  setup     ${COMMANDS.setup}
+  link      ${COMMANDS.link}
+  connect   ${COMMANDS.connect}
+  status    ${COMMANDS.status}
+  stop      ${COMMANDS.stop}
+  logs      ${COMMANDS.logs}
+
+Options:
+  --name <name>       Device name
+  --workspace <id>    Workspace ID
+  --agent <id>        Agent ID (for link)
+  --api <url>         API URL (default: http://localhost:8787)
+  --help              Show this help
+
+Examples:
+  multi-agent setup --name "My Mac" --workspace ws_xxx
+  multi-agent link --agent agent_xxx
+  multi-agent connect
+`);
+}
+
+async function cmdSetup(name?: string, workspaceId?: string, apiUrl?: string) {
+  ensureDirs();
+  if (!workspaceId) {
+    console.log('❌ Workspace ID required. Run: multi-agent setup --workspace <id>');
+    process.exit(1);
+  }
+
+  console.log('🔍 Detecting local agent runtimes...');
+  const detected = await detectAgents();
+  for (const a of detected) console.log(`  ✓ ${a.type} at ${a.path}`);
+  if (!detected.length) console.log('  (none detected — stub runtime will be used)');
+
+  const deviceName = name || process.env.HOSTNAME || 'Unknown Device';
+  console.log(`\n📝 Registering device "${deviceName}"...`);
+
+  const result = await apiClient.post<{ id: string }>(`${apiUrl}/api/devices/register`, {
+    workspace_id: workspaceId,
+    name: deviceName,
+    platform: process.platform,
+    arch: process.arch,
+    os_version: process.version,
+    detected_runtimes: detected.map(a => a.type),
+  });
+
+  if (!result.success || !result.data) {
+    console.log('\n❌ Registration failed:', result.error);
+    process.exit(1);
+  }
+
+  console.log(`✅ Device registered. ID: ${result.data.id}`);
+  saveConfig({ deviceId: result.data.id, workspaceId, apiUrl });
+  await syncSkills(apiUrl!, workspaceId);
+  console.log('\nNext: link to an agent with: multi-agent link --agent <agentId>');
+  console.log('Then: multi-agent connect');
+}
+
+async function syncSkills(apiUrl: string, workspaceId: string) {
+  const res = await apiClient.get<any[]>(`${apiUrl}/api/skills?workspace_id=${workspaceId}`);
+  if (!res.success || !Array.isArray(res.data)) return;
+  ensureDirs();
+  for (const skill of res.data) {
+    writeFileSync(join(SKILLS_DIR, `${skill.name}.json`), JSON.stringify(skill, null, 2));
+  }
+  if (res.data.length) console.log(`   Synced ${res.data.length} skill(s) → ${SKILLS_DIR}`);
+}
+
+async function cmdLink(apiUrl: string, config: Config, agentId?: string) {
+  if (!config.deviceId) {
+    console.log('❌ Not registered. Run "multi-agent setup" first.');
+    process.exit(1);
+  }
+  if (!agentId) {
+    console.log('❌ Agent ID required: multi-agent link --agent <id>');
+    process.exit(1);
+  }
+  const res = await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/link`, { agent_id: agentId });
+  if (!res.success) {
+    console.log('❌ Link failed:', res.error);
+    process.exit(1);
+  }
+  console.log(`✅ Linked agent ${agentId} ↔ device ${config.deviceId}`);
+}
+
+async function cmdConnect(apiUrl: string, config: Config) {
+  if (!config.deviceId) {
+    console.log('❌ Not registered. Run "multi-agent setup" first.');
+    process.exit(1);
+  }
+
+  if (existsSync(PID_PATH)) {
+    const pid = Number(readFileSync(PID_PATH, 'utf8').trim());
+    if (pid && isRunning(pid)) {
+      console.log(`❌ Daemon already running (pid ${pid}).`);
+      process.exit(1);
+    }
+    unlinkSync(PID_PATH);
+  }
+  ensureDirs();
+  writeFileSync(PID_PATH, String(process.pid));
+  if (existsSync(STOP_PATH)) unlinkSync(STOP_PATH);
+
+  const detected = await detectAgents();
+  log(`🚀 Connecting device ${config.deviceId} (pid ${process.pid})`);
+  log(`   runtimes: ${detected.map(d => d.type).join(', ') || 'stub'}`);
+
+  await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: 'online' });
+
+  const wsUrl = apiUrl.replace(/^http/, 'ws') + `/ws/devices/${config.deviceId}`;
+  let ws: WebSocket | null = null;
+  let running = true;
+
+  const shutdown = async (reason: string) => {
+    if (!running) return;
+    running = false;
+    log(`🛑 Shutting down (${reason})`);
+    try { ws?.close(); } catch {}
+    await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: 'offline' });
+    if (existsSync(PID_PATH)) unlinkSync(PID_PATH);
+    if (existsSync(STOP_PATH)) unlinkSync(STOP_PATH);
+    log('👋 Disconnected');
+    process.exit(0);
+  };
+  process.on('SIGINT', () => shutdown('SIGINT'));
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+
+  const connect = () => {
+    ws = new WebSocket(wsUrl);
+    ws.addEventListener('open', () => log(`🔌 WS connected: ${wsUrl}`));
+    ws.addEventListener('message', async (ev) => {
+      try {
+        const msg = JSON.parse(typeof ev.data === 'string' ? ev.data : '');
+        if (msg.type === 'run_task') {
+          await handleRunTask(apiUrl, config.deviceId!, msg.task, detected);
+        }
+      } catch (e) {
+        log(`msg parse error: ${String(e)}`);
+      }
+    });
+    ws.addEventListener('close', () => {
+      if (!running) return;
+      log('⚠️  WS closed, reconnecting in 3s');
+      setTimeout(connect, 3000);
+    });
+    ws.addEventListener('error', (e) => log(`WS error: ${String((e as any).message || e)}`));
+  };
+  connect();
+
+  // Heartbeat loop
+  while (running) {
+    await sleep(20000);
+    if (existsSync(STOP_PATH)) { await shutdown('stop flag'); break; }
+    try {
+      await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: 'online' });
+    } catch (e) {
+      log(`heartbeat error: ${String(e)}`);
+    }
+  }
+}
+
+async function handleRunTask(apiUrl: string, deviceId: string, task: any, detected: { type: string; path: string }[]) {
+  const issueId = task.issue_id;
+  const isFollowup = !!task.followup;
+  log(`▶ run_task ${task.key}: ${isFollowup ? '(follow-up) ' : ''}${task.title}`);
+
+  await apiClient.patch(`${apiUrl}/api/issues/${issueId}`, { status: 'in_progress' });
+  await postStream(apiUrl, issueId, 'progress', { message: `Device ${deviceId} picked up ${isFollowup ? 'follow-up' : 'task'}` });
+
+  let liveCommentId: string | undefined;
+  let liveBody = '';
+  let hadError = false;
+  let hasAssistantText = false;
+
+  const ensureLiveComment = async () => {
+    if (liveCommentId) return;
+    const res = await apiClient.post<any>(`${apiUrl}/api/issues/${issueId}/comments`, {
+      author_type: 'agent', author_id: task.agent_id, author_name: 'agent', body: '…',
+    });
+    liveCommentId = res.data?.id;
+  };
+  const patchLive = async (body: string) => {
+    if (!liveCommentId) return;
+    try { await apiClient.patch(`${apiUrl}/api/issues/${issueId}/comments/${liveCommentId}`, { body: body || '…' }); } catch {}
+  };
+  const postComment = async (body: string) => {
+    try { await apiClient.post(`${apiUrl}/api/issues/${issueId}/comments`, { author_type: 'agent', author_id: task.agent_id, author_name: 'agent', body }); } catch {}
+  };
+
+  type ToolEntry = { id: string; tool: string; kind?: string; status?: string; input?: any; results: string[] };
+  const turn = {
+    text: '' as string,
+    toolOrder: [] as string[],
+    tools: new Map<string, ToolEntry>(),
+    plans: [] as string[],
+    progress: [] as string[],
+    result: null as null | { duration_ms?: number; total_cost_usd?: number; stopReason?: string; is_error?: boolean },
+    error: null as null | string,
+  };
+
+  const render = (): string => {
+    const parts: string[] = [];
+    if (turn.text) parts.push(turn.text);
+
+    for (const id of turn.toolOrder) {
+      const t = turn.tools.get(id);
+      if (!t) continue;
+      const icon = statusIcon(t.status);
+      const cleanTool = stripMd(t.tool);
+      const head = `${icon} ${cleanTool}${t.kind ? ` · ${t.kind}` : ''}${t.status && t.status !== 'completed' ? ` · ${t.status}` : ''}`;
+      const body: string[] = [];
+      if (t.input !== undefined && t.input !== null) {
+        const inputStr = typeof t.input === 'object' ? JSON.stringify(t.input, null, 2) : String(t.input);
+        body.push('```json\n' + inputStr + '\n```');
+      }
+      if (t.results.length) {
+        const joined = t.results.join('\n').slice(-2000);
+        body.push('**Output**\n\n```\n' + joined + '\n```');
+      }
+      parts.push(`<details>\n<summary>${head}</summary>\n\n${body.join('\n\n')}\n</details>`);
+    }
+
+    if (turn.plans.length) parts.push('**Plan**\n\n' + turn.plans[turn.plans.length - 1]);
+
+    if (turn.error) parts.push(`> ❌ ${turn.error}`);
+
+    if (turn.result) {
+      const bits: string[] = [];
+      if (turn.result.duration_ms) bits.push(`${Math.round(turn.result.duration_ms)}ms`);
+      if (turn.result.total_cost_usd) bits.push(`$${Number(turn.result.total_cost_usd).toFixed(4)}`);
+      if (turn.result.stopReason) bits.push(turn.result.stopReason);
+      if (bits.length) parts.push(`---\n_${bits.join(' · ')}_`);
+    }
+
+    return parts.join('\n\n') || '…';
+  };
+
+  let renderScheduled = false;
+  const schedulePatch = () => {
+    if (renderScheduled) return;
+    renderScheduled = true;
+    queueMicrotask(async () => {
+      renderScheduled = false;
+      try { await patchLive(render()); } catch {}
+    });
+  };
+
+  const eventHandler = async (event: any) => {
+    if (event.event_type === 'error') hadError = true;
+    await postStream(apiUrl, issueId, event.event_type, event.payload);
+
+    const p: any = event.payload || {};
+    switch (event.event_type) {
+      case 'progress': {
+        if (p.message) turn.progress.push(p.message);
+        break;
+      }
+      case 'assistant_text': {
+        await ensureLiveComment();
+        turn.text += (turn.text ? '\n\n' : '') + p.text;
+        hasAssistantText = true;
+        schedulePatch();
+        break;
+      }
+      case 'stdout': {
+        // Legacy (non-ACP) runners emit stdout — route to live comment too.
+        if (p.line) {
+          await ensureLiveComment();
+          turn.text += (turn.text ? '\n' : '') + p.line;
+          hasAssistantText = true;
+          schedulePatch();
+        }
+        break;
+      }
+      case 'tool_call': {
+        await ensureLiveComment();
+        const id = p.id || `anon-${turn.toolOrder.length}`;
+        const existing = turn.tools.get(id);
+        if (existing) {
+          if (p.tool) existing.tool = p.tool;
+          if (p.kind) existing.kind = p.kind;
+          if (p.status) existing.status = p.status;
+          if (p.input !== undefined) existing.input = p.input;
+        } else {
+          turn.toolOrder.push(id);
+          turn.tools.set(id, { id, tool: p.tool || 'tool', kind: p.kind, status: p.status, input: p.input, results: [] });
+        }
+        schedulePatch();
+        break;
+      }
+      case 'tool_result': {
+        await ensureLiveComment();
+        const id = p.tool_use_id || turn.toolOrder[turn.toolOrder.length - 1];
+        const entry = id ? turn.tools.get(id) : undefined;
+        const content = String(p.content ?? '').trim();
+        if (entry && content) {
+          entry.results.push(content);
+          schedulePatch();
+        } else if (content) {
+          // orphan result — create a pseudo tool
+          const pid = `result-${turn.toolOrder.length}`;
+          turn.toolOrder.push(pid);
+          turn.tools.set(pid, { id: pid, tool: 'tool result', results: [content] });
+          schedulePatch();
+        }
+        break;
+      }
+      case 'result': {
+        await ensureLiveComment();
+        if (p.is_error) hadError = true;
+        if (!hasAssistantText && p.result) {
+          turn.text = p.result;
+          hasAssistantText = true;
+        }
+        turn.result = { duration_ms: p.duration_ms, total_cost_usd: p.total_cost_usd, stopReason: p.stopReason, is_error: p.is_error };
+        schedulePatch();
+        break;
+      }
+      case 'error': {
+        await ensureLiveComment();
+        turn.error = p.message || 'error';
+        schedulePatch();
+        break;
+      }
+    }
+  };
+
+  // Pick per-agent-type path: claude-code → ACP; pi/others → legacy stdout runner.
+  let preferType: string | undefined;
+  try {
+    const a = await apiClient.get<any>(`${apiUrl}/api/agents/${task.agent_id}`);
+    if (a.data?.type) preferType = a.data.type;
+  } catch {}
+  const acpCapable = detected.filter(d => d.type === 'claude-code');
+  const useAcp = preferType !== 'pi' && acpCapable.length > 0 && process.env.MULTI_LEGACY !== '1';
+
+  try {
+    if (useAcp) {
+      const base = `${task.title}\n\n${task.description || ''}`.trim();
+      let userPart = task.followup
+        ? `${task.followup}\n\n---\nContext (original task ${task.key}): ${task.title}`
+        : (base || task.title);
+      userPart = stripSelfMention(userPart, preferType);
+
+      // Pull agent + linked skills to construct system/context preamble
+      let preamble = '';
+      try {
+        const agentRes = await apiClient.get<any>(`${apiUrl}/api/agents/${task.agent_id}`);
+        const agent = agentRes.data;
+        if (agent?.prompt) preamble += `# Agent instructions\n\n${agent.prompt}\n\n`;
+
+        const skillsRes = await apiClient.get<any[]>(`${apiUrl}/api/agents/${task.agent_id}/skills`);
+        const skillList = Array.isArray(skillsRes.data) ? skillsRes.data : [];
+        if (skillList.length) {
+          preamble += `# Attached skills (${skillList.length})\n\n`;
+          for (const s of skillList) {
+            const body = String(s.body || s.description || '').trim();
+            if (!body) continue;
+            preamble += `## ${s.name}${s.version ? ` v${s.version}` : ''}\n\n${body}\n\n`;
+          }
+        }
+      } catch (e) {
+        log(`preamble fetch failed: ${String(e)}`);
+      }
+
+      const prompt = preamble ? `${preamble}\n---\n\n${userPart}` : userPart;
+
+      // Pick adapter for the agent's declared type if we have it, else first ACP-capable
+      let preferredType: string = 'claude-code';
+      try {
+        const a = await apiClient.get<any>(`${apiUrl}/api/agents/${task.agent_id}`);
+        if (a.data?.type) preferredType = a.data.type;
+      } catch {}
+      const chosen = acpCapable.find(d => d.type === preferredType) || acpCapable[0];
+      const adapterBin = await resolveAcpAdapter(chosen.type, chosen.path);
+      if (!adapterBin) throw new Error(`ACP adapter for ${chosen.type} not found`);
+      log(`  adapter: ${chosen.type} → ${adapterBin.join(' ')}`);
+
+      const { sessionId } = await runAcp({
+        apiUrl, issueId, deviceId, prompt,
+        sessionId: task.session_id || null,
+        adapterBin,
+        onEvent: eventHandler,
+        onSession: async (sid) => {
+          try { await apiClient.patch(`${apiUrl}/api/issues/${issueId}`, { session_id: sid } as any); } catch {}
+        },
+      });
+      log(`  acp session ${sessionId.slice(0, 8)}`);
+    } else {
+      // Determine preferred type from agent (e.g. pi)
+      let preferType: string | undefined;
+      try {
+        const a = await apiClient.get<any>(`${apiUrl}/api/agents/${task.agent_id}`);
+        if (a.data?.type) preferType = a.data.type;
+      } catch {}
+      const runner = pickRunner(detected, preferType);
+      for await (const event of runner(task)) await eventHandler(event);
+    }
+
+    if (hadError) { await apiClient.post(`${apiUrl}/api/issues/${issueId}/fail`, {}); log(`  ✗ ${task.key} failed`); }
+    else { await apiClient.post(`${apiUrl}/api/issues/${issueId}/complete`, {}); log(`  ✓ ${task.key} complete`); }
+  } catch (e) {
+    await postStream(apiUrl, issueId, 'error', { message: String(e) });
+    await postComment(`❌ spawn error: ${String(e)}`);
+    await apiClient.post(`${apiUrl}/api/issues/${issueId}/fail`, {});
+    log(`  ✗ ${task.key} failed: ${String(e)}`);
+  }
+}
+
+function stripMd(s: string): string {
+  return s.replace(/[`*_]/g, '').trim();
+}
+
+// Strip leading "@agent_name" so the agent CLI doesn't treat it as a file ref (pi)
+// or get confused by self-address. Universally safe across runners.
+function stripSelfMention(prompt: string, _agentType?: string): string {
+  return prompt.replace(/^@[A-Za-z0-9_\-]+\s*/, '').trim();
+}
+
+function statusIcon(status?: string): string {
+  switch (status) {
+    case 'pending': return '⏳';
+    case 'in_progress': return '🔧';
+    case 'completed': return '✓';
+    case 'failed': return '✗';
+    default: return '🔧';
+  }
+}
+
+async function resolveAcpAdapter(agentType: string, detectedPath?: string): Promise<string[] | null> {
+  // Native ACP agents (like `pi`) — invoke directly with ACP mode flag
+  if (agentType === 'pi' && detectedPath && existsSync(detectedPath)) {
+    return [detectedPath, '--mode', 'rpc'];
+  }
+
+  // claude-code → Zed adapter wrapper (stdio ACP)
+  const adapterName = 'claude-code-acp';
+  const candidates = [
+    join(HOME, '.bun', 'install', 'global', 'node_modules', '.bin', adapterName),
+  ];
+  try {
+    const here = new URL(import.meta.url).pathname;
+    let dir = here;
+    for (let i = 0; i < 8; i++) {
+      dir = dirname(dir);
+      const bin = join(dir, 'node_modules', '.bin', adapterName);
+      if (existsSync(bin)) return [bin];
+    }
+  } catch {}
+  for (const c of candidates) if (existsSync(c)) return [c];
+  return null;
+}
+
+async function postStream(apiUrl: string, issueId: string, event_type: string, payload: any) {
+  await apiClient.post(`${apiUrl}/api/streams/${issueId}`, { event_type, payload });
+}
+
+type StreamEvent = { event_type: 'progress' | 'stdout' | 'stderr' | 'tool_call' | 'done' | 'error'; payload: any };
+type Runner = (task: any) => AsyncGenerator<StreamEvent>;
+
+function pickRunner(detected: { type: string; path: string }[], preferType?: string): Runner {
+  const forceStub = process.env.MULTI_STUB === '1';
+  if (forceStub || !detected.length) return stubRunner;
+  const preferred = (preferType && detected.find(d => d.type === preferType)) || detected.find(d => d.type === 'claude-code') || detected[0];
+  return makeCliRunner(preferred);
+}
+
+async function* stubRunner(task: any): AsyncGenerator<StreamEvent> {
+  yield { event_type: 'stdout', payload: { line: `# ${task.key}: ${task.title}` } };
+  await sleep(600);
+  yield { event_type: 'stdout', payload: { line: 'Analyzing task...' } };
+  await sleep(800);
+  yield { event_type: 'progress', payload: { message: 'Generating solution' } };
+  await sleep(800);
+  yield { event_type: 'stdout', payload: { line: 'Solution ready.' } };
+  yield { event_type: 'done', payload: { code: 0 } };
+}
+
+function makeCliRunner(agent: { type: string; path: string }): Runner {
+  return async function* (task: any): AsyncGenerator<StreamEvent> {
+    const base = `${task.title}\n\n${task.description || ''}`.trim();
+    let prompt = task.followup
+      ? `${task.followup}\n\n---\nContext (original task ${task.key}): ${task.title}`
+      : (base || task.title);
+    prompt = stripSelfMention(prompt, agent.type);
+    const args = buildArgs(agent.type, prompt);
+    yield { event_type: 'progress', payload: { message: `spawning ${agent.type}`, cmd: `${agent.path} ${args.slice(0, 2).join(' ')} …` } };
+
+    let proc: ReturnType<typeof Bun.spawn>;
+    try {
+      proc = Bun.spawn([agent.path, ...args], { stdout: 'pipe', stderr: 'pipe', stdin: 'ignore' });
+    } catch (e) {
+      yield { event_type: 'error', payload: { message: `spawn failed: ${String(e)}` } };
+      return;
+    }
+
+    const queue: StreamEvent[] = [];
+    let stdoutDone = false, stderrDone = false;
+    let notify: (() => void) | null = null;
+    const pushWaiter = () => new Promise<void>((r) => { notify = r; });
+
+    const drainStderr = (stream: ReadableStream<Uint8Array>) => {
+      const reader = stream.getReader();
+      const dec = new TextDecoder();
+      let buf = '';
+      (async () => {
+        try {
+          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);
+              buf = buf.slice(nl + 1);
+              if (line.trim()) queue.push({ event_type: 'stderr', payload: { line } });
+              notify?.();
+            }
+          }
+          if (buf.trim()) { queue.push({ event_type: 'stderr', payload: { line: buf } }); notify?.(); }
+        } finally { stderrDone = true; notify?.(); }
+      })();
+    };
+
+    const drainStdout = (stream: ReadableStream<Uint8Array>) => {
+      const reader = stream.getReader();
+      const dec = new TextDecoder();
+      let buf = '';
+      (async () => {
+        try {
+          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); buf = buf.slice(nl + 1);
+              if (!line.trim()) continue;
+              if (agent.type === 'claude-code') {
+                const events = parseClaudeStreamJson(line);
+                for (const ev of events) queue.push(ev);
+              } else {
+                queue.push({ event_type: 'stdout', payload: { line } });
+              }
+              notify?.();
+            }
+          }
+          if (buf.trim()) {
+            if (agent.type === 'claude-code') {
+              for (const ev of parseClaudeStreamJson(buf)) queue.push(ev);
+            } else queue.push({ event_type: 'stdout', payload: { line: buf } });
+            notify?.();
+          }
+        } finally { stdoutDone = true; notify?.(); }
+      })();
+    };
+
+    drainStderr(proc.stderr as ReadableStream<Uint8Array>);
+    drainStdout(proc.stdout as ReadableStream<Uint8Array>);
+
+    while (!stdoutDone || !stderrDone || queue.length) {
+      if (queue.length) yield queue.shift()!;
+      else await pushWaiter();
+    }
+
+    const code = await proc.exited;
+    if (code === 0) yield { event_type: 'done', payload: { code } };
+    else yield { event_type: 'error', payload: { code, message: `exited with code ${code}` } };
+  };
+}
+
+function parseClaudeStreamJson(line: string): StreamEvent[] {
+  let msg: any;
+  try { msg = JSON.parse(line); } catch { return [{ event_type: 'stdout', payload: { line } }]; }
+  const out: StreamEvent[] = [];
+  const t = msg.type;
+  if (t === 'system') {
+    if (msg.subtype === 'init') {
+      out.push({ event_type: 'progress', payload: { message: `session ${msg.session_id?.slice(0, 8)} started`, model: msg.model } });
+    }
+    // skip hook chatter
+    return out;
+  }
+  if (t === 'assistant') {
+    const content = msg.message?.content || [];
+    for (const c of content) {
+      if (c.type === 'text' && c.text) {
+        out.push({ event_type: 'assistant_text', payload: { text: c.text } });
+      } else if (c.type === 'tool_use') {
+        out.push({ event_type: 'tool_call', payload: { tool: c.name, input: c.input, id: c.id } });
+      }
+    }
+    return out;
+  }
+  if (t === 'user') {
+    const content = msg.message?.content || [];
+    for (const c of content) {
+      if (c.type === 'tool_result') {
+        const preview = typeof c.content === 'string' ? c.content : JSON.stringify(c.content);
+        out.push({ event_type: 'tool_result', payload: { tool_use_id: c.tool_use_id, content: preview.slice(0, 2000), truncated: preview.length > 2000 } });
+      }
+    }
+    return out;
+  }
+  if (t === 'result') {
+    out.push({ event_type: 'result', payload: {
+      result: msg.result, duration_ms: msg.duration_ms,
+      num_turns: msg.num_turns, total_cost_usd: msg.total_cost_usd,
+      usage: msg.usage, is_error: !!msg.is_error,
+    }});
+    return out;
+  }
+  return out;
+}
+
+function buildArgs(type: string, prompt: string): string[] {
+  switch (type) {
+    case 'claude-code':
+      return ['-p', prompt, '--output-format', 'stream-json', '--verbose'];
+    case 'pi':
+      // pi: non-interactive, plain text mode, no session saved
+      return ['-p', '--mode', 'text', '--no-session', prompt];
+    case 'codex':
+      return ['-q', prompt];
+    case 'opencode':
+      return ['run', prompt];
+    case 'gemini-cli':
+      return ['-p', prompt];
+    default:
+      return [prompt];
+  }
+}
+
+async function cmdStatus(apiUrl: string, config: Config) {
+  if (!config.deviceId) {
+    console.log('❌ Not registered.');
+    process.exit(1);
+  }
+  const res = await apiClient.get<any>(`${apiUrl}/api/devices/${config.deviceId}`);
+  if (!res.success) { console.log('❌', res.error); process.exit(1); }
+  const d = res.data;
+  const pid = existsSync(PID_PATH) ? readFileSync(PID_PATH, 'utf8').trim() : null;
+  const daemon = pid && isRunning(Number(pid)) ? `running (pid ${pid})` : 'stopped';
+  console.log(`
+Device Status
+=============
+ID:        ${d.id}
+Name:      ${d.name}
+Platform:  ${d.platform} ${d.arch}
+Runtimes:  ${JSON.parse(d.detected_runtimes || '[]').join(', ') || 'none'}
+Status:    ${d.status}
+Daemon:    ${daemon}
+`);
+}
+
+async function cmdStop() {
+  if (!existsSync(PID_PATH)) { console.log('No daemon running.'); return; }
+  const pid = Number(readFileSync(PID_PATH, 'utf8').trim());
+  if (!pid || !isRunning(pid)) {
+    unlinkSync(PID_PATH);
+    console.log('Cleaned stale pidfile.');
+    return;
+  }
+  ensureDirs();
+  writeFileSync(STOP_PATH, '1');
+  try { process.kill(pid, 'SIGTERM'); console.log(`Sent SIGTERM to ${pid}`); } catch {}
+}
+
+async function cmdLogs() {
+  if (!existsSync(LOG_PATH)) { console.log('No logs yet.'); return; }
+  const content = readFileSync(LOG_PATH, 'utf8');
+  console.log(content.split('\n').slice(-100).join('\n'));
+}
+
+function isRunning(pid: number): boolean {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+interface Config {
+  deviceId?: string;
+  workspaceId?: string;
+  apiUrl?: string;
+  // legacy
+  agentId?: string;
+}
+
+function loadConfig(): Config {
+  try {
+    if (!existsSync(CONFIG_PATH)) return {};
+    return JSON.parse(readFileSync(CONFIG_PATH, 'utf8'));
+  } catch { return {}; }
+}
+
+function saveConfig(config: Config) {
+  ensureDirs();
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+
+function sleep(ms: number) { return new Promise(r => setTimeout(r, ms)); }
+
+main().catch((err) => {
+  log(`Fatal: ${String(err)}`);
+  process.exit(1);
+});