@beevibe/daemon 0.0.1-rc2

package/dist/main.js

@@ -0,0 +1,1385 @@
+#!/usr/bin/env node
+
+// src/setup.ts
+import { hostname, userInfo } from "node:os";
+import { spawnSync } from "node:child_process";
+
+// src/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+var CONFIG_DIR = join(homedir(), ".beevibe");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+function loadConfig() {
+  if (!existsSync(CONFIG_PATH))
+    return;
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
+  } catch (err) {
+    throw new Error(`Daemon config at ${CONFIG_PATH} is malformed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function saveConfig(cfg) {
+  mkdirSync(dirname(CONFIG_PATH), { recursive: true, mode: 448 });
+  writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + `
+`, { mode: 384 });
+}
+
+// src/setup.ts
+var KNOWN_CLIS = ["claude", "codex", "opencode"];
+async function runSetup(options) {
+  if (!/^https?:\/\//.test(options.apiUrl)) {
+    throw new Error("--api must be an http(s) URL");
+  }
+  if (!options.userToken.startsWith("bv_u_")) {
+    throw new Error("--user-token must start with bv_u_");
+  }
+  const externalId = options.externalId ?? hostname();
+  const deviceName = options.deviceName ?? `${userInfo().username}@${hostname()}`;
+  const runtimes = options.detectedClis ?? detectClis();
+  if (runtimes.length === 0) {
+    throw new Error(`No supported CLIs detected on PATH. beevibe currently looks for: ${KNOWN_CLIS.join(", ")}`);
+  }
+  const res = await fetch(`${options.apiUrl}/runtime/register`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${options.userToken}`
+    },
+    body: JSON.stringify({
+      external_id: externalId,
+      device_name: deviceName,
+      runtimes
+    })
+  });
+  if (res.status !== 200 && res.status !== 201) {
+    throw new Error(`/runtime/register failed: ${res.status} ${await res.text()}`);
+  }
+  const body = await res.json();
+  const config = {
+    api_url: options.apiUrl,
+    external_id: externalId,
+    daemon_id: body.daemon_id,
+    daemon_token: body.daemon_token,
+    runtimes: body.runtimes
+  };
+  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, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+
+// ../core/dist/services/skills/sync.js
+import { promises as fs } from "node:fs";
+import path from "node:path";
+async function syncSkills(opts) {
+  const { sourceDir, targetDir, filter, namespacePrefix } = opts;
+  const result = { added: [], updated: [], removed: [], unchanged: [] };
+  await fs.mkdir(targetDir, { recursive: true });
+  const targetEntries = await fs.readdir(targetDir, { withFileTypes: true });
+  const targetSkills = new Set;
+  for (const entry of targetEntries) {
+    if (!entry.isDirectory())
+      continue;
+    const name = entry.name;
+    if (name === namespacePrefix || name.startsWith(`${namespacePrefix}-`)) {
+      targetSkills.add(name);
+    }
+  }
+  for (const name of targetSkills) {
+    if (!filter.has(name)) {
+      await fs.rm(path.join(targetDir, name), { recursive: true, force: true });
+      result.removed.push(name);
+    }
+  }
+  for (const name of filter) {
+    const src = path.join(sourceDir, name);
+    const tgt = path.join(targetDir, name);
+    const srcExists = await pathExists(src);
+    if (!srcExists) {
+      if (targetSkills.has(name)) {
+        await fs.rm(tgt, { recursive: true, force: true });
+        result.removed.push(name);
+      }
+      continue;
+    }
+    if (!targetSkills.has(name)) {
+      await copyDir(src, tgt);
+      result.added.push(name);
+      continue;
+    }
+    const changed = await syncDirIfChanged(src, tgt);
+    if (changed)
+      result.updated.push(name);
+    else
+      result.unchanged.push(name);
+  }
+  return result;
+}
+async function pathExists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function copyDir(src, dst) {
+  await fs.mkdir(dst, { recursive: true });
+  const entries = await fs.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const s = path.join(src, entry.name);
+    const d = path.join(dst, entry.name);
+    if (entry.isDirectory()) {
+      await copyDir(s, d);
+    } else if (entry.isFile() || entry.isSymbolicLink()) {
+      await fs.copyFile(s, d);
+    }
+  }
+}
+async function syncDirIfChanged(src, tgt) {
+  let changed = false;
+  const srcFiles = await listFilesRecursive(src);
+  const tgtFiles = await listFilesRecursive(tgt);
+  const srcRel = new Set(srcFiles.map((f) => path.relative(src, f)));
+  for (const srcFile of srcFiles) {
+    const rel = path.relative(src, srcFile);
+    const tgtFile = path.join(tgt, rel);
+    const srcStat = await fs.stat(srcFile);
+    let tgtStat;
+    try {
+      tgtStat = await fs.stat(tgtFile);
+    } catch {
+      tgtStat = null;
+    }
+    const needsCopy = !tgtStat || tgtStat.mtimeMs < srcStat.mtimeMs || tgtStat.size !== srcStat.size;
+    if (needsCopy) {
+      await fs.mkdir(path.dirname(tgtFile), { recursive: true });
+      await fs.copyFile(srcFile, tgtFile);
+      changed = true;
+    }
+  }
+  for (const tgtFile of tgtFiles) {
+    const rel = path.relative(tgt, tgtFile);
+    if (!srcRel.has(rel)) {
+      await fs.rm(tgtFile, { force: true });
+      changed = true;
+    }
+  }
+  return changed;
+}
+async function listFilesRecursive(dir) {
+  const out = [];
+  async function walk(d) {
+    const entries = await fs.readdir(d, { withFileTypes: true });
+    for (const entry of entries) {
+      const p = path.join(d, entry.name);
+      if (entry.isDirectory())
+        await walk(p);
+      else if (entry.isFile() || entry.isSymbolicLink())
+        out.push(p);
+    }
+  }
+  if (await pathExists(dir))
+    await walk(dir);
+  return out;
+}
+// ../core/dist/services/skills/tier-filter.js
+var UNIVERSAL_SKILLS = ["beevibe-pre-task-setup"];
+var TEAM_ONLY_SKILLS = ["beevibe-team-mesh-negotiation"];
+function tierFilterFor(level) {
+  if (level === "ic")
+    return new Set(UNIVERSAL_SKILLS);
+  return new Set([...UNIVERSAL_SKILLS, ...TEAM_ONLY_SKILLS]);
+}
+// ../core/dist/adapters/local-workspace/manager.js
+class LocalWorkspaceManager {
+  config;
+  root;
+  constructor(config) {
+    this.config = config;
+    this.root = config.workspaceRoot ?? join2(homedir2(), ".beevibe", "workspaces");
+  }
+  async ensureWorkspace({ agent }) {
+    const path2 = join2(this.root, agent.id);
+    mkdirSync2(path2, { recursive: true, mode: 448 });
+    const configPath = join2(path2, "mcp-config.json");
+    if (!existsSync2(configPath)) {
+      if (!agent.api_key) {
+        throw new Error(`Cannot write mcp-config.json for agent ${agent.id}: agent.api_key is missing`);
+      }
+      writeFileSync2(configPath, buildMcpConfig(agent.api_key, this.config.mcpServerUrl), {
+        mode: 384
+      });
+    }
+    const workspace = { path: path2 };
+    const runtime = this.config.runtimeRegistry[agent.runtime_config.type];
+    if (!runtime) {
+      throw new Error(`No runtime registered for agent ${agent.id} (runtime_config.type='${agent.runtime_config.type}')`);
+    }
+    await syncSkills({
+      sourceDir: this.config.skillsSourceDir,
+      targetDir: runtime.skillsDir(workspace),
+      filter: tierFilterFor(agent.hierarchy_level),
+      namespacePrefix: "beevibe"
+    });
+    return workspace;
+  }
+  async removeWorkspace(workspace) {
+    rmSync(workspace.path, { recursive: true, force: true });
+  }
+}
+function buildMcpConfig(apiKey, mcpServerUrl) {
+  return JSON.stringify({
+    mcpServers: {
+      beevibe: {
+        type: "http",
+        url: mcpServerUrl,
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "X-Beevibe-Session": "${BEEVIBE_SESSION_ID}"
+        }
+      }
+    }
+  }, null, 2) + `
+`;
+}
+// ../core/dist/adapters/claude-code/runtime.js
+import { tmpdir } from "node:os";
+import { join as join3 } from "node:path";
+
+// ../core/dist/adapters/claude-code/spawn.js
+import { spawn } from "node:child_process";
+var MAX_CAPTURE_BYTES = 4 * 1024 * 1024;
+
+class CappedBuffer {
+  chunks = [];
+  len = 0;
+  truncated = false;
+  append(chunk) {
+    if (this.len >= MAX_CAPTURE_BYTES) {
+      this.truncated = true;
+      return;
+    }
+    const remaining = MAX_CAPTURE_BYTES - this.len;
+    if (chunk.length > remaining) {
+      this.chunks.push(chunk.slice(0, remaining));
+      this.len = MAX_CAPTURE_BYTES;
+      this.truncated = true;
+    } else {
+      this.chunks.push(chunk);
+      this.len += chunk.length;
+    }
+  }
+  join() {
+    return this.chunks.join("");
+  }
+}
+function runCliProcess(options) {
+  if (process.platform === "win32") {
+    throw new Error("runCliProcess: Windows is not supported in v1. Process-group " + "signaling is POSIX-only; half-working Windows behavior would leak " + "child processes on abort.");
+  }
+  const graceMs = options.graceMs ?? 20000;
+  return new Promise((resolve) => {
+    const stdout = new CappedBuffer;
+    const stderr = new CappedBuffer;
+    let settled = false;
+    const proc = spawn(options.command, options.args ?? [], {
+      env: options.env ?? process.env,
+      cwd: options.cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      detached: true,
+      shell: false
+    });
+    const pid = proc.pid ?? null;
+    if (pid !== null && options.onSpawn) {
+      options.onSpawn({ pid, process_group_id: pid });
+    }
+    function killProc(signal) {
+      try {
+        if (proc.pid)
+          process.kill(-proc.pid, signal);
+      } catch {}
+    }
+    function settleWith(partial) {
+      if (settled)
+        return;
+      settled = true;
+      if (timer)
+        clearTimeout(timer);
+      resolve({
+        ...partial,
+        stdout: stdout.join(),
+        stderr: stderr.join(),
+        pid,
+        process_group_id: pid,
+        truncated: stdout.truncated || stderr.truncated
+      });
+    }
+    proc.stdin.on("error", () => {});
+    if (options.stdin !== undefined) {
+      proc.stdin.write(options.stdin);
+    }
+    proc.stdin.end();
+    let asyncMode = false;
+    let logChain = Promise.resolve();
+    function invokeLog(kind, text) {
+      if (!options.onLog)
+        return;
+      const cb = options.onLog;
+      if (asyncMode) {
+        logChain = logChain.then(() => {
+          try {
+            return cb(kind, text);
+          } catch {
+            return;
+          }
+        }).catch(() => {
+          return;
+        });
+        return;
+      }
+      let ret;
+      try {
+        ret = cb(kind, text);
+      } catch {
+        return;
+      }
+      if (ret && typeof ret.then === "function") {
+        asyncMode = true;
+        logChain = ret.catch(() => {
+          return;
+        });
+      }
+    }
+    function attachStreamHandler(stream, kind, buf) {
+      stream.on("data", (chunk) => {
+        const text = chunk.toString();
+        buf.append(text);
+        invokeLog(kind, text);
+      });
+    }
+    attachStreamHandler(proc.stdout, "stdout", stdout);
+    attachStreamHandler(proc.stderr, "stderr", stderr);
+    let abortFired = false;
+    let timeoutFired = false;
+    let timer = null;
+    if (options.timeoutMs) {
+      timer = setTimeout(() => {
+        timeoutFired = true;
+        killProc("SIGTERM");
+        setTimeout(() => {
+          if (!settled)
+            killProc("SIGKILL");
+        }, graceMs);
+      }, options.timeoutMs);
+    }
+    if (options.abortSignal) {
+      options.abortSignal.addEventListener("abort", () => {
+        abortFired = true;
+        killProc("SIGTERM");
+        setTimeout(() => {
+          if (!settled)
+            killProc("SIGKILL");
+        }, graceMs);
+      }, { once: true });
+    }
+    proc.on("close", (code) => {
+      settleWith({ exitCode: code, timedOut: timeoutFired, aborted: abortFired });
+    });
+    proc.on("error", (err) => {
+      stderr.append(err.message);
+      settleWith({ exitCode: null, timedOut: timeoutFired, aborted: abortFired });
+    });
+  });
+}
+
+// ../core/dist/adapters/claude-code/stream-json.js
+var STREAM_TYPE = {
+  System: "system",
+  Assistant: "assistant",
+  ToolUse: "tool_use",
+  ToolResult: "tool_result",
+  Result: "result",
+  ContentBlockStart: "content_block_start"
+};
+var BLOCK_TYPE = {
+  Text: "text",
+  ToolUse: "tool_use"
+};
+function parseStreamJsonLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed || !trimmed.startsWith("{"))
+    return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+}
+function extractStepEvents(msg) {
+  const now = new Date().toISOString();
+  if (msg.type === STREAM_TYPE.ToolUse || msg.subtype === STREAM_TYPE.ToolUse) {
+    return [
+      {
+        kind: "tool_call",
+        tool: msg.name ?? "unknown",
+        description: describeToolInput(msg.input ?? {}),
+        timestamp: now
+      }
+    ];
+  }
+  if (msg.type === STREAM_TYPE.ContentBlockStart && msg.content_block?.type === BLOCK_TYPE.ToolUse) {
+    const block = msg.content_block;
+    return [
+      {
+        kind: "tool_call",
+        tool: block.name ?? "unknown",
+        description: describeToolInput(block.input ?? {}),
+        timestamp: now
+      }
+    ];
+  }
+  if (msg.type === STREAM_TYPE.Assistant && msg.message && Array.isArray(msg.message.content)) {
+    const out = [];
+    for (const block of msg.message.content) {
+      if (block.type === BLOCK_TYPE.Text && typeof block.text === "string" && block.text.trim().length > 0) {
+        out.push({
+          kind: "agent",
+          description: block.text,
+          timestamp: now
+        });
+      } else if (block.type === BLOCK_TYPE.ToolUse) {
+        out.push({
+          kind: "tool_call",
+          tool: block.name ?? "unknown",
+          description: describeToolInput(block.input ?? {}),
+          timestamp: now
+        });
+      }
+    }
+    return out;
+  }
+  return [];
+}
+var PREFERRED_INPUT_FIELDS = [
+  "file_path",
+  "command",
+  "query",
+  "pattern",
+  "path",
+  "url",
+  "question",
+  "answer",
+  "intent",
+  "feedback",
+  "proposal",
+  "blocker_summary",
+  "summary"
+];
+function describeToolInput(input) {
+  for (const k of PREFERRED_INPUT_FIELDS) {
+    const v = input[k];
+    if (typeof v === "string")
+      return v.slice(0, 200);
+  }
+  if (typeof input.name === "string" && typeof input.persona === "string") {
+    return input.name.slice(0, 80);
+  }
+  const keys = Object.keys(input);
+  if (keys.length === 1 && typeof input[keys[0]] === "string") {
+    return input[keys[0]].slice(0, 200);
+  }
+  return JSON.stringify(input).slice(0, 200);
+}
+function parseClaudeMessages(messages, exitCode) {
+  const toolUseNames = new Map;
+  for (const msg of messages) {
+    if (msg.type === STREAM_TYPE.Assistant && Array.isArray(msg.message?.content)) {
+      for (const block of msg.message.content) {
+        if (block.type === BLOCK_TYPE.ToolUse && block.id) {
+          toolUseNames.set(block.id, block.name ?? "unknown");
+        }
+      }
+    }
+  }
+  const transcriptParts = [];
+  let output = "";
+  let sessionId;
+  let costUsd;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cacheCreationTokens = 0;
+  let cacheReadTokens = 0;
+  let model;
+  for (const msg of messages) {
+    if (msg.type === STREAM_TYPE.Assistant && msg.message) {
+      const content = msg.message.content;
+      if (typeof content === "string") {
+        transcriptParts.push(`[assistant] ${content}
+`);
+        output = content;
+      } else if (Array.isArray(content)) {
+        const texts = [];
+        for (const block of content) {
+          if (block.type === BLOCK_TYPE.Text && typeof block.text === "string") {
+            transcriptParts.push(`[assistant] ${block.text}
+`);
+            texts.push(block.text);
+          } else if (block.type === BLOCK_TYPE.ToolUse) {
+            transcriptParts.push(`[tool_call] ${block.name ?? "unknown"}
+`);
+          }
+        }
+        if (texts.length > 0)
+          output = texts.join(`
+`);
+      }
+    } else if (msg.type === STREAM_TYPE.ToolUse) {
+      transcriptParts.push(`[tool_call] ${msg.name ?? "unknown"}
+`);
+    } else if (msg.type === STREAM_TYPE.ToolResult) {
+      const toolName = msg.tool_use_id ? toolUseNames.get(msg.tool_use_id) : undefined;
+      const resultContent = typeof msg.content === "string" ? msg.content.slice(0, 200).replace(/\n/g, " ") : "";
+      if (toolName) {
+        transcriptParts.push(resultContent ? `[tool_result from ${toolName}] ${resultContent}
+` : `[tool_result from ${toolName}]
+`);
+      } else {
+        transcriptParts.push(`[tool_result]
+`);
+      }
+    } else if (msg.type === STREAM_TYPE.Result) {
+      sessionId = msg.session_id;
+      costUsd = msg.total_cost_usd ?? msg.cost_usd;
+      if (msg.result)
+        output = msg.result;
+      if (msg.model)
+        model = msg.model;
+      if (msg.usage) {
+        inputTokens = msg.usage.input_tokens ?? 0;
+        outputTokens = msg.usage.output_tokens ?? 0;
+        cacheCreationTokens = msg.usage.cache_creation_input_tokens ?? 0;
+        cacheReadTokens = msg.usage.cache_read_input_tokens ?? 0;
+      }
+    }
+  }
+  const succeeded = exitCode === 0;
+  const transcript = transcriptParts.join("");
+  const usage = inputTokens || outputTokens || costUsd !== undefined || cacheCreationTokens || cacheReadTokens ? {
+    input_tokens: inputTokens,
+    output_tokens: outputTokens,
+    cache_creation_input_tokens: cacheCreationTokens,
+    cache_read_input_tokens: cacheReadTokens,
+    cost_usd: costUsd ?? 0,
+    model: model ?? "unknown"
+  } : undefined;
+  return {
+    status: succeeded ? "completed" : "failed",
+    output: output || (succeeded ? "Session completed." : `CLI exited with code ${exitCode}`),
+    transcript: transcript || undefined,
+    usage,
+    cli_session_id: sessionId
+  };
+}
+
+// ../core/dist/adapters/claude-code/runtime.js
+var NESTING_GUARD_VARS = [
+  "CLAUDECODE",
+  "CLAUDE_CODE_ENTRYPOINT",
+  "CLAUDE_CODE_SESSION",
+  "CLAUDE_CODE_PARENT_SESSION"
+];
+var ANTHROPIC_AUTH_VARS = [
+  "ANTHROPIC_API_KEY",
+  "ANTHROPIC_AUTH_TOKEN"
+];
+
+class ClaudeCodeRuntime {
+  config;
+  type = "claude";
+  constructor(config = {}) {
+    this.config = config;
+  }
+  async execute(context) {
+    const cwd = context.workspace.path;
+    const mcpConfigPath = join3(cwd, "mcp-config.json");
+    const args = [
+      "--print",
+      "-",
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      "--dangerously-skip-permissions",
+      "--strict-mcp-config",
+      "--mcp-config",
+      mcpConfigPath
+    ];
+    const model = context.model ?? this.config.model;
+    if (model)
+      args.push("--model", model);
+    const maxTurns = context.max_turns ?? this.config.maxTurns;
+    if (maxTurns)
+      args.push("--max-turns", String(maxTurns));
+    if (context.resume_session_id)
+      args.push("--resume", context.resume_session_id);
+    if (context.system_prompt_append.length > 0) {
+      args.push("--append-system-prompt", context.system_prompt_append);
+    }
+    const env = { ...process.env };
+    for (const key of NESTING_GUARD_VARS)
+      delete env[key];
+    for (const key of ANTHROPIC_AUTH_VARS)
+      delete env[key];
+    if (context.env)
+      Object.assign(env, context.env);
+    const messages = [];
+    let pending = "";
+    const handleLine = (line) => {
+      const msg = parseStreamJsonLine(line);
+      if (!msg)
+        return;
+      messages.push(msg);
+      if (context.onStep) {
+        for (const step of extractStepEvents(msg)) {
+          context.onStep(step);
+        }
+      }
+    };
+    const result = await runCliProcess({
+      command: this.config.command ?? "claude",
+      args,
+      cwd,
+      env,
+      stdin: context.intent,
+      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("[ClaudeCodeRuntime] 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 = parseClaudeMessages(messages, result.exitCode);
+    return {
+      ...parsed,
+      process_pid: result.pid ?? undefined,
+      process_group_id: result.process_group_id ?? undefined
+    };
+  }
+  async healthCheck() {
+    try {
+      const result = await runCliProcess({
+        command: this.config.command ?? "claude",
+        args: ["--version"],
+        cwd: tmpdir(),
+        timeoutMs: 5000,
+        graceMs: 0
+      });
+      return { healthy: result.exitCode === 0 };
+    } catch {
+      return {
+        healthy: false,
+        error: `Command not found: ${this.config.command ?? "claude"}`
+      };
+    }
+  }
+  async shutdown() {}
+  skillsDir(workspace) {
+    return join3(workspace.path, ".claude", "skills");
+  }
+}
+
+// ../core/dist/adapters/runtime-registry.js
+function createDefaultRuntimeRegistry() {
+  return {
+    claude: new ClaudeCodeRuntime({})
+  };
+}
+
+// src/api-client.ts
+import WebSocket from "ws";
+
+class ApiClient {
+  cfg;
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  async get(path2) {
+    const res = await fetch(this.url(path2), {
+      headers: { authorization: `Bearer ${this.cfg.daemonToken}` }
+    });
+    if (res.status === 204 || res.status >= 400)
+      return;
+    return await res.json();
+  }
+  async post(path2, body) {
+    const res = await fetch(this.url(path2), {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${this.cfg.daemonToken}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (res.status === 204)
+      return { status: 204, body: undefined };
+    const text = await res.text();
+    if (!text)
+      return { status: res.status, body: undefined };
+    try {
+      return { status: res.status, body: JSON.parse(text) };
+    } catch {
+      return { status: res.status, body: undefined };
+    }
+  }
+  async claim(runtimeId) {
+    const res = await fetch(`${this.url("/runtime/claim")}?runtime_id=${encodeURIComponent(runtimeId)}`, {
+      method: "POST",
+      headers: { authorization: `Bearer ${this.cfg.daemonToken}` }
+    });
+    if (res.status === 204)
+      return;
+    if (res.status >= 400)
+      return;
+    return await res.json();
+  }
+  openWebSocket(runtimeIds) {
+    const wsUrl = this.cfg.apiUrl.replace(/^http/, "ws");
+    const url = `${wsUrl}/runtime/ws?runtime_ids=${runtimeIds.map(encodeURIComponent).join(",")}`;
+    return new WebSocket(url, {
+      headers: { authorization: `Bearer ${this.cfg.daemonToken}` }
+    });
+  }
+  url(path2) {
+    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" }
+  };
+  const ws = await deps.workspaceManager.ensureWorkspace({ agent: syntheticAgent });
+  const runtime = deps.runtime ?? new ClaudeCodeRuntime;
+  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/spawner] /runtime/events POST failed; events dropped:", err instanceof Error ? err.message : String(err));
+    }
+  };
+  const scheduleFlush = () => {
+    if (flushTimer)
+      return;
+    flushTimer = setTimeout(() => {
+      flushTimer = undefined;
+      flush();
+    }, 250);
+  };
+  const onStep = (step) => {
+    buffer.push({
+      session_id: payload.session_id,
+      kind: step.kind,
+      content: step.description,
+      tool_name: step.tool
+    });
+    if (buffer.length >= 16)
+      flush();
+    else
+      scheduleFlush();
+  };
+  let result;
+  let runError;
+  try {
+    result = await runtime.execute({
+      intent: payload.intent,
+      workspace: ws,
+      system_prompt_append: payload.system_prompt_append,
+      model: payload.model,
+      max_turns: payload.max_turns,
+      env: payload.env,
+      resume_session_id: payload.resume_session_id,
+      abort_signal: abortSignal,
+      onStep
+    });
+  } catch (err) {
+    runError = err instanceof Error ? err : new Error(String(err));
+  }
+  if (flushTimer) {
+    clearTimeout(flushTimer);
+    flushTimer = undefined;
+  }
+  await flush();
+  const status = runError ? "failed" : result?.status === "completed" ? "succeeded" : result?.status === "cancelled" ? "cancelled" : "failed";
+  const done = {
+    session_id: payload.session_id,
+    status,
+    cli_session_id: result?.cli_session_id,
+    result_summary: result?.output ?? "",
+    exit_code: status === "succeeded" ? 0 : 1,
+    error: runError?.message,
+    usage: result?.usage
+  };
+  try {
+    await deps.api.post("/runtime/done", done);
+  } catch (err) {
+    console.error("[daemon/spawner] /runtime/done POST failed:", err instanceof Error ? err.message : String(err));
+  }
+}
+
+// src/claimer.ts
+var DEFAULT_POLL_MS = 30000;
+var DEFAULT_HEARTBEAT_MS = 15000;
+var DEFAULT_WS_RECONNECT_MAX_MS = 30000;
+
+class Claimer {
+  cfg;
+  running = false;
+  ws;
+  pollTimer;
+  heartbeatTimer;
+  wsReconnectAttempts = 0;
+  wsReconnectTimer;
+  pollIntervalMs;
+  heartbeatIntervalMs;
+  wsReconnectMaxDelayMs;
+  constructor(cfg) {
+    this.cfg = cfg;
+    this.pollIntervalMs = cfg.pollIntervalMs ?? DEFAULT_POLL_MS;
+    this.heartbeatIntervalMs = cfg.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_MS;
+    this.wsReconnectMaxDelayMs = cfg.wsReconnectMaxDelayMs ?? DEFAULT_WS_RECONNECT_MAX_MS;
+  }
+  start() {
+    if (this.running)
+      return;
+    this.running = true;
+    this.heartbeat();
+    this.heartbeatTimer = setInterval(() => void this.heartbeat(), this.heartbeatIntervalMs);
+    this.pollAll();
+    this.pollTimer = setInterval(() => void this.pollAll(), this.pollIntervalMs);
+    this.connectWs();
+  }
+  async stop() {
+    this.running = false;
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = undefined;
+    }
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = undefined;
+    }
+    if (this.wsReconnectTimer) {
+      clearTimeout(this.wsReconnectTimer);
+      this.wsReconnectTimer = undefined;
+    }
+    if (this.ws) {
+      this.ws.removeAllListeners();
+      this.ws.close();
+      this.ws = undefined;
+    }
+    this.cfg.supervisor.cancelAll();
+  }
+  connectWs() {
+    if (!this.running)
+      return;
+    const ws = this.cfg.api.openWebSocket(this.cfg.runtimeIds);
+    this.ws = ws;
+    ws.on("open", () => {
+      this.wsReconnectAttempts = 0;
+      console.log(`[daemon] connected: ${this.cfg.runtimeIds.length} runtime(s) subscribed`);
+    });
+    ws.on("message", (raw) => {
+      let msg;
+      try {
+        msg = JSON.parse(raw.toString());
+      } catch {
+        return;
+      }
+      if (msg.type === "task_available" && msg.runtime_id) {
+        this.pollRuntime(msg.runtime_id);
+      } else if (msg.type === "cancel" && msg.session_id) {
+        this.cfg.supervisor.cancel(msg.session_id);
+      }
+    });
+    ws.on("close", () => {
+      if (!this.running)
+        return;
+      this.scheduleWsReconnect();
+    });
+    ws.on("error", (err) => {
+      console.warn("[daemon] ws error:", err.message);
+    });
+  }
+  scheduleWsReconnect() {
+    if (!this.running)
+      return;
+    this.wsReconnectAttempts += 1;
+    const delay = Math.min(1000 * Math.pow(2, this.wsReconnectAttempts - 1), this.wsReconnectMaxDelayMs);
+    console.warn(`[daemon] ws disconnected; reconnecting in ${delay}ms`);
+    this.wsReconnectTimer = setTimeout(() => {
+      this.wsReconnectTimer = undefined;
+      this.connectWs();
+    }, delay);
+  }
+  async heartbeat() {
+    if (!this.running)
+      return;
+    try {
+      await this.cfg.api.post("/runtime/heartbeat", {
+        runtime_ids: this.cfg.runtimeIds
+      });
+    } catch (err) {
+      console.warn("[daemon] heartbeat failed:", err instanceof Error ? err.message : String(err));
+    }
+  }
+  async pollAll() {
+    if (!this.running)
+      return;
+    await Promise.all(this.cfg.runtimeIds.map((rid) => this.pollRuntime(rid)));
+  }
+  async pollRuntime(runtimeId) {
+    while (this.running && this.cfg.supervisor.hasCapacity()) {
+      const payload = await this.cfg.api.claim(runtimeId);
+      if (!payload)
+        return;
+      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));
+    }
+  }
+}
+
+// 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";
+function skillsCacheDir() {
+  return join4(homedir3(), ".beevibe", "skills");
+}
+var VERSION_FILE = ".version";
+async function readCachedVersion() {
+  try {
+    return (await fs2.readFile(join4(skillsCacheDir(), VERSION_FILE), "utf8")).trim();
+  } catch {
+    return;
+  }
+}
+async function syncSkillsCache(api) {
+  const cache = skillsCacheDir();
+  const cached = await readCachedVersion();
+  const res = await api.get("/runtime/skills");
+  if (!res) {
+    if (cached)
+      return cache;
+    throw new Error("/runtime/skills returned no body and no local cache");
+  }
+  if (cached === res.version)
+    return cache;
+  await fs2.mkdir(cache, { recursive: true, mode: 448 });
+  for (const dirent of await fs2.readdir(cache, { withFileTypes: true })) {
+    if (!dirent.isDirectory())
+      continue;
+    if (dirent.name === "beevibe" || dirent.name.startsWith("beevibe-")) {
+      await fs2.rm(join4(cache, dirent.name), { recursive: true, force: true });
+    }
+  }
+  for (const skill of res.skills) {
+    const skillDir = join4(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 });
+      await fs2.writeFile(filePath, file.content, { mode: 384 });
+    }
+  }
+  await fs2.writeFile(join4(cache, VERSION_FILE), res.version, { mode: 384 });
+  return cache;
+}
+
+// src/supervisor.ts
+var DEFAULT_MAX_CONCURRENT = 10;
+
+class Supervisor {
+  maxConcurrent;
+  active = new Map;
+  constructor(maxConcurrent = readMaxFromEnv()) {
+    this.maxConcurrent = maxConcurrent;
+  }
+  hasCapacity() {
+    return this.active.size < this.maxConcurrent;
+  }
+  inFlight() {
+    return this.active.size;
+  }
+  start(sessionId) {
+    if (!this.hasCapacity()) {
+      throw new Error("supervisor at capacity");
+    }
+    const ctrl = new AbortController;
+    this.active.set(sessionId, ctrl);
+    return ctrl;
+  }
+  finish(sessionId) {
+    this.active.delete(sessionId);
+  }
+  cancel(sessionId) {
+    const ctrl = this.active.get(sessionId);
+    if (!ctrl)
+      return false;
+    ctrl.abort();
+    return true;
+  }
+  cancelAll() {
+    for (const ctrl of this.active.values())
+      ctrl.abort();
+    this.active.clear();
+  }
+}
+function readMaxFromEnv() {
+  const raw = process.env.BEEVIBE_DAEMON_MAX_CONCURRENT;
+  if (!raw)
+    return DEFAULT_MAX_CONCURRENT;
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n) || n < 1)
+    return DEFAULT_MAX_CONCURRENT;
+  return n;
+}
+
+// src/start.ts
+async function runStart() {
+  const cfg = loadConfig();
+  if (!cfg) {
+    throw new Error("No daemon config found. Run `beevibe-daemon setup --api <url> --user-token <bv_u_…>` first.");
+  }
+  const api = new ApiClient({
+    apiUrl: cfg.api_url,
+    daemonToken: cfg.daemon_token
+  });
+  const skillsSourceDir = await syncSkillsCache(api).catch((err) => {
+    console.warn("[daemon] skills sync failed; continuing without skills:", err instanceof Error ? err.message : String(err));
+    return;
+  });
+  const runtimeRegistry = createDefaultRuntimeRegistry();
+  const workspaceManager = new LocalWorkspaceManager({
+    mcpServerUrl: `${cfg.api_url}/mcp`,
+    runtimeRegistry,
+    skillsSourceDir: skillsSourceDir ?? "/dev/null",
+    workspaceRoot: process.env.WORKSPACE_ROOT
+  });
+  const supervisor = new Supervisor;
+  const claimer = new Claimer({
+    api,
+    supervisor,
+    workspaceManager,
+    runtimeIds: cfg.runtimes.map((r) => r.id)
+  });
+  claimer.start();
+  console.log(`[daemon] started (${cfg.daemon_id} → ${cfg.api_url}, ${cfg.runtimes.length} runtime(s))`);
+  let stopped = false;
+  const stop = async (signal) => {
+    if (stopped)
+      return;
+    stopped = true;
+    console.log(`[daemon] received ${signal}; stopping`);
+    await claimer.stop();
+    process.exit(0);
+  };
+  process.on("SIGINT", () => void stop("SIGINT"));
+  process.on("SIGTERM", () => void stop("SIGTERM"));
+  await new Promise(() => {
+    return;
+  });
+}
+
+// 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 { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { createInterface } from "node:readline/promises";
+var RELEASES_API_URL = "https://api.github.com/repos/beevibe-ai/beevibe/releases/latest";
+var DOWNLOAD_BASE = "https://github.com/beevibe-ai/beevibe/releases/download";
+var FETCH_TIMEOUT_MS = 60000;
+var PLATFORM_ASSETS = {
+  "darwin-arm64": "beevibe-daemon-darwin-arm64",
+  "darwin-x64": "beevibe-daemon-darwin-x64",
+  "linux-x64": "beevibe-daemon-linux-x64",
+  "linux-arm64": "beevibe-daemon-linux-arm64"
+};
+function currentVersion() {
+  return "0.0.1-rc2";
+}
+function isCompiledBinary() {
+  if (!process.versions.bun)
+    return false;
+  return !/(bun|node)(?:\.exe)?$/.test(process.execPath);
+}
+function platformAsset() {
+  return PLATFORM_ASSETS[`${process.platform}-${process.arch}`];
+}
+function compareSemver(a, b) {
+  const norm = (s) => {
+    const parts = s.replace(/^v/, "").split(".").map((p) => Number.parseInt(p, 10) || 0);
+    return [parts[0] ?? 0, parts[1] ?? 0, parts[2] ?? 0];
+  };
+  const [a1, a2, a3] = norm(a);
+  const [b1, b2, b3] = norm(b);
+  if (a1 !== b1)
+    return a1 - b1;
+  if (a2 !== b2)
+    return a2 - b2;
+  return a3 - b3;
+}
+async function fetchLatestRelease() {
+  const res = await fetch(RELEASES_API_URL, {
+    headers: { Accept: "application/vnd.github+json", "User-Agent": "beevibe-daemon-updater" },
+    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+  });
+  if (res.status === 404)
+    return null;
+  if (!res.ok) {
+    throw new Error(`GitHub API returned ${res.status}: ${await res.text()}`);
+  }
+  return await res.json();
+}
+async function downloadChecksum(version, assetName) {
+  const url = `${DOWNLOAD_BASE}/${version}/${assetName}.sha256`;
+  const res = await fetch(url, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+  if (!res.ok)
+    throw new Error(`checksum ${url} failed: ${res.status}`);
+  const text = await res.text();
+  const hex = text.split(/\s+/)[0] ?? "";
+  if (!/^[0-9a-f]{64}$/i.test(hex))
+    throw new Error(`bad checksum format: ${text}`);
+  return hex.toLowerCase();
+}
+async function downloadAndHash(url, destPath) {
+  const res = await fetch(url, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+  if (!res.ok)
+    throw new Error(`download ${url} failed: ${res.status}`);
+  if (!res.body)
+    throw new Error(`download ${url} returned no body`);
+  const hash = createHash("sha256");
+  const source = Readable.fromWeb(res.body);
+  await pipeline(source, async function* (chunks) {
+    for await (const chunk of chunks) {
+      hash.update(chunk);
+      yield chunk;
+    }
+  }, createWriteStream(destPath));
+  return hash.digest("hex");
+}
+async function promptYesNo(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question(`${question} [y/N] `);
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+async function runUpdate(opts = {}) {
+  const current = currentVersion();
+  if (!current) {
+    console.log("Could not determine current daemon version.");
+    console.log("If you installed via npm:  npm update -g @beevibe/daemon");
+    console.log("If you installed from source: git pull && pnpm install && pnpm build");
+    process.exit(2);
+  }
+  if (!isCompiledBinary()) {
+    console.log(`Current version: ${current}`);
+    console.log("This binary was not produced by the standalone build path.");
+    console.log("If you installed via npm:  npm update -g @beevibe/daemon");
+    console.log("If you installed from source: git pull && pnpm install && pnpm build");
+    return;
+  }
+  const asset = platformAsset();
+  if (!asset) {
+    console.error(`Unsupported platform: ${process.platform}/${process.arch}`);
+    console.error("Pre-built binaries are only published for darwin-arm64, darwin-x64, linux-x64, linux-arm64.");
+    process.exit(2);
+  }
+  console.log(`Current version: ${current}`);
+  console.log("Checking for updates…");
+  const release = await fetchLatestRelease();
+  if (!release) {
+    console.log("No releases published yet — nothing to update to.");
+    return;
+  }
+  const latest = release.tag_name;
+  console.log(`Latest version: ${latest}`);
+  if (compareSemver(current, latest) >= 0) {
+    console.log("Already on the latest version.");
+    return;
+  }
+  console.log(`Update available: ${current} → ${latest}`);
+  if (!opts.skipPrompt) {
+    const proceed = await promptYesNo("Install this update now?");
+    if (!proceed) {
+      console.log("Update cancelled.");
+      return;
+    }
+  }
+  const stagingDir = mkdtempSync(join5(tmpdir2(), "beevibe-daemon-update-"));
+  const stagingPath = join5(stagingDir, asset);
+  try {
+    console.log(`Downloading ${asset}…`);
+    const downloadUrl = `${DOWNLOAD_BASE}/${latest}/${asset}`;
+    const [actualSha, expectedSha] = await Promise.all([
+      downloadAndHash(downloadUrl, stagingPath),
+      downloadChecksum(latest, asset)
+    ]);
+    if (actualSha !== expectedSha) {
+      console.error(`Checksum mismatch — refusing to install.`);
+      console.error(`  expected: ${expectedSha}`);
+      console.error(`  actual:   ${actualSha}`);
+      process.exit(3);
+    }
+    chmodSync(stagingPath, 493);
+    try {
+      renameSync(stagingPath, process.execPath);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`Failed to replace ${process.execPath}: ${msg}`);
+      console.error(`The new binary is at ${stagingPath} — install manually if needed.`);
+      return;
+    }
+    console.log(`Updated to ${latest}. Restart the daemon to pick up the new binary.`);
+  } finally {
+    rmSync2(stagingDir, { recursive: true, force: true });
+  }
+}
+
+// src/main.ts
+function parseFlags(argv) {
+  const flags = {};
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    const next = argv[i + 1];
+    if ((arg === "--api" || arg === "-a") && next) {
+      flags.api = next;
+      i += 1;
+    } else if ((arg === "--user-token" || arg === "-t") && next) {
+      flags.userToken = next;
+      i += 1;
+    } else if (arg === "--device-name" && next) {
+      flags.deviceName = next;
+      i += 1;
+    } else if (arg === "--external-id" && next) {
+      flags.externalId = next;
+      i += 1;
+    }
+  }
+  return flags;
+}
+function printHelp() {
+  console.log([
+    "Usage: beevibe-daemon <command> [flags]",
+    "",
+    "Commands:",
+    "  setup    Register this machine with a beevibe api server.",
+    "  start    Run the daemon: claim pending sessions and spawn the CLI.",
+    "  update   Check for and install a newer daemon binary (brew/curl installs).",
+    "",
+    "setup flags:",
+    "  --api, -a <url>            beevibe api base URL (e.g. http://localhost:3000)",
+    "  --user-token, -t <bv_u_…>  human bv_u_ token (one-time, used to mint a bv_d_)",
+    "  --device-name <name>       optional friendly name (defaults to user@hostname)",
+    "  --external-id <id>         optional stable per-machine id (defaults to hostname)",
+    "",
+    "update flags:",
+    "  --yes, -y                  skip the install-this-update prompt"
+  ].join(`
+`));
+}
+async function main() {
+  const [command, ...rest] = process.argv.slice(2);
+  if (!command || command === "--help" || command === "-h") {
+    printHelp();
+    return;
+  }
+  if (command === "setup") {
+    const flags = parseFlags(rest);
+    if (!flags.api || !flags.userToken) {
+      console.error("setup requires --api and --user-token");
+      printHelp();
+      process.exit(2);
+    }
+    const cfg = await runSetup({
+      apiUrl: flags.api,
+      userToken: flags.userToken,
+      deviceName: flags.deviceName,
+      externalId: flags.externalId
+    });
+    console.log(`Registered as ${cfg.daemon_id}`);
+    console.log(`Runtimes: ${cfg.runtimes.map((r) => `${r.cli} (${r.id})`).join(", ")}`);
+    console.log("Config saved to ~/.beevibe/config.json");
+    return;
+  }
+  if (command === "start") {
+    await runStart();
+    return;
+  }
+  if (command === "update") {
+    const skipPrompt = rest.includes("--yes") || rest.includes("-y");
+    await runUpdate({ skipPrompt });
+    return;
+  }
+  console.error(`Unknown command: ${command}`);
+  printHelp();
+  process.exit(2);
+}
+main().catch((err) => {
+  console.error(err instanceof Error ? err.stack ?? err.message : String(err));
+  process.exit(1);
+});