@beevibe/daemon 0.1.2 → 0.1.3

package/dist/main.js

@@ -2,7 +2,6 @@
 
 // src/setup.ts
 import { hostname, userInfo } from "node:os";
-import { spawnSync } from "node:child_process";
 
 // ../../node_modules/.pnpm/nanoid@5.1.9/node_modules/nanoid/index.js
 import { webcrypto as crypto } from "node:crypto";
@@ -224,6 +223,29 @@ function saveConfig(cfg) {
 `, { mode: 384 });
 }
 
+// src/detect-clis.ts
+import { execFile } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+var execFileAsync = promisify2(execFile);
+async function probeOne(cli) {
+  try {
+    await execFileAsync("which", [cli]);
+  } catch {
+    return null;
+  }
+  let cli_version;
+  try {
+    const { stdout } = await execFileAsync(cli, ["--version"]);
+    cli_version = stdout.trim().split(`
+`)[0];
+  } catch {}
+  return { cli, cli_version };
+}
+async function detectClis() {
+  const results = await Promise.all(KNOWN_CLIS.map((cli) => probeOne(cli)));
+  return results.filter((r) => r !== null);
+}
+
 // src/setup.ts
 async function runSetup(options) {
   if (!/^https?:\/\//.test(options.apiUrl)) {
@@ -234,7 +256,7 @@ async function runSetup(options) {
   }
   const externalId = options.externalId ?? hostname();
   const deviceName = options.deviceName ?? `${userInfo().username}@${hostname()}`;
-  const runtimes = options.detectedClis ?? detectClis();
+  const runtimes = options.detectedClis ?? await detectClis();
   if (runtimes.length === 0) {
     throw new Error(`No supported CLIs detected on PATH. beevibe currently looks for: ${KNOWN_CLIS.join(", ")}`);
   }
@@ -264,21 +286,6 @@ async function runSetup(options) {
   saveConfig(config);
   return config;
 }
-function detectClis() {
-  const out = [];
-  for (const cli of KNOWN_CLIS) {
-    const which = spawnSync("which", [cli], { encoding: "utf8" });
-    if (which.status !== 0 || !which.stdout.trim())
-      continue;
-    const version = spawnSync(cli, ["--version"], { encoding: "utf8" });
-    out.push({
-      cli,
-      cli_version: version.status === 0 ? version.stdout.trim().split(`
-`)[0] : undefined
-    });
-  }
-  return out;
-}
 
 // ../core/dist/adapters/local-workspace/manager.js
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
@@ -436,6 +443,16 @@ class LocalWorkspaceManager {
     if (!runtime3) {
       throw new Error(`No runtime registered for agent ${agent2.id} (runtime_config.type='${agent2.runtime_config.type}')`);
     }
+    if (runtime3.prepareWorkspace) {
+      if (!agent2.api_key) {
+        throw new Error(`Cannot prepare workspace for agent ${agent2.id}: agent.api_key is missing`);
+      }
+      await runtime3.prepareWorkspace({
+        workspace: workspace2,
+        agentApiKey: agent2.api_key,
+        mcpServerUrl: this.config.mcpServerUrl
+      });
+    }
     await syncSkills({
       sourceDir: this.config.skillsSourceDir,
       targetDir: runtime3.skillsDir(workspace2),
@@ -648,6 +665,15 @@ function extractStepEvents(msg) {
       }
     ];
   }
+  if (msg.type === STREAM_TYPE.ToolResult) {
+    return [
+      {
+        kind: "tool_result",
+        description: describeToolResult(msg.content, msg.is_error === true),
+        timestamp: now
+      }
+    ];
+  }
   if (msg.type === STREAM_TYPE.ContentBlockStart && msg.content_block?.type === BLOCK_TYPE.ToolUse) {
     const block = msg.content_block;
     return [
@@ -681,6 +707,11 @@ function extractStepEvents(msg) {
   }
   return [];
 }
+function describeToolResult(content, isError) {
+  const text = typeof content === "string" ? content : JSON.stringify(content ?? "");
+  const collapsed = text.replace(/\s+/g, " ").trim();
+  return isError ? `[error] ${collapsed}` : collapsed;
+}
 var PREFERRED_INPUT_FIELDS = [
   "file_path",
   "command",
@@ -845,6 +876,9 @@ class ClaudeCodeRuntime {
       args.push("--max-turns", String(maxTurns));
     if (context.resume_session_id)
       args.push("--resume", context.resume_session_id);
+    if (context.disallowed_tools?.length) {
+      args.push("--disallowedTools", context.disallowed_tools.join(","));
+    }
     if (context.system_prompt_append.length > 0) {
       args.push("--append-system-prompt", context.system_prompt_append);
     }
@@ -937,10 +971,705 @@ class ClaudeCodeRuntime {
   }
 }
 
+// ../core/dist/adapters/codex/runtime.js
+import { existsSync as existsSync3, readFileSync as readFileSync3, unlinkSync } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join4 } from "node:path";
+
+// ../core/dist/adapters/codex/stream-json.js
+var CODEX_EVENT_TYPE = {
+  ThreadStarted: "thread.started",
+  TurnStarted: "turn.started",
+  TurnCompleted: "turn.completed",
+  TurnFailed: "turn.failed",
+  ItemStarted: "item.started",
+  ItemUpdated: "item.updated",
+  ItemCompleted: "item.completed",
+  Error: "error"
+};
+var CODEX_ITEM_TYPE = {
+  AgentMessage: "agent_message",
+  Reasoning: "reasoning",
+  CommandExecution: "command_execution",
+  FileChange: "file_change",
+  McpToolCall: "mcp_tool_call",
+  CollabToolCall: "collab_tool_call",
+  WebSearch: "web_search",
+  TodoList: "todo_list",
+  Error: "error"
+};
+function parseCodexEventLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed || !trimmed.startsWith("{"))
+    return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+}
+function extractCodexStepEvents(evt) {
+  const now = new Date().toISOString();
+  if (evt.type !== CODEX_EVENT_TYPE.ItemStarted && evt.type !== CODEX_EVENT_TYPE.ItemCompleted) {
+    return [];
+  }
+  const item = evt.item;
+  if (!item || !item.type)
+    return [];
+  const isCompletion = evt.type === CODEX_EVENT_TYPE.ItemCompleted;
+  if (item.type === CODEX_ITEM_TYPE.AgentMessage) {
+    if (!isCompletion)
+      return [];
+    const text = item.text?.trim();
+    if (!text)
+      return [];
+    return [{ kind: "agent", description: text, timestamp: now }];
+  }
+  if (item.type === CODEX_ITEM_TYPE.McpToolCall) {
+    return [
+      {
+        kind: isCompletion ? "tool_result" : "tool_call",
+        tool: item.tool ?? "unknown",
+        description: describeCodexInput(item.arguments),
+        timestamp: now
+      }
+    ];
+  }
+  if (item.type === CODEX_ITEM_TYPE.CommandExecution) {
+    return [
+      {
+        kind: isCompletion ? "tool_result" : "tool_call",
+        tool: "shell",
+        description: (item.command ?? "").slice(0, 200),
+        timestamp: now
+      }
+    ];
+  }
+  if (item.type === CODEX_ITEM_TYPE.FileChange) {
+    const summary = (item.changes ?? []).map((c) => `${c.kind ?? "?"} ${c.path ?? ""}`).join(", ").slice(0, 200);
+    return [
+      {
+        kind: isCompletion ? "tool_result" : "tool_call",
+        tool: "file_change",
+        description: summary,
+        timestamp: now
+      }
+    ];
+  }
+  if (item.type === CODEX_ITEM_TYPE.WebSearch) {
+    return [
+      {
+        kind: isCompletion ? "tool_result" : "tool_call",
+        tool: "web_search",
+        description: (item.query ?? "").slice(0, 200),
+        timestamp: now
+      }
+    ];
+  }
+  return [];
+}
+var PREFERRED_CODEX_FIELDS = [
+  "file_path",
+  "path",
+  "command",
+  "cmd",
+  "query",
+  "pattern",
+  "url",
+  "intent"
+];
+function describeCodexInput(input) {
+  if (typeof input === "string")
+    return input.slice(0, 200);
+  if (!input || typeof input !== "object" || Array.isArray(input))
+    return "";
+  const obj = input;
+  for (const key of PREFERRED_CODEX_FIELDS) {
+    const v = obj[key];
+    if (typeof v === "string" && v.length > 0)
+      return v.slice(0, 200);
+  }
+  return JSON.stringify(input).slice(0, 200);
+}
+function parseCodexEvents(events, exitCode, lastMessage) {
+  let threadId;
+  let usage;
+  let assistantText = "";
+  let turnFailed;
+  let topLevelError;
+  const transcriptParts = [];
+  for (const evt of events) {
+    switch (evt.type) {
+      case CODEX_EVENT_TYPE.ThreadStarted:
+        if (evt.thread_id)
+          threadId = evt.thread_id;
+        break;
+      case CODEX_EVENT_TYPE.TurnCompleted:
+        if (evt.usage)
+          usage = evt.usage;
+        break;
+      case CODEX_EVENT_TYPE.TurnFailed:
+        turnFailed = evt.error?.message ?? turnFailed;
+        break;
+      case CODEX_EVENT_TYPE.Error:
+        topLevelError = evt.message ?? topLevelError;
+        if (evt.message)
+          transcriptParts.push(`[error] ${evt.message}
+`);
+        break;
+      case CODEX_EVENT_TYPE.ItemCompleted: {
+        const item = evt.item;
+        if (!item || !item.type)
+          break;
+        if (item.type === CODEX_ITEM_TYPE.AgentMessage && item.text) {
+          assistantText = item.text;
+          transcriptParts.push(`[assistant] ${item.text}
+`);
+        } else if (item.type === CODEX_ITEM_TYPE.McpToolCall) {
+          const tool = item.tool ?? "unknown";
+          transcriptParts.push(`[tool_call] ${tool}
+`);
+          const resultSummary = summarizeMcpResult(item.result);
+          if (resultSummary || item.error?.message) {
+            transcriptParts.push(`[tool_result from ${tool}] ${item.error?.message ?? resultSummary}
+`);
+          }
+        } else if (item.type === CODEX_ITEM_TYPE.CommandExecution) {
+          transcriptParts.push(`[tool_call] shell ${(item.command ?? "").slice(0, 200)}
+`);
+          if (item.aggregated_output) {
+            transcriptParts.push(`[tool_result from shell] ${item.aggregated_output.slice(0, 200).replace(/\n/g, " ")}
+`);
+          }
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  const failed = exitCode !== 0 || !!turnFailed || !!topLevelError;
+  const trimmedLast = lastMessage.trim();
+  const failureMessage = turnFailed ?? topLevelError;
+  const output = failed ? failureMessage || assistantText || bareCliExitMessage(exitCode) : trimmedLast || assistantText || "Session completed.";
+  return {
+    status: failed ? "failed" : "completed",
+    output,
+    transcript: transcriptParts.join("") || undefined,
+    cli_session_id: threadId,
+    usage: usage ? {
+      input_tokens: usage.input_tokens ?? 0,
+      output_tokens: (usage.output_tokens ?? 0) + (usage.reasoning_output_tokens ?? 0),
+      cache_creation_input_tokens: 0,
+      cache_read_input_tokens: usage.cached_input_tokens ?? 0
+    } : undefined
+  };
+}
+function summarizeMcpResult(result) {
+  if (!result || !Array.isArray(result.content))
+    return "";
+  for (const block of result.content) {
+    if (block && typeof block === "object" && block.type === "text") {
+      const text = block.text;
+      if (typeof text === "string")
+        return text.slice(0, 200).replace(/\n/g, " ");
+    }
+  }
+  return JSON.stringify(result.content).slice(0, 200);
+}
+
+// ../core/dist/adapters/codex/runtime.js
+var OPENAI_AUTH_VARS = ["OPENAI_API_KEY", "OPENAI_AUTH_TOKEN"];
+
+class CodexRuntime {
+  config;
+  type = "codex";
+  prepared = new Map;
+  constructor(config = {}) {
+    this.config = config;
+  }
+  async execute(context) {
+    const prepared = this.prepared.get(context.workspace.path);
+    const sid = context.env?.BEEVIBE_SESSION_ID;
+    const lastMessagePath = join4(context.workspace.path, `.beevibe-codex-last-message-${Date.now()}.txt`);
+    const globalArgs = buildGlobalArgs(context, this.config);
+    const execArgs = [
+      "--json",
+      "--skip-git-repo-check",
+      "--output-last-message",
+      lastMessagePath
+    ];
+    if (prepared && sid) {
+      globalArgs.push("-c", `mcp_servers.beevibe.url=${tomlString(withBeevibeSession(prepared.mcpServerUrl, sid))}`, "-c", `mcp_servers.beevibe.bearer_token_env_var=${tomlString("BEEVIBE_AGENT_API_KEY")}`, "-c", `mcp_servers.beevibe.default_tools_approval_mode=${tomlString("approve")}`);
+    }
+    const args = context.resume_session_id ? [
+      ...globalArgs,
+      "exec",
+      "resume",
+      ...execArgs,
+      context.resume_session_id,
+      composePrompt(context)
+    ] : [...globalArgs, "exec", ...execArgs, composePrompt(context)];
+    const env2 = { ...process.env };
+    for (const key of OPENAI_AUTH_VARS)
+      delete env2[key];
+    if (context.env)
+      Object.assign(env2, context.env);
+    if (prepared)
+      env2.BEEVIBE_AGENT_API_KEY = prepared.agentApiKey;
+    const events = [];
+    let pending = "";
+    const handleLine = (line) => {
+      const evt = parseCodexEventLine(line);
+      if (!evt)
+        return;
+      events.push(evt);
+      if (!context.onStep)
+        return;
+      for (const step of extractCodexStepEvents(evt)) {
+        context.onStep(step);
+      }
+    };
+    const result = await runCliProcess({
+      command: this.config.command ?? "codex",
+      args,
+      cwd: context.workspace.path,
+      env: env2,
+      abortSignal: context.abort_signal,
+      onSpawn: ({ pid, process_group_id }) => {
+        context.onSpawn?.({ process_pid: pid, process_group_id });
+      },
+      onLog: (stream, chunk) => {
+        if (stream !== "stdout")
+          return;
+        pending += chunk;
+        let nl;
+        while ((nl = pending.indexOf(`
+`)) !== -1) {
+          handleLine(pending.slice(0, nl));
+          pending = pending.slice(nl + 1);
+        }
+      }
+    });
+    if (pending)
+      handleLine(pending);
+    if (result.truncated) {
+      console.warn("[CodexRuntime] stdout truncated at 4MB — result parsing may be incomplete");
+    }
+    if (result.aborted) {
+      removeIfExists(lastMessagePath);
+      return {
+        status: "cancelled",
+        output: "Session cancelled.",
+        process_pid: result.pid ?? undefined,
+        process_group_id: result.process_group_id ?? undefined
+      };
+    }
+    const lastMessage = readIfExists(lastMessagePath);
+    removeIfExists(lastMessagePath);
+    const parsed = parseCodexEvents(events, result.exitCode, lastMessage);
+    const STDERR_TAIL_BYTES = 4096;
+    const stderrTail = parsed.status === "failed" && result.stderr ? result.stderr.slice(-STDERR_TAIL_BYTES) : undefined;
+    return {
+      ...parsed,
+      process_pid: result.pid ?? undefined,
+      process_group_id: result.process_group_id ?? undefined,
+      exit_code: result.exitCode,
+      ...stderrTail ? { stderr: stderrTail } : {}
+    };
+  }
+  async healthCheck() {
+    try {
+      const result = await runCliProcess({
+        command: this.config.command ?? "codex",
+        args: ["--version"],
+        cwd: tmpdir2(),
+        timeoutMs: 5000,
+        graceMs: 0
+      });
+      return {
+        healthy: result.exitCode === 0,
+        error: result.exitCode === 0 ? undefined : result.stderr.slice(-500)
+      };
+    } catch {
+      return {
+        healthy: false,
+        error: `Command not found: ${this.config.command ?? "codex"}`
+      };
+    }
+  }
+  async shutdown() {}
+  skillsDir(workspace2) {
+    return join4(workspace2.path, ".codex", "skills");
+  }
+  prepareWorkspace(context) {
+    this.prepared.set(context.workspace.path, {
+      agentApiKey: context.agentApiKey,
+      mcpServerUrl: context.mcpServerUrl
+    });
+  }
+}
+function buildGlobalArgs(context, config) {
+  const args = [
+    "--sandbox",
+    "workspace-write",
+    "--ask-for-approval",
+    "never",
+    "--cd",
+    context.workspace.path
+  ];
+  const model = context.model ?? config.model;
+  if (model)
+    args.push("--model", model);
+  return args;
+}
+function composePrompt(context) {
+  if (context.system_prompt_append.length === 0)
+    return context.intent;
+  return [
+    "<beevibe_system_context>",
+    context.system_prompt_append,
+    "</beevibe_system_context>",
+    "",
+    context.intent
+  ].join(`
+`);
+}
+function withBeevibeSession(mcpServerUrl, sid) {
+  const url = new URL(mcpServerUrl);
+  url.searchParams.set("beevibe_session", sid);
+  return url.toString();
+}
+function tomlString(value) {
+  return JSON.stringify(value);
+}
+function readIfExists(path2) {
+  try {
+    return existsSync3(path2) ? readFileSync3(path2, "utf8") : "";
+  } catch {
+    return "";
+  }
+}
+function removeIfExists(path2) {
+  try {
+    if (existsSync3(path2))
+      unlinkSync(path2);
+  } catch {}
+}
+
+// ../core/dist/adapters/opencode/runtime.js
+import { existsSync as existsSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { tmpdir as tmpdir3 } from "node:os";
+import { join as join5 } from "node:path";
+
+// ../core/dist/adapters/opencode/stream-json.js
+var OPENCODE_EVENT_TYPE = {
+  Text: "text",
+  Reasoning: "reasoning",
+  ToolUse: "tool_use",
+  StepStart: "step_start",
+  StepFinish: "step_finish",
+  Error: "error"
+};
+var OPENCODE_TOOL_STATUS = {
+  Pending: "pending",
+  Running: "running",
+  Completed: "completed",
+  Error: "error"
+};
+function parseOpenCodeEventLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed || !trimmed.startsWith("{"))
+    return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+}
+function extractOpenCodeStepEvents(evt) {
+  const now = new Date().toISOString();
+  if (evt.type === OPENCODE_EVENT_TYPE.Text) {
+    const text = evt.part?.text?.trim();
+    if (!text)
+      return [];
+    return [{ kind: "agent", description: text, timestamp: now }];
+  }
+  if (evt.type === OPENCODE_EVENT_TYPE.ToolUse) {
+    const part = evt.part;
+    if (!part)
+      return [];
+    const status = part.state?.status;
+    const isTerminal = status === OPENCODE_TOOL_STATUS.Completed || status === OPENCODE_TOOL_STATUS.Error;
+    return [
+      {
+        kind: isTerminal ? "tool_result" : "tool_call",
+        tool: part.tool ?? "unknown",
+        description: describeOpenCodeInput(part.state?.input),
+        timestamp: now
+      }
+    ];
+  }
+  return [];
+}
+var PREFERRED_OPENCODE_FIELDS = [
+  "file_path",
+  "path",
+  "command",
+  "cmd",
+  "query",
+  "pattern",
+  "url",
+  "intent"
+];
+function describeOpenCodeInput(input) {
+  if (typeof input === "string")
+    return input.slice(0, 200);
+  if (!input || typeof input !== "object" || Array.isArray(input))
+    return "";
+  const obj = input;
+  for (const key of PREFERRED_OPENCODE_FIELDS) {
+    const v = obj[key];
+    if (typeof v === "string" && v.length > 0)
+      return v.slice(0, 200);
+  }
+  return JSON.stringify(input).slice(0, 200);
+}
+function parseOpenCodeEvents(events, exitCode) {
+  let sessionId;
+  let sawUsage = false;
+  let totalInput = 0;
+  let totalOutput = 0;
+  let totalReasoning = 0;
+  let totalCacheRead = 0;
+  let totalCacheWrite = 0;
+  let totalCost = 0;
+  const assistantTexts = [];
+  const transcriptParts = [];
+  let errorMessage;
+  for (const evt of events) {
+    if (evt.sessionID)
+      sessionId = evt.sessionID;
+    switch (evt.type) {
+      case OPENCODE_EVENT_TYPE.StepFinish: {
+        const part = evt.part;
+        if (!part)
+          break;
+        sawUsage = true;
+        totalCost += part.cost ?? 0;
+        totalInput += part.tokens?.input ?? 0;
+        totalOutput += part.tokens?.output ?? 0;
+        totalReasoning += part.tokens?.reasoning ?? 0;
+        totalCacheRead += part.tokens?.cache?.read ?? 0;
+        totalCacheWrite += part.tokens?.cache?.write ?? 0;
+        break;
+      }
+      case OPENCODE_EVENT_TYPE.Text: {
+        const text = evt.part?.text;
+        if (text) {
+          assistantTexts.push(text);
+          transcriptParts.push(`[assistant] ${text}
+`);
+        }
+        break;
+      }
+      case OPENCODE_EVENT_TYPE.ToolUse: {
+        const part = evt.part;
+        if (!part)
+          break;
+        const tool = part.tool ?? "unknown";
+        const status = part.state?.status;
+        if (status === OPENCODE_TOOL_STATUS.Completed || status === OPENCODE_TOOL_STATUS.Error) {
+          const detail = (part.state?.error ?? part.state?.output ?? "").slice(0, 200).replace(/\n/g, " ");
+          transcriptParts.push(detail ? `[tool_result from ${tool}] ${detail}
+` : `[tool_result from ${tool}]
+`);
+        } else {
+          transcriptParts.push(`[tool_call] ${tool}
+`);
+        }
+        break;
+      }
+      case OPENCODE_EVENT_TYPE.Error:
+        errorMessage = evt.error?.message ?? evt.result?.error?.message ?? errorMessage;
+        if (errorMessage)
+          transcriptParts.push(`[error] ${errorMessage}
+`);
+        break;
+      default:
+        break;
+    }
+  }
+  const assistantText = assistantTexts.join(`
+`).trim();
+  const failed = exitCode !== 0 || !!errorMessage;
+  const output = failed ? errorMessage || assistantText || bareCliExitMessage(exitCode) : assistantText || "Session completed.";
+  const usage = sawUsage ? {
+    input_tokens: totalInput,
+    output_tokens: totalOutput + totalReasoning,
+    cache_creation_input_tokens: totalCacheWrite,
+    cache_read_input_tokens: totalCacheRead,
+    cost_usd: totalCost
+  } : undefined;
+  return {
+    status: failed ? "failed" : "completed",
+    output,
+    transcript: transcriptParts.join("") || undefined,
+    cli_session_id: sessionId,
+    usage
+  };
+}
+
+// ../core/dist/adapters/opencode/runtime.js
+class OpenCodeRuntime {
+  config;
+  type = "opencode";
+  constructor(config = {}) {
+    this.config = config;
+  }
+  async execute(context) {
+    const args = [
+      "run",
+      "--format",
+      "json",
+      "--dangerously-skip-permissions",
+      "--dir",
+      context.workspace.path
+    ];
+    const model = context.model ?? this.config.model;
+    if (model)
+      args.push("--model", model);
+    if (context.resume_session_id)
+      args.push("--session", context.resume_session_id);
+    args.push(composePrompt2(context));
+    const env2 = { ...process.env };
+    if (context.env)
+      Object.assign(env2, context.env);
+    const events = [];
+    let pending = "";
+    const handleLine = (line) => {
+      const evt = parseOpenCodeEventLine(line);
+      if (!evt)
+        return;
+      events.push(evt);
+      if (!context.onStep)
+        return;
+      for (const step of extractOpenCodeStepEvents(evt)) {
+        context.onStep(step);
+      }
+    };
+    const result = await runCliProcess({
+      command: this.config.command ?? "opencode",
+      args,
+      cwd: context.workspace.path,
+      env: env2,
+      abortSignal: context.abort_signal,
+      onSpawn: ({ pid, process_group_id }) => {
+        context.onSpawn?.({ process_pid: pid, process_group_id });
+      },
+      onLog: (stream, chunk) => {
+        if (stream !== "stdout")
+          return;
+        pending += chunk;
+        let nl;
+        while ((nl = pending.indexOf(`
+`)) !== -1) {
+          handleLine(pending.slice(0, nl));
+          pending = pending.slice(nl + 1);
+        }
+      }
+    });
+    if (pending)
+      handleLine(pending);
+    if (result.truncated) {
+      console.warn("[OpenCodeRuntime] stdout truncated at 4MB — result parsing may be incomplete");
+    }
+    if (result.aborted) {
+      return {
+        status: "cancelled",
+        output: "Session cancelled.",
+        process_pid: result.pid ?? undefined,
+        process_group_id: result.process_group_id ?? undefined
+      };
+    }
+    const parsed = parseOpenCodeEvents(events, result.exitCode);
+    const STDERR_TAIL_BYTES = 4096;
+    const stderrTail = parsed.status === "failed" && result.stderr ? result.stderr.slice(-STDERR_TAIL_BYTES) : undefined;
+    return {
+      ...parsed,
+      process_pid: result.pid ?? undefined,
+      process_group_id: result.process_group_id ?? undefined,
+      exit_code: result.exitCode,
+      ...stderrTail ? { stderr: stderrTail } : {}
+    };
+  }
+  async healthCheck() {
+    try {
+      const result = await runCliProcess({
+        command: this.config.command ?? "opencode",
+        args: ["--version"],
+        cwd: tmpdir3(),
+        timeoutMs: 5000,
+        graceMs: 0
+      });
+      return { healthy: result.exitCode === 0 };
+    } catch {
+      return {
+        healthy: false,
+        error: `Command not found: ${this.config.command ?? "opencode"}`
+      };
+    }
+  }
+  async shutdown() {}
+  skillsDir(workspace2) {
+    return join5(workspace2.path, ".opencode", "skills");
+  }
+  prepareWorkspace(context) {
+    const configPath = join5(context.workspace.path, "opencode.json");
+    if (existsSync4(configPath))
+      return;
+    writeFileSync3(configPath, buildOpenCodeConfig(context.agentApiKey, context.mcpServerUrl), {
+      mode: 384
+    });
+  }
+}
+function composePrompt2(context) {
+  if (context.system_prompt_append.length === 0)
+    return context.intent;
+  return [
+    "<beevibe_system_context>",
+    context.system_prompt_append,
+    "</beevibe_system_context>",
+    "",
+    context.intent
+  ].join(`
+`);
+}
+function buildOpenCodeConfig(apiKey, mcpServerUrl) {
+  return JSON.stringify({
+    $schema: "https://opencode.ai/config.json",
+    mcp: {
+      beevibe: {
+        type: "remote",
+        url: mcpServerUrl,
+        enabled: true,
+        oauth: false,
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "X-Beevibe-Session": "{env:BEEVIBE_SESSION_ID}"
+        }
+      }
+    }
+  }, null, 2) + `
+`;
+}
+
 // ../core/dist/adapters/runtime-registry.js
 function createDefaultRuntimeRegistry() {
   return {
-    claude: new ClaudeCodeRuntime({})
+    claude: new ClaudeCodeRuntime({}),
+    codex: new CodexRuntime({}),
+    opencode: new OpenCodeRuntime({})
   };
 }
 
@@ -1002,17 +1731,22 @@ class ApiClient {
     return `${this.cfg.apiUrl}${path2}`;
   }
 }
+
 // src/spawner.ts
 async function runDispatch(deps, payload, abortSignal) {
   const syntheticAgent = {
     id: payload.agent_id,
     api_key: payload.agent_api_key,
     hierarchy_level: payload.agent_hierarchy_level,
-    runtime_config: { type: "claude" }
+    runtime_config: { type: payload.runtime_type }
   };
   const ws = await deps.workspaceManager.ensureWorkspace({ agent: syntheticAgent });
-  console.log(`[daemon/spawn] sess=${payload.session_id} agent=${payload.agent_id} type=${payload.type} cwd=${ws.path}`);
-  const runtime3 = deps.runtime ?? new ClaudeCodeRuntime;
+  console.log(`[daemon/spawn] sess=${payload.session_id} agent=${payload.agent_id} runtime=${payload.runtime_type} type=${payload.type} cwd=${ws.path}`);
+  const registry = deps.runtimeRegistry ?? createDefaultRuntimeRegistry();
+  const runtime3 = registry[payload.runtime_type];
+  if (!runtime3) {
+    throw new Error(`No runtime registered for dispatch payload type '${payload.runtime_type}'`);
+  }
   const buffer = [];
   let flushTimer;
   const flush = async () => {
@@ -1054,6 +1788,7 @@ async function runDispatch(deps, payload, abortSignal) {
       system_prompt_append: payload.system_prompt_append,
       model: payload.model,
       max_turns: payload.max_turns,
+      disallowed_tools: payload.disallowed_tools,
       env: payload.env,
       resume_session_id: payload.resume_session_id,
       abort_signal: abortSignal,
@@ -1206,12 +1941,22 @@ class Claimer {
   }
   async pollRuntime(runtimeId) {
     while (this.running && this.cfg.supervisor.hasCapacity()) {
-      const payload = await this.cfg.api.claim(runtimeId);
+      let payload;
+      try {
+        payload = await this.cfg.api.claim(runtimeId);
+      } catch (err) {
+        console.warn(`[daemon] claim failed for runtime=${runtimeId}:`, err instanceof Error ? err.message : String(err));
+        return;
+      }
       if (!payload)
         return;
       console.log(`[daemon/claim] sess=${payload.session_id} agent=${payload.agent_id} runtime=${runtimeId}`);
       const ctrl = this.cfg.supervisor.start(payload.session_id);
-      runDispatch({ api: this.cfg.api, workspaceManager: this.cfg.workspaceManager }, payload, ctrl.signal).catch((err) => console.error(`[daemon] dispatch ${payload.session_id} failed:`, err instanceof Error ? err.message : String(err))).finally(() => this.cfg.supervisor.finish(payload.session_id));
+      runDispatch({
+        api: this.cfg.api,
+        workspaceManager: this.cfg.workspaceManager,
+        runtimeRegistry: this.cfg.runtimeRegistry
+      }, payload, ctrl.signal).catch((err) => console.error(`[daemon] dispatch ${payload.session_id} failed:`, err instanceof Error ? err.message : String(err))).finally(() => this.cfg.supervisor.finish(payload.session_id));
     }
   }
 }
@@ -1219,14 +1964,14 @@ class Claimer {
 // src/skills-cache.ts
 import { promises as fs2 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join4 } from "node:path";
+import { join as join6 } from "node:path";
 function skillsCacheDir() {
-  return join4(homedir3(), ".beevibe", "skills");
+  return join6(homedir3(), ".beevibe", "skills");
 }
 var VERSION_FILE = ".version";
 async function readCachedVersion() {
   try {
-    return (await fs2.readFile(join4(skillsCacheDir(), VERSION_FILE), "utf8")).trim();
+    return (await fs2.readFile(join6(skillsCacheDir(), VERSION_FILE), "utf8")).trim();
   } catch {
     return;
   }
@@ -1247,19 +1992,19 @@ async function syncSkillsCache(api) {
     if (!dirent.isDirectory())
       continue;
     if (dirent.name === "beevibe" || dirent.name.startsWith("beevibe-")) {
-      await fs2.rm(join4(cache, dirent.name), { recursive: true, force: true });
+      await fs2.rm(join6(cache, dirent.name), { recursive: true, force: true });
     }
   }
   for (const skill of res.skills) {
-    const skillDir = join4(cache, skill.name);
+    const skillDir = join6(cache, skill.name);
     await fs2.mkdir(skillDir, { recursive: true, mode: 448 });
     for (const file of skill.files) {
-      const filePath = join4(skillDir, file.path);
-      await fs2.mkdir(join4(filePath, ".."), { recursive: true });
+      const filePath = join6(skillDir, file.path);
+      await fs2.mkdir(join6(filePath, ".."), { recursive: true });
       await fs2.writeFile(filePath, file.content, { mode: 384 });
     }
   }
-  await fs2.writeFile(join4(cache, VERSION_FILE), res.version, { mode: 384 });
+  await fs2.writeFile(join6(cache, VERSION_FILE), res.version, { mode: 384 });
   return cache;
 }
 
@@ -1338,6 +2083,7 @@ async function runStart() {
     api,
     supervisor,
     workspaceManager,
+    runtimeRegistry,
     runtimeIds: cfg.runtimes.map((r) => r.id)
   });
   claimer.start();
@@ -1353,16 +2099,46 @@ async function runStart() {
   };
   process.on("SIGINT", () => void stop("SIGINT"));
   process.on("SIGTERM", () => void stop("SIGTERM"));
+  process.on("unhandledRejection", (reason) => {
+    console.warn("[daemon] unhandledRejection (continuing):", reason instanceof Error ? reason.message : String(reason));
+  });
   await new Promise(() => {
     return;
   });
 }
 
+// src/sync.ts
+async function runSync() {
+  const config = loadConfig();
+  if (!config) {
+    throw new Error(`No daemon config at ${CONFIG_PATH}. Run 'beevibe-daemon setup' first.`);
+  }
+  const detected = await detectClis();
+  if (detected.length === 0) {
+    throw new Error(`No supported CLIs detected on PATH. beevibe currently looks for: ${KNOWN_CLIS.join(", ")}`);
+  }
+  const api = new ApiClient({
+    apiUrl: config.api_url,
+    daemonToken: config.daemon_token
+  });
+  const { status, body } = await api.post("/runtime/sync", {
+    runtimes: detected
+  });
+  if (status !== 200 || !body) {
+    throw new Error(`/runtime/sync failed: ${status}`);
+  }
+  const before = new Set(config.runtimes.map((r) => r.cli));
+  const added = body.runtimes.filter((r) => !before.has(r.cli));
+  const next = { ...config, runtimes: body.runtimes };
+  saveConfig(next);
+  return { added, runtimes: body.runtimes };
+}
+
 // src/update.ts
 import { createHash } from "node:crypto";
 import { createWriteStream, mkdtempSync, rmSync as rmSync2, chmodSync, renameSync } from "node:fs";
-import { tmpdir as tmpdir2 } from "node:os";
-import { join as join5 } from "node:path";
+import { tmpdir as tmpdir4 } from "node:os";
+import { join as join7 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { createInterface } from "node:readline/promises";
@@ -1376,7 +2152,7 @@ var PLATFORM_ASSETS = {
   "linux-arm64": "beevibe-daemon-linux-arm64"
 };
 function currentVersion() {
-  return "0.1.2";
+  return "0.1.3";
 }
 function isCompiledBinary() {
   if (!process.versions.bun)
@@ -1489,8 +2265,8 @@ async function runUpdate(opts = {}) {
       return;
     }
   }
-  const stagingDir = mkdtempSync(join5(tmpdir2(), "beevibe-daemon-update-"));
-  const stagingPath = join5(stagingDir, asset);
+  const stagingDir = mkdtempSync(join7(tmpdir4(), "beevibe-daemon-update-"));
+  const stagingPath = join7(stagingDir, asset);
   try {
     console.log(`Downloading ${asset}…`);
     const downloadUrl = `${DOWNLOAD_BASE}/${latest}/${asset}`;
@@ -1548,6 +2324,7 @@ function printHelp() {
     "Commands:",
     "  setup    Register this machine with a beevibe api server.",
     "  start    Run the daemon: claim pending sessions and spawn the CLI.",
+    "  sync     Re-detect CLIs on PATH and register newly-installed ones.",
     "  update   Check for and install a newer daemon binary (brew/curl installs).",
     "",
     "setup flags:",
@@ -1589,6 +2366,16 @@ async function main() {
     await runStart();
     return;
   }
+  if (command === "sync") {
+    const result = await runSync();
+    if (result.added.length === 0) {
+      console.log("No new CLIs detected.");
+    } else {
+      console.log(`Added ${result.added.length} runtime(s): ${result.added.map((r) => `${r.cli} (${r.id})`).join(", ")}.`);
+      console.log("Restart the daemon to pick up the new runtime(s).");
+    }
+    return;
+  }
   if (command === "update") {
     const skipPrompt = rest.includes("--yes") || rest.includes("-y");
     await runUpdate({ skipPrompt });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@beevibe/daemon",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Beevibe daemon — runs on each user's machine, claims pending sessions and spawns the CLI locally",
   "license": "Apache-2.0",
   "author": "Zhe Pang",