@beevibe/daemon 0.1.3 → 0.1.5

package/dist/main.js

@@ -408,7 +408,10 @@ async function listFilesRecursive(dir) {
   return out;
 }
 // ../core/dist/services/skills/tier-filter.js
-var UNIVERSAL_SKILLS = ["beevibe-pre-task-setup"];
+var UNIVERSAL_SKILLS = [
+  "beevibe-pre-task-setup",
+  "beevibe-verify-pr"
+];
 var TEAM_ONLY_SKILLS = ["beevibe-team-mesh-negotiation"];
 function tierFilterFor(level) {
   if (level === "ic")
@@ -876,9 +879,6 @@ 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);
     }
@@ -1672,6 +1672,9 @@ function createDefaultRuntimeRegistry() {
     opencode: new OpenCodeRuntime({})
   };
 }
+function runtimeMissingError(cli) {
+  return `No runtime registered for dispatch payload type '${cli}'`;
+}
 
 // src/api-client.ts
 import WebSocket from "ws";
@@ -1732,8 +1735,681 @@ class ApiClient {
   }
 }
 
+// ../sandbox/dist/orchestrator.js
+import { spawn as spawn3 } from "node:child_process";
+import { mkdir as mkdir2, readFile as readFile2, readdir, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname2, join as join7, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// ../sandbox/dist/docker.js
+import { spawn as spawn2 } from "node:child_process";
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir as tmpdir4 } from "node:os";
+import { join as join6 } from "node:path";
+var DEFAULT_IMAGE = "python:3.12-slim";
+var DEFAULT_LIMITS = {
+  cmd_timeout_seconds: 300,
+  cpus: 2,
+  memory: "2g",
+  storage: "4g",
+  network: true
+};
+async function createSandbox(opts = {}) {
+  const image = opts.image ?? DEFAULT_IMAGE;
+  const limits = { ...DEFAULT_LIMITS, ...opts.limits ?? {} };
+  const id = generateId(opts.label ?? "bv-sbx");
+  const artifact_dir = await mkdtemp(join6(tmpdir4(), `${id}-artifacts-`));
+  const args = [
+    "run",
+    "--detach",
+    "--name",
+    id,
+    `--cpus=${limits.cpus}`,
+    `--memory=${limits.memory}`,
+    `--storage-opt=size=${limits.storage}`,
+    "--user",
+    "1000:1000",
+    "--tmpfs",
+    "/tmp:rw,size=512m",
+    "-v",
+    `${artifact_dir}:/sandbox/artifacts:rw`,
+    "--workdir",
+    "/sandbox",
+    "--entrypoint",
+    "tail"
+  ];
+  if (!limits.network) {
+    args.push("--network=none");
+  }
+  args.push(image, "-f", "/dev/null");
+  const result = await runDocker(args, { timeoutMs: 30000 });
+  if (result.exit_code !== 0) {
+    await rm(artifact_dir, { recursive: true, force: true }).catch(() => {});
+    throw new SandboxError(`Failed to create sandbox: ${result.stderr.trim() || "docker run exited " + result.exit_code}`);
+  }
+  return {
+    id,
+    image,
+    artifact_dir,
+    created_at: new Date
+  };
+}
+async function exec(sandbox, cmd, opts = {}) {
+  const cwd = opts.cwd ?? "/sandbox";
+  const timeoutMs = (opts.timeout_seconds ?? DEFAULT_LIMITS.cmd_timeout_seconds) * 1000;
+  const args = ["exec", "--workdir", cwd];
+  for (const [k, v] of Object.entries(opts.env ?? {})) {
+    args.push("--env", `${k}=${v}`);
+  }
+  args.push(sandbox.id, "sh", "-c", cmd);
+  const startedAt = Date.now();
+  const r = await runDocker(args, { timeoutMs });
+  return {
+    stdout: r.stdout,
+    stderr: r.stderr,
+    exit_code: r.exit_code,
+    timed_out: r.timed_out,
+    duration_seconds: (Date.now() - startedAt) / 1000
+  };
+}
+async function destroySandbox(sandbox) {
+  await runDocker(["rm", "-f", sandbox.id], { timeoutMs: 30000 }).catch(() => {});
+}
+async function prepareBaseEnvironment(sandbox) {
+  const r = await runDocker([
+    "exec",
+    "--user",
+    "0",
+    sandbox.id,
+    "sh",
+    "-c",
+    "apt-get update -qq && apt-get install -y -qq --no-install-recommends git curl ca-certificates && rm -rf /var/lib/apt/lists/* && mkdir -p /sandbox && chown -R 1000:1000 /sandbox"
+  ], { timeoutMs: 180000 });
+  if (r.exit_code !== 0) {
+    throw new SandboxError(`base prep failed (exit ${r.exit_code}): ${r.stderr.trim().slice(0, 500)}`);
+  }
+}
+
+class SandboxError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SandboxError";
+  }
+}
+function runDocker(args, opts) {
+  return new Promise((resolve) => {
+    const proc = spawn2("docker", args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      proc.kill("SIGKILL");
+    }, opts.timeoutMs);
+    proc.stdout?.on("data", (c) => {
+      stdout += c.toString("utf8");
+    });
+    proc.stderr?.on("data", (c) => {
+      stderr += c.toString("utf8");
+    });
+    proc.on("error", (err) => {
+      clearTimeout(timer);
+      resolve({
+        stdout,
+        stderr: stderr + `
+<spawn-error>${err.message}</spawn-error>`,
+        exit_code: -1,
+        timed_out: timedOut
+      });
+    });
+    proc.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({
+        stdout,
+        stderr,
+        exit_code: code ?? -1,
+        timed_out: timedOut
+      });
+    });
+  });
+}
+function generateId(label) {
+  const suffix = randomBytes2(4).toString("hex");
+  const safe = label.toLowerCase().replace(/[^a-z0-9_-]/g, "-").slice(0, 32);
+  return `${safe}-${suffix}`;
+}
+
+// ../sandbox/dist/orchestrator.js
+var DEFAULT_PROMPT_HEADER = `You are a Beevibe sandbox child agent running inside a fresh Docker container.
+
+You have ONLY these five MCP tools to touch the container. They are in your
+tool list as deferred MCP tools — you MUST load each one via ToolSearch
+before using it. ToolSearch's "select:" form only accepts ONE tool name per
+call, so make five separate calls at the very start of your work:
+
+  ToolSearch({ "query": "select:mcp__beevibe-sandbox__sandbox_exec", "max_results": 1 })
+  ToolSearch({ "query": "select:mcp__beevibe-sandbox__sandbox_read_file", "max_results": 1 })
+  ToolSearch({ "query": "select:mcp__beevibe-sandbox__sandbox_write_file", "max_results": 1 })
+  ToolSearch({ "query": "select:mcp__beevibe-sandbox__sandbox_list", "max_results": 1 })
+  ToolSearch({ "query": "select:mcp__beevibe-sandbox__sandbox_export_artifact", "max_results": 1 })
+
+After those five ToolSearch calls, you may invoke the MCP tools directly:
+
+  mcp__beevibe-sandbox__sandbox_exec(cmd, cwd?, timeout_seconds?)
+  mcp__beevibe-sandbox__sandbox_read_file(path, max_bytes?)
+  mcp__beevibe-sandbox__sandbox_write_file(path, content)
+  mcp__beevibe-sandbox__sandbox_list(path)
+  mcp__beevibe-sandbox__sandbox_export_artifact(sandbox_path, title?)
+
+You have NO Bash, NO Read, NO Edit, NO Write tool — those will return errors.
+
+The container has Python 3.12, git, and curl pre-installed. Operate inside
+/sandbox. Use a project-local venv at /sandbox/venv.
+
+Your job: use the external repo the user gives you to produce a real artifact
+for the goal. Plan, install, run, verify, export. You succeed by exporting at
+least one artifact under /sandbox/artifacts/ via sandbox_export_artifact. Stop
+as soon as you've exported something useful — don't keep exploring. If you
+can't, write REASON.txt explaining why and export that.`;
+function nowIso() {
+  return new Date().toISOString();
+}
+var MAX_TRANSCRIPT_EVENTS = 500;
+var MAX_EVENT_TEXT_BYTES = 4000;
+function classifyStartupError(err) {
+  const raw = err instanceof Error ? err.message : String(err);
+  if (/Cannot connect to the Docker daemon/i.test(raw)) {
+    return "Docker isn't running. Start Docker Desktop and try the run again.";
+  }
+  if (/ENOENT.*docker/i.test(raw)) {
+    return "The `docker` CLI isn't on PATH. Install Docker Desktop (or set DOCKER_HOST).";
+  }
+  if (/no space left on device/i.test(raw)) {
+    return "Docker is out of disk. Prune containers/images or expand Docker Desktop's allotment.";
+  }
+  return raw;
+}
+async function runRepoAgent(opts) {
+  const state = {
+    run_id: opts.run_id,
+    status: "starting",
+    repo_url: opts.repo_url,
+    goal: opts.goal,
+    started_at: nowIso(),
+    transcript: [],
+    artifacts: []
+  };
+  const emit = () => opts.on_state?.({ ...state, transcript: state.transcript.slice(), artifacts: state.artifacts.slice() });
+  const log = (kind, text) => {
+    const trimmed = text.length > MAX_EVENT_TEXT_BYTES ? text.slice(0, MAX_EVENT_TEXT_BYTES) + `
+…[truncated ${text.length - MAX_EVENT_TEXT_BYTES} bytes]…` : text;
+    state.transcript.push({ at: nowIso(), kind, text: trimmed });
+    if (state.transcript.length > MAX_TRANSCRIPT_EVENTS) {
+      const overflow = state.transcript.length - MAX_TRANSCRIPT_EVENTS;
+      state.transcript.splice(1, overflow);
+      const alreadyMarked = state.transcript[1]?.text.startsWith("[log truncated:");
+      if (!alreadyMarked) {
+        state.transcript.splice(1, 0, {
+          at: nowIso(),
+          kind: "log",
+          text: `[log truncated: dropped ${overflow} earlier event${overflow === 1 ? "" : "s"}]`
+        });
+      }
+    }
+    emit();
+  };
+  let sandbox = null;
+  try {
+    log("log", "Creating sandbox container…");
+    state.status = "preparing";
+    emit();
+    try {
+      sandbox = await createSandbox({ label: `bv-run-${opts.run_id}` });
+    } catch (err) {
+      throw new Error(classifyStartupError(err));
+    }
+    state.sandbox_id = sandbox.id;
+    log("log", `Sandbox ${sandbox.id} created (image ${sandbox.image}).`);
+    log("log", "Installing git + curl in the sandbox base image…");
+    await prepareBaseEnvironment(sandbox);
+    log("log", "Base environment ready.");
+    if (opts.input_url) {
+      const filename = opts.input_filename ?? "input.bin";
+      log("log", `Fetching input into /sandbox/inputs/${filename}…`);
+      const r = await exec(sandbox, `mkdir -p /sandbox/inputs && curl -fsSL ${shellQuote(opts.input_url)} -o /sandbox/inputs/${shellQuote(filename)}`, { timeout_seconds: 120 });
+      if (r.exit_code !== 0) {
+        throw new Error(`input fetch failed: ${r.stderr.trim().slice(0, 400)}`);
+      }
+      log("log", "Input file ready.");
+    }
+    const mcpServerCommand = opts.mcp_server_command ?? defaultMcpServerCommand();
+    const mcpConfigPath = join7(sandbox.artifact_dir, "mcp-config.json");
+    const mcpConfig = {
+      mcpServers: {
+        "beevibe-sandbox": {
+          command: mcpServerCommand.command,
+          args: mcpServerCommand.args,
+          env: {
+            BEEVIBE_SANDBOX_ID: sandbox.id,
+            BEEVIBE_SANDBOX_ARTIFACTS: sandbox.artifact_dir
+          }
+        }
+      }
+    };
+    await writeFile2(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), "utf8");
+    log("log", `MCP config written: ${mcpConfigPath}`);
+    const userPrompt = buildUserPrompt(opts);
+    const systemPromptAppend = DEFAULT_PROMPT_HEADER;
+    state.status = "running";
+    log("log", "Spawning child claude session…");
+    emit();
+    const claudeResult = await runClaude({
+      claudeBin: opts.claude_bin ?? "claude",
+      mcpConfigPath,
+      systemPromptAppend,
+      userPrompt,
+      maxBudgetUsd: opts.max_budget_usd ?? 2,
+      timeoutSeconds: opts.max_runtime_seconds ?? 600,
+      onTranscript: (kind, text) => log(kind, text)
+    });
+    if (claudeResult.exit_code !== 0 && claudeResult.exit_code !== null) {
+      const tail = claudeResult.stderr.slice(-500);
+      log("error", `Child claude exited with code ${claudeResult.exit_code}: ${tail}`);
+      state.status = claudeResult.timed_out ? "blocked" : "failed";
+      state.error = claudeResult.timed_out ? `Run hit the ${opts.max_runtime_seconds ?? 600}s wall-clock budget — agent didn't finish in time.` : `Claude exited ${claudeResult.exit_code}.${tail ? " " + tail.slice(-200) : ""}`;
+      state.finished_at = nowIso();
+      emit();
+      return state;
+    }
+    log("log", "Child claude exited cleanly. Collecting artifacts…");
+    state.artifacts = await collectArtifacts(sandbox);
+    if (state.artifacts.length === 0) {
+      state.status = "blocked";
+      state.error = "agent produced no artifacts";
+    } else {
+      state.status = "succeeded";
+    }
+    state.finished_at = nowIso();
+    emit();
+    return state;
+  } catch (err) {
+    log("error", err instanceof Error ? err.message : String(err));
+    state.status = "failed";
+    state.error = err instanceof Error ? err.message : String(err);
+    state.finished_at = nowIso();
+    emit();
+    return state;
+  } finally {
+    if (sandbox) {
+      try {
+        log("log", `Destroying sandbox ${sandbox.id}…`);
+        await destroySandbox(sandbox);
+      } catch (err) {
+        log("log", `Sandbox cleanup note: ${err instanceof Error ? err.message : String(err)}. Run with \`docker ps -a --filter name=bv-run-\` to inspect.`);
+      }
+    }
+  }
+}
+function buildUserPrompt(opts) {
+  const lines = [
+    `Goal: ${opts.goal}`,
+    `Repo: ${opts.repo_url}`
+  ];
+  if (opts.input_url) {
+    lines.push(`Input file (pre-fetched): /sandbox/inputs/${opts.input_filename ?? "input.bin"}`);
+  }
+  lines.push("");
+  lines.push("Work inside /sandbox. Clone the repo to /sandbox/repo. Install in a venv. ");
+  lines.push("Produce at least one artifact under /sandbox/artifacts/, then call ");
+  lines.push("sandbox_export_artifact() on each one with a short, human-readable title. ");
+  lines.push("Stop as soon as you've exported a useful artifact — don't keep exploring.");
+  return lines.join(`
+`);
+}
+var ALLOWED_TOOLS = [
+  "mcp__beevibe-sandbox__sandbox_exec",
+  "mcp__beevibe-sandbox__sandbox_read_file",
+  "mcp__beevibe-sandbox__sandbox_write_file",
+  "mcp__beevibe-sandbox__sandbox_list",
+  "mcp__beevibe-sandbox__sandbox_export_artifact"
+];
+var DISALLOWED_TOOLS = ["Bash", "Read", "Edit", "Write", "BashOutput", "KillBash"];
+function runClaude(args) {
+  return new Promise((resolve2) => {
+    const cliArgs = [
+      "--print",
+      "--mcp-config",
+      args.mcpConfigPath,
+      "--allowed-tools",
+      ALLOWED_TOOLS.join(","),
+      "--disallowed-tools",
+      DISALLOWED_TOOLS.join(","),
+      "--append-system-prompt",
+      args.systemPromptAppend,
+      "--max-budget-usd",
+      String(args.maxBudgetUsd),
+      "--output-format",
+      "stream-json",
+      "--verbose"
+    ];
+    const proc = spawn3(args.claudeBin, cliArgs, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env },
+      detached: true
+    });
+    proc.unref();
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let stdoutBuffer = "";
+    const timer = setTimeout(() => {
+      timedOut = true;
+      proc.kill("SIGTERM");
+      setTimeout(() => proc.kill("SIGKILL"), 5000);
+    }, args.timeoutSeconds * 1000);
+    proc.stdout.on("data", (chunk) => {
+      const s = chunk.toString("utf8");
+      stdout += s;
+      stdoutBuffer += s;
+      let nl;
+      while ((nl = stdoutBuffer.indexOf(`
+`)) !== -1) {
+        const line = stdoutBuffer.slice(0, nl);
+        stdoutBuffer = stdoutBuffer.slice(nl + 1);
+        if (line.trim().length === 0)
+          continue;
+        try {
+          const evt = JSON.parse(line);
+          if (evt && typeof evt === "object" && evt.type === "system" && evt.subtype === "init") {
+            const init = evt;
+            const servers = init.mcp_servers;
+            if (servers) {
+              for (const sv of servers) {
+                args.onTranscript("log", `mcp server ${sv.name}: ${sv.status}`);
+              }
+            }
+            const tools = init.tools;
+            const mcpTools = (tools ?? []).filter((t) => t.startsWith("mcp__beevibe-sandbox__"));
+            args.onTranscript("log", `mcp tools exposed: ${mcpTools.length ? mcpTools.join(", ") : "none"}`);
+          }
+          handleStreamEvent(evt, args.onTranscript);
+        } catch {}
+      }
+    });
+    proc.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    proc.on("error", (err) => {
+      clearTimeout(timer);
+      const friendly = /ENOENT/i.test(err.message) ? `Claude CLI not found at ${args.claudeBin}. Set BEEVIBE_CLAUDE_BIN to the binary path.` : `claude spawn error: ${err.message}`;
+      args.onTranscript("error", friendly);
+      resolve2({ exit_code: -1, stdout, stderr, timed_out: timedOut });
+    });
+    proc.on("close", (code) => {
+      clearTimeout(timer);
+      if (code !== 0 && code !== null) {
+        const tail = stderr.slice(-800).trim();
+        if (tail) {
+          args.onTranscript("error", `claude stderr tail: ${tail}`);
+        }
+      }
+      resolve2({ exit_code: code, stdout, stderr, timed_out: timedOut });
+    });
+    proc.stdin.write(args.userPrompt);
+    proc.stdin.end();
+  });
+}
+function handleStreamEvent(evt, emit) {
+  if (!evt || typeof evt !== "object")
+    return;
+  const e = evt;
+  const t = e.type;
+  if (t === "assistant" || t === "assistant_message") {
+    const message = e.message;
+    if (message && Array.isArray(message.content)) {
+      for (const item of message.content) {
+        if (!item || typeof item !== "object")
+          continue;
+        const it = item;
+        if (it.type === "text" && typeof it.text === "string") {
+          emit("agent", it.text);
+        } else if (it.type === "tool_use") {
+          const name = String(it.name ?? "unknown");
+          const input = it.input ? compactJson(it.input) : "";
+          emit("tool_call", `${name}(${input})`);
+        }
+      }
+    } else if (typeof e.content === "string") {
+      emit("agent", e.content);
+    }
+  } else if (t === "user" || t === "user_message") {
+    const message = e.message;
+    if (message && Array.isArray(message.content)) {
+      for (const item of message.content) {
+        if (!item || typeof item !== "object")
+          continue;
+        const it = item;
+        if (it.type === "tool_result") {
+          const content = it.content;
+          let text;
+          if (typeof content === "string") {
+            text = content;
+          } else if (Array.isArray(content)) {
+            text = content.map((c) => c && typeof c === "object" && typeof c.text === "string" ? c.text : "").filter(Boolean).join(" ");
+          } else {
+            text = JSON.stringify(content ?? null);
+          }
+          const isErr = it.is_error === true;
+          emit(isErr ? "error" : "tool_call", `→ ${text.slice(0, 300)}${text.length > 300 ? "…" : ""}`);
+        }
+      }
+    }
+  } else if (t === "result" && typeof e.result === "string") {
+    emit("agent", e.result);
+  } else if (t === "error") {
+    emit("error", typeof e.message === "string" ? e.message : "claude error");
+  }
+}
+function compactJson(v) {
+  try {
+    const s = JSON.stringify(v);
+    return s.length > 200 ? s.slice(0, 200) + "…" : s;
+  } catch {
+    return "?";
+  }
+}
+async function collectArtifacts(sandbox) {
+  const out = [];
+  await mkdir2(sandbox.artifact_dir, { recursive: true });
+  const entries = await readdir(sandbox.artifact_dir);
+  const sidecars = new Map;
+  for (const e of entries) {
+    if (e.endsWith(".meta.json")) {
+      try {
+        const raw = await readFile2(join7(sandbox.artifact_dir, e), "utf8");
+        sidecars.set(e.replace(/\.meta\.json$/, ""), JSON.parse(raw));
+      } catch {}
+    }
+  }
+  for (const e of entries) {
+    if (e.endsWith(".meta.json") || e === "mcp-config.json")
+      continue;
+    const hostPath = join7(sandbox.artifact_dir, e);
+    const stat = await readFile2(hostPath).then((b) => ({ size: b.byteLength }), () => null);
+    if (!stat)
+      continue;
+    const meta = sidecars.get(e);
+    out.push({
+      filename: e,
+      title: typeof meta?.title === "string" && meta.title || e.replace(/\.[^.]+$/, ""),
+      size_bytes: stat.size,
+      host_path: hostPath,
+      sandbox_path: typeof meta?.sandbox_path === "string" && meta.sandbox_path || undefined
+    });
+  }
+  return out;
+}
+function defaultMcpServerCommand() {
+  const here = dirname2(fileURLToPath(import.meta.url));
+  const isTsxRun = here.endsWith("/src");
+  const mcpServerPath = resolve(here, isTsxRun ? "./mcp-server.ts" : "./mcp-server.js");
+  return isTsxRun ? { command: "npx", args: ["--no-install", "tsx", mcpServerPath] } : { command: "node", args: ["--enable-source-maps", mcpServerPath] };
+}
+function shellQuote(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+
+// src/repo-runs.ts
+var CLAUDE_BIN = process.env.BEEVIBE_CLAUDE_BIN ?? "claude";
+async function runRepoDispatch(deps, payload, abortSignal) {
+  const rr = payload.run_repo;
+  if (!rr) {
+    throw new Error("run_repo dispatch missing payload.run_repo");
+  }
+  console.log(`[daemon/repo-run] sess=${payload.session_id} repo_run=${rr.repo_run_id} repo=${rr.repo_url}`);
+  const buffer = [];
+  let flushTimer;
+  const flush = async () => {
+    if (buffer.length === 0)
+      return;
+    const events = buffer.splice(0);
+    try {
+      await deps.api.post("/runtime/events", { events });
+    } catch (err) {
+      console.warn("[daemon/repo-run] /runtime/events POST failed:", err instanceof Error ? err.message : String(err));
+    }
+  };
+  const scheduleFlush = () => {
+    if (flushTimer)
+      return;
+    flushTimer = setTimeout(() => {
+      flushTimer = undefined;
+      flush();
+    }, 250);
+  };
+  let pushedUpTo = 0;
+  const pushNew = (transcript) => {
+    for (let i = pushedUpTo;i < transcript.length; i++) {
+      const ev = transcript[i];
+      if (!ev)
+        continue;
+      buffer.push({
+        session_id: payload.session_id,
+        kind: mapKind(ev.kind),
+        content: ev.text
+      });
+    }
+    pushedUpTo = transcript.length;
+    if (buffer.length >= 16)
+      flush();
+    else
+      scheduleFlush();
+  };
+  const installLines = [];
+  let invocation;
+  const noteCommandFromToolCall = (text) => {
+    const m = text.match(/sandbox_exec\(\{?"?cmd"?:?\s*"([^"]+)"/);
+    if (!m)
+      return;
+    const cmd = m[1] ?? "";
+    if (!cmd)
+      return;
+    if (isInstallCommand(cmd))
+      installLines.push(cmd);
+    else
+      invocation = cmd;
+  };
+  const result = await runRepoAgent({
+    run_id: rr.repo_run_id,
+    repo_url: rr.repo_url,
+    goal: rr.goal,
+    input_url: rr.input_url,
+    input_filename: rr.input_filename,
+    claude_bin: CLAUDE_BIN,
+    max_runtime_seconds: (rr.limits?.wall_clock_minutes ?? 20) * 60,
+    on_state: (s) => {
+      pushNew(s.transcript);
+      for (let i = pushedUpTo - (s.transcript.length - 0);i < s.transcript.length; i++) {
+        if (i < 0)
+          continue;
+        const ev = s.transcript[i];
+        if (ev?.kind === "tool_call")
+          noteCommandFromToolCall(ev.text);
+      }
+      if (abortSignal?.aborted) {
+        buffer.push({
+          session_id: payload.session_id,
+          kind: "summary",
+          content: "[run cancelled by user]"
+        });
+        flush();
+      }
+    }
+  });
+  if (flushTimer) {
+    clearTimeout(flushTimer);
+    flushTimer = undefined;
+  }
+  await flush();
+  const status = result.status === "succeeded" ? "succeeded" : result.status === "blocked" ? "failed" : result.status === "failed" ? "failed" : "failed";
+  const artifacts = result.artifacts.map((a) => ({
+    filename: a.filename,
+    title: a.title,
+    size_bytes: a.size_bytes,
+    host_path: a.host_path,
+    sandbox_path: a.sandbox_path
+  }));
+  const done = {
+    session_id: payload.session_id,
+    status,
+    result_summary: result.status === "succeeded" ? `Exported ${artifacts.length} artifact${artifacts.length === 1 ? "" : "s"}.` : result.error ?? "Run did not produce an artifact.",
+    error: result.error,
+    run_repo: {
+      repo_run_id: rr.repo_run_id,
+      install_log: installLines.length ? installLines.join(`
+`) : undefined,
+      invocation,
+      artifacts
+    }
+  };
+  if (status === "succeeded") {
+    console.log(`[daemon/repo-run] sess=${payload.session_id} succeeded artifacts=${artifacts.length}`);
+  } else {
+    console.error(`[daemon/repo-run] sess=${payload.session_id} status=${status}` + (result.error ? `
+  error:
+    ${result.error.split(`
+`).join(`
+    `)}` : ""));
+  }
+  try {
+    await deps.api.post("/runtime/done", done);
+  } catch (err) {
+    console.error("[daemon/repo-run] /runtime/done POST failed:", err instanceof Error ? err.message : String(err));
+  }
+}
+function mapKind(kind) {
+  switch (kind) {
+    case "agent":
+      return "agent";
+    case "tool_call":
+      return "tool_call";
+    case "log":
+      return "summary";
+    case "error":
+      return "tool_result";
+  }
+}
+function isInstallCommand(cmd) {
+  return /^(pip\s|pip3\s|apt-get\s|apt\s|brew\s|npm\s+(install|i)|yarn\s+(add|install)|pnpm\s+(add|install)|git\s+clone)/.test(cmd.trim());
+}
+
 // src/spawner.ts
 async function runDispatch(deps, payload, abortSignal) {
+  if (payload.type === "run_repo") {
+    await runRepoDispatch({ api: deps.api }, payload, abortSignal);
+    return;
+  }
   const syntheticAgent = {
     id: payload.agent_id,
     api_key: payload.agent_api_key,
@@ -1745,7 +2421,7 @@ async function runDispatch(deps, payload, abortSignal) {
   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}'`);
+    throw new Error(runtimeMissingError(payload.runtime_type));
   }
   const buffer = [];
   let flushTimer;
@@ -1788,7 +2464,6 @@ 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,
@@ -1964,14 +2639,14 @@ class Claimer {
 // src/skills-cache.ts
 import { promises as fs2 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join8 } from "node:path";
 function skillsCacheDir() {
-  return join6(homedir3(), ".beevibe", "skills");
+  return join8(homedir3(), ".beevibe", "skills");
 }
 var VERSION_FILE = ".version";
 async function readCachedVersion() {
   try {
-    return (await fs2.readFile(join6(skillsCacheDir(), VERSION_FILE), "utf8")).trim();
+    return (await fs2.readFile(join8(skillsCacheDir(), VERSION_FILE), "utf8")).trim();
   } catch {
     return;
   }
@@ -1992,19 +2667,19 @@ async function syncSkillsCache(api) {
     if (!dirent.isDirectory())
       continue;
     if (dirent.name === "beevibe" || dirent.name.startsWith("beevibe-")) {
-      await fs2.rm(join6(cache, dirent.name), { recursive: true, force: true });
+      await fs2.rm(join8(cache, dirent.name), { recursive: true, force: true });
     }
   }
   for (const skill of res.skills) {
-    const skillDir = join6(cache, skill.name);
+    const skillDir = join8(cache, skill.name);
     await fs2.mkdir(skillDir, { recursive: true, mode: 448 });
     for (const file of skill.files) {
-      const filePath = join6(skillDir, file.path);
-      await fs2.mkdir(join6(filePath, ".."), { recursive: true });
+      const filePath = join8(skillDir, file.path);
+      await fs2.mkdir(join8(filePath, ".."), { recursive: true });
       await fs2.writeFile(filePath, file.content, { mode: 384 });
     }
   }
-  await fs2.writeFile(join6(cache, VERSION_FILE), res.version, { mode: 384 });
+  await fs2.writeFile(join8(cache, VERSION_FILE), res.version, { mode: 384 });
   return cache;
 }
 
@@ -2137,8 +2812,8 @@ async function runSync() {
 // src/update.ts
 import { createHash } from "node:crypto";
 import { createWriteStream, mkdtempSync, rmSync as rmSync2, chmodSync, renameSync } from "node:fs";
-import { tmpdir as tmpdir4 } from "node:os";
-import { join as join7 } from "node:path";
+import { tmpdir as tmpdir5 } from "node:os";
+import { join as join9 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { createInterface } from "node:readline/promises";
@@ -2152,7 +2827,7 @@ var PLATFORM_ASSETS = {
   "linux-arm64": "beevibe-daemon-linux-arm64"
 };
 function currentVersion() {
-  return "0.1.3";
+  return "0.1.5";
 }
 function isCompiledBinary() {
   if (!process.versions.bun)
@@ -2265,8 +2940,8 @@ async function runUpdate(opts = {}) {
       return;
     }
   }
-  const stagingDir = mkdtempSync(join7(tmpdir4(), "beevibe-daemon-update-"));
-  const stagingPath = join7(stagingDir, asset);
+  const stagingDir = mkdtempSync(join9(tmpdir5(), "beevibe-daemon-update-"));
+  const stagingPath = join9(stagingDir, asset);
   try {
     console.log(`Downloading ${asset}…`);
     const downloadUrl = `${DOWNLOAD_BASE}/${latest}/${asset}`;

package/package.json

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