@beevibe/daemon 0.1.5 → 0.1.6

package/README.md

@@ -93,6 +93,29 @@ Each workspace contains `mcp-config.json` (mode `0600`) with `Bearer <bv_a_…>`
 
 Skills cache: `~/.beevibe/skills/`, version-gated via `.version`. Refreshed on every `start`.
 
+## Multi-instance (dev only)
+
+Two daemons can run on one machine, authenticated as two different `bv_u_` accounts, by giving each its own `--config-root`. The api already supports this — the `daemon` table is keyed by `(owner_person_id, external_id)`, so two daemons with the same hostname but different owners coexist as separate rows.
+
+```bash
+# Terminal 1 — account A
+pnpm dev setup --config-root $HOME/.beevibe-A --api http://localhost:3000 --user-token bv_u_A…
+pnpm dev start --config-root $HOME/.beevibe-A
+
+# Terminal 2 — account B
+pnpm dev setup --config-root $HOME/.beevibe-B --api http://localhost:3000 --user-token bv_u_B…
+pnpm dev start --config-root $HOME/.beevibe-B
+```
+
+`BEEVIBE_CONFIG_ROOT` is an equivalent env-var entry point. Each instance writes its own `config.json`, skills cache, and workspaces under the override; defaults are unchanged (`~/.beevibe/...`) when neither the flag nor the env is set.
+
+**Hard restrictions:**
+
+- **Dev/source builds only.** Compiled binaries (brew/curl install path) and the npm-published bundle reject both `--config-root` and `BEEVIBE_CONFIG_ROOT` with exit code 2. The gate is the `__DEV_BUILD__` compile-time define set by `scripts/build-binaries.sh` and `scripts/prepare-publish.sh`, backed by a runtime check in `main.ts`. To run multi-instance, use `pnpm dev` against a source checkout.
+- **`update` operates on the shared binary.** `beevibe-daemon update` rewrites `process.execPath`, which is the same file both instances spawn from. Running `update` from one instance affects the other on its next launch. Acceptable for dev testing of the update flow; the running daemon keeps its open inode on POSIX so it doesn't crash mid-session.
+- **Device name is not auto-suffixed.** Both daemons register as `<user>@<hostname>` in the Runtimes panel by default. Use `--device-name "MBP (account-B)"` at `setup` time if you want them visually distinct.
+- **Same OS user only.** Different OS users on one machine already isolate via `homedir()`; this flag is for running two accounts as the SAME OS user.
+
 ## What it doesn't do
 
 - **No MCP proxy.** The CLI calls `/mcp` directly using the `bv_a_` token in `mcp-config.json`. The daemon's job stops at writing the file and supervising the subprocess.

package/dist/main.js

@@ -1,5 +1,52 @@
 #!/usr/bin/env node
 
+// src/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+var CONFIG_ROOT_ENV = "BEEVIBE_CONFIG_ROOT";
+function isDevBuild() {
+  return false;
+}
+function getConfigRoot(override) {
+  if (override && override.length > 0)
+    return override;
+  const fromEnv = process.env[CONFIG_ROOT_ENV];
+  if (fromEnv && fromEnv.length > 0)
+    return fromEnv;
+  return join(homedir(), ".beevibe");
+}
+function getConfigPath(override) {
+  return join(getConfigRoot(override), "config.json");
+}
+function loadConfig(configRoot) {
+  const path = getConfigPath(configRoot);
+  if (!existsSync(path))
+    return;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch (err) {
+    throw new Error(`Daemon config at ${path} is malformed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function saveConfig(cfg, configRoot) {
+  const path = getConfigPath(configRoot);
+  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  writeFileSync(path, JSON.stringify(cfg, null, 2) + `
+`, { mode: 384 });
+}
+
+// src/logger.ts
+function log(...args) {
+  console.log(new Date().toISOString(), ...args);
+}
+function warn(...args) {
+  console.warn(new Date().toISOString(), ...args);
+}
+function error(...args) {
+  console.error(new Date().toISOString(), ...args);
+}
+
 // src/setup.ts
 import { hostname, userInfo } from "node:os";
 
@@ -202,27 +249,6 @@ var scryptAsync = promisify(scrypt);
 var SCRYPT_N = 16384;
 var SCRYPT_R = 8;
 var SCRYPT_MAXMEM = 128 * SCRYPT_N * SCRYPT_R * 2;
-// 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/detect-clis.ts
 import { execFile } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
@@ -283,10 +309,13 @@ async function runSetup(options) {
     daemon_token: body.daemon_token,
     runtimes: body.runtimes
   };
-  saveConfig(config);
+  saveConfig(config, options.configRoot);
   return config;
 }
 
+// src/start.ts
+import { join as join9 } from "node:path";
+
 // ../core/dist/adapters/local-workspace/manager.js
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
@@ -468,12 +497,14 @@ class LocalWorkspaceManager {
     rmSync(workspace2.path, { recursive: true, force: true });
   }
 }
+var MCP_TOOL_TIMEOUT_MS = 10 * 60000;
 function buildMcpConfig(apiKey, mcpServerUrl) {
   return JSON.stringify({
     mcpServers: {
       beevibe: {
         type: "http",
         url: mcpServerUrl,
+        timeout: MCP_TOOL_TIMEOUT_MS,
         headers: {
           Authorization: `Bearer ${apiKey}`,
           "X-Beevibe-Session": "${BEEVIBE_SESSION_ID}"
@@ -1200,7 +1231,7 @@ class CodexRuntime {
       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")}`);
+      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")}`, "-c", `mcp_servers.beevibe.tool_timeout_sec=${MCP_TOOL_TIMEOUT_MS / 1000}`);
     }
     const args = context.resume_session_id ? [
       ...globalArgs,
@@ -1941,7 +1972,7 @@ async function runRepoAgent(opts) {
     artifacts: []
   };
   const emit = () => opts.on_state?.({ ...state, transcript: state.transcript.slice(), artifacts: state.artifacts.slice() });
-  const log = (kind, text) => {
+  const log2 = (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 });
@@ -1961,7 +1992,7 @@ async function runRepoAgent(opts) {
   };
   let sandbox = null;
   try {
-    log("log", "Creating sandbox container…");
+    log2("log", "Creating sandbox container…");
     state.status = "preparing";
     emit();
     try {
@@ -1970,18 +2001,18 @@ async function runRepoAgent(opts) {
       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…");
+    log2("log", `Sandbox ${sandbox.id} created (image ${sandbox.image}).`);
+    log2("log", "Installing git + curl in the sandbox base image…");
     await prepareBaseEnvironment(sandbox);
-    log("log", "Base environment ready.");
+    log2("log", "Base environment ready.");
     if (opts.input_url) {
       const filename = opts.input_filename ?? "input.bin";
-      log("log", `Fetching input into /sandbox/inputs/${filename}…`);
+      log2("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.");
+      log2("log", "Input file ready.");
     }
     const mcpServerCommand = opts.mcp_server_command ?? defaultMcpServerCommand();
     const mcpConfigPath = join7(sandbox.artifact_dir, "mcp-config.json");
@@ -1998,11 +2029,11 @@ async function runRepoAgent(opts) {
       }
     };
     await writeFile2(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), "utf8");
-    log("log", `MCP config written: ${mcpConfigPath}`);
+    log2("log", `MCP config written: ${mcpConfigPath}`);
     const userPrompt = buildUserPrompt(opts);
     const systemPromptAppend = DEFAULT_PROMPT_HEADER;
     state.status = "running";
-    log("log", "Spawning child claude session…");
+    log2("log", "Spawning child claude session…");
     emit();
     const claudeResult = await runClaude({
       claudeBin: opts.claude_bin ?? "claude",
@@ -2011,18 +2042,18 @@ async function runRepoAgent(opts) {
       userPrompt,
       maxBudgetUsd: opts.max_budget_usd ?? 2,
       timeoutSeconds: opts.max_runtime_seconds ?? 600,
-      onTranscript: (kind, text) => log(kind, text)
+      onTranscript: (kind, text) => log2(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}`);
+      log2("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…");
+    log2("log", "Child claude exited cleanly. Collecting artifacts…");
     state.artifacts = await collectArtifacts(sandbox);
     if (state.artifacts.length === 0) {
       state.status = "blocked";
@@ -2034,7 +2065,7 @@ async function runRepoAgent(opts) {
     emit();
     return state;
   } catch (err) {
-    log("error", err instanceof Error ? err.message : String(err));
+    log2("error", err instanceof Error ? err.message : String(err));
     state.status = "failed";
     state.error = err instanceof Error ? err.message : String(err);
     state.finished_at = nowIso();
@@ -2043,10 +2074,10 @@ async function runRepoAgent(opts) {
   } finally {
     if (sandbox) {
       try {
-        log("log", `Destroying sandbox ${sandbox.id}…`);
+        log2("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.`);
+        log2("log", `Sandbox cleanup note: ${err instanceof Error ? err.message : String(err)}. Run with \`docker ps -a --filter name=bv-run-\` to inspect.`);
       }
     }
   }
@@ -2267,7 +2298,7 @@ async function runRepoDispatch(deps, payload, abortSignal) {
   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}`);
+  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 () => {
@@ -2277,7 +2308,7 @@ async function runRepoDispatch(deps, payload, abortSignal) {
     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));
+      warn("[daemon/repo-run] /runtime/events POST failed:", err instanceof Error ? err.message : String(err));
     }
   };
   const scheduleFlush = () => {
@@ -2374,9 +2405,9 @@ async function runRepoDispatch(deps, payload, abortSignal) {
     }
   };
   if (status === "succeeded") {
-    console.log(`[daemon/repo-run] sess=${payload.session_id} succeeded artifacts=${artifacts.length}`);
+    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(`[daemon/repo-run] sess=${payload.session_id} status=${status}` + (result.error ? `
   error:
     ${result.error.split(`
 `).join(`
@@ -2385,7 +2416,7 @@ async function runRepoDispatch(deps, payload, abortSignal) {
   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));
+    error("[daemon/repo-run] /runtime/done POST failed:", err instanceof Error ? err.message : String(err));
   }
 }
 function mapKind(kind) {
@@ -2417,7 +2448,7 @@ async function runDispatch(deps, payload, abortSignal) {
     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} runtime=${payload.runtime_type} type=${payload.type} cwd=${ws.path}`);
+  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) {
@@ -2432,7 +2463,7 @@ async function runDispatch(deps, payload, abortSignal) {
     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));
+      warn("[daemon/spawner] /runtime/events POST failed; events dropped:", err instanceof Error ? err.message : String(err));
     }
   };
   const scheduleFlush = () => {
@@ -2489,9 +2520,9 @@ async function runDispatch(deps, payload, abortSignal) {
     usage: result?.usage
   };
   if (status === "succeeded") {
-    console.log(`[daemon/spawn] sess=${payload.session_id} exit=0`);
+    log(`[daemon/spawn] sess=${payload.session_id} exit=0`);
   } else {
-    console.error(`[daemon/spawn] sess=${payload.session_id} status=${status} exit=${done.exit_code}` + (errorDetail ? `
+    error(`[daemon/spawn] sess=${payload.session_id} status=${status} exit=${done.exit_code}` + (errorDetail ? `
   error:
     ${errorDetail.split(`
 `).join(`
@@ -2500,7 +2531,7 @@ async function runDispatch(deps, payload, abortSignal) {
   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));
+    error("[daemon/spawner] /runtime/done POST failed:", err instanceof Error ? err.message : String(err));
   }
 }
 
@@ -2563,7 +2594,7 @@ class Claimer {
     this.ws = ws;
     ws.on("open", () => {
       this.wsReconnectAttempts = 0;
-      console.log(`[daemon] connected: ${this.cfg.runtimeIds.length} runtime(s) subscribed`);
+      log(`[daemon] connected: ${this.cfg.runtimeIds.length} runtime(s) subscribed`);
     });
     ws.on("message", (raw) => {
       let msg;
@@ -2584,7 +2615,7 @@ class Claimer {
       this.scheduleWsReconnect();
     });
     ws.on("error", (err) => {
-      console.warn("[daemon] ws error:", err.message);
+      warn("[daemon] ws error:", err.message);
     });
   }
   scheduleWsReconnect() {
@@ -2592,7 +2623,7 @@ class Claimer {
       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`);
+    warn(`[daemon] ws disconnected; reconnecting in ${delay}ms`);
     this.wsReconnectTimer = setTimeout(() => {
       this.wsReconnectTimer = undefined;
       this.connectWs();
@@ -2606,7 +2637,7 @@ class Claimer {
         runtime_ids: this.cfg.runtimeIds
       });
     } catch (err) {
-      console.warn("[daemon] heartbeat failed:", err instanceof Error ? err.message : String(err));
+      warn("[daemon] heartbeat failed:", err instanceof Error ? err.message : String(err));
     }
   }
   async pollAll() {
@@ -2620,40 +2651,39 @@ class Claimer {
       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));
+        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}`);
+      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,
         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));
+      }, payload, ctrl.signal).catch((err) => 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 join8 } from "node:path";
-function skillsCacheDir() {
-  return join8(homedir3(), ".beevibe", "skills");
+function skillsCacheDir(configRoot) {
+  return join8(getConfigRoot(configRoot), "skills");
 }
 var VERSION_FILE = ".version";
-async function readCachedVersion() {
+async function readCachedVersion(configRoot) {
   try {
-    return (await fs2.readFile(join8(skillsCacheDir(), VERSION_FILE), "utf8")).trim();
+    return (await fs2.readFile(join8(skillsCacheDir(configRoot), VERSION_FILE), "utf8")).trim();
   } catch {
     return;
   }
 }
-async function syncSkillsCache(api) {
-  const cache = skillsCacheDir();
-  const cached = await readCachedVersion();
+async function syncSkillsCache(api, configRoot) {
+  const cache = skillsCacheDir(configRoot);
+  const cached = await readCachedVersion(configRoot);
   const res = await api.get("/runtime/skills");
   if (!res) {
     if (cached)
@@ -2733,8 +2763,8 @@ function readMaxFromEnv() {
 }
 
 // src/start.ts
-async function runStart() {
-  const cfg = loadConfig();
+async function runStart(options = {}) {
+  const cfg = loadConfig(options.configRoot);
   if (!cfg) {
     throw new Error("No daemon config found. Run `beevibe-daemon setup --api <url> --user-token <bv_u_…>` first.");
   }
@@ -2742,8 +2772,8 @@ async function runStart() {
     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));
+  const skillsSourceDir = await syncSkillsCache(api, options.configRoot).catch((err) => {
+    warn("[daemon] skills sync failed; continuing without skills:", err instanceof Error ? err.message : String(err));
     return;
   });
   const runtimeRegistry = createDefaultRuntimeRegistry();
@@ -2751,7 +2781,7 @@ async function runStart() {
     mcpServerUrl: `${cfg.api_url}/mcp`,
     runtimeRegistry,
     skillsSourceDir: skillsSourceDir ?? "/dev/null",
-    workspaceRoot: process.env.WORKSPACE_ROOT
+    workspaceRoot: process.env.WORKSPACE_ROOT && process.env.WORKSPACE_ROOT.length > 0 ? process.env.WORKSPACE_ROOT : join9(getConfigRoot(options.configRoot), "workspaces")
   });
   const supervisor = new Supervisor;
   const claimer = new Claimer({
@@ -2762,20 +2792,20 @@ async function runStart() {
     runtimeIds: cfg.runtimes.map((r) => r.id)
   });
   claimer.start();
-  console.log(`[daemon] started (${cfg.daemon_id} → ${cfg.api_url}, ${cfg.runtimes.length} runtime(s))`);
+  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`);
+    log(`[daemon] received ${signal}; stopping`);
     await claimer.stop();
     process.exit(0);
   };
   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));
+    warn("[daemon] unhandledRejection (continuing):", reason instanceof Error ? reason.message : String(reason));
   });
   await new Promise(() => {
     return;
@@ -2783,10 +2813,10 @@ async function runStart() {
 }
 
 // src/sync.ts
-async function runSync() {
-  const config = loadConfig();
+async function runSync(options = {}) {
+  const config = loadConfig(options.configRoot);
   if (!config) {
-    throw new Error(`No daemon config at ${CONFIG_PATH}. Run 'beevibe-daemon setup' first.`);
+    throw new Error(`No daemon config at ${getConfigPath(options.configRoot)}. Run 'beevibe-daemon setup' first.`);
   }
   const detected = await detectClis();
   if (detected.length === 0) {
@@ -2805,7 +2835,7 @@ async function runSync() {
   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);
+  saveConfig(next, options.configRoot);
   return { added, runtimes: body.runtimes };
 }
 
@@ -2813,7 +2843,7 @@ async function runSync() {
 import { createHash } from "node:crypto";
 import { createWriteStream, mkdtempSync, rmSync as rmSync2, chmodSync, renameSync } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { createInterface } from "node:readline/promises";
@@ -2827,7 +2857,7 @@ var PLATFORM_ASSETS = {
   "linux-arm64": "beevibe-daemon-linux-arm64"
 };
 function currentVersion() {
-  return "0.1.5";
+  return "0.1.6";
 }
 function isCompiledBinary() {
   if (!process.versions.bun)
@@ -2901,58 +2931,58 @@ async function promptYesNo(question) {
 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");
+    log("Could not determine current daemon version.");
+    log("If you installed via npm:  npm update -g @beevibe/daemon");
+    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");
+    log(`Current version: ${current}`);
+    log("This binary was not produced by the standalone build path.");
+    log("If you installed via npm:  npm update -g @beevibe/daemon");
+    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.");
+    error(`Unsupported platform: ${process.platform}/${process.arch}`);
+    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…");
+  log(`Current version: ${current}`);
+  log("Checking for updates…");
   const release = await fetchLatestRelease();
   if (!release) {
-    console.log("No releases published yet — nothing to update to.");
+    log("No releases published yet — nothing to update to.");
     return;
   }
   const latest = release.tag_name;
-  console.log(`Latest version: ${latest}`);
+  log(`Latest version: ${latest}`);
   if (compareSemver(current, latest) >= 0) {
-    console.log("Already on the latest version.");
+    log("Already on the latest version.");
     return;
   }
-  console.log(`Update available: ${current} → ${latest}`);
+  log(`Update available: ${current} → ${latest}`);
   if (!opts.skipPrompt) {
     const proceed = await promptYesNo("Install this update now?");
     if (!proceed) {
-      console.log("Update cancelled.");
+      log("Update cancelled.");
       return;
     }
   }
-  const stagingDir = mkdtempSync(join9(tmpdir5(), "beevibe-daemon-update-"));
-  const stagingPath = join9(stagingDir, asset);
+  const stagingDir = mkdtempSync(join10(tmpdir5(), "beevibe-daemon-update-"));
+  const stagingPath = join10(stagingDir, asset);
   try {
-    console.log(`Downloading ${asset}…`);
+    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}`);
+      error(`Checksum mismatch — refusing to install.`);
+      error(`  expected: ${expectedSha}`);
+      error(`  actual:   ${actualSha}`);
       process.exit(3);
     }
     chmodSync(stagingPath, 493);
@@ -2960,11 +2990,11 @@ async function runUpdate(opts = {}) {
       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.`);
+      error(`Failed to replace ${process.execPath}: ${msg}`);
+      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.`);
+    log(`Updated to ${latest}. Restart the daemon to pick up the new binary.`);
   } finally {
     rmSync2(stagingDir, { recursive: true, force: true });
   }
@@ -2988,12 +3018,28 @@ function parseFlags(argv) {
     } else if (arg === "--external-id" && next) {
       flags.externalId = next;
       i += 1;
+    } else if (arg === "--config-root" && next) {
+      flags.configRoot = next;
+      i += 1;
     }
   }
   return flags;
 }
+function resolveConfigRoot(flag) {
+  const env2 = process.env[CONFIG_ROOT_ENV];
+  const hasFlag = flag && flag.length > 0;
+  const hasEnv = env2 && env2.length > 0;
+  if (!hasFlag && !hasEnv)
+    return;
+  if (!isDevBuild()) {
+    const source = hasFlag ? "--config-root" : CONFIG_ROOT_ENV;
+    error(`${source} is a dev-only knob and is not available in this build. ` + `Reinstall via npm/curl without the override, or use a source checkout ` + `(pnpm dev) if you need multi-instance.`);
+    process.exit(2);
+  }
+  return hasFlag ? flag : env2;
+}
 function printHelp() {
-  console.log([
+  log([
     "Usage: beevibe-daemon <command> [flags]",
     "",
     "Commands:",
@@ -3009,7 +3055,13 @@ function printHelp() {
     "  --external-id <id>         optional stable per-machine id (defaults to hostname)",
     "",
     "update flags:",
-    "  --yes, -y                  skip the install-this-update prompt"
+    "  --yes, -y                  skip the install-this-update prompt",
+    "",
+    "dev-only flags (source builds only — rejected in compiled binaries):",
+    "  --config-root <path>       shift the daemon's on-disk root from ~/.beevibe.",
+    "                             Lets two daemons coexist on one machine as",
+    "                             different accounts. Also settable via the",
+    "                             BEEVIBE_CONFIG_ROOT env var."
   ].join(`
 `));
 }
@@ -3019,10 +3071,11 @@ async function main() {
     printHelp();
     return;
   }
+  const flags = parseFlags(rest);
+  const configRoot = resolveConfigRoot(flags.configRoot);
   if (command === "setup") {
-    const flags = parseFlags(rest);
     if (!flags.api || !flags.userToken) {
-      console.error("setup requires --api and --user-token");
+      error("setup requires --api and --user-token");
       printHelp();
       process.exit(2);
     }
@@ -3030,24 +3083,25 @@ async function main() {
       apiUrl: flags.api,
       userToken: flags.userToken,
       deviceName: flags.deviceName,
-      externalId: flags.externalId
+      externalId: flags.externalId,
+      configRoot
     });
-    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");
+    log(`Registered as ${cfg.daemon_id}`);
+    log(`Runtimes: ${cfg.runtimes.map((r) => `${r.cli} (${r.id})`).join(", ")}`);
+    log(`Config saved to ${getConfigPath(configRoot)}`);
     return;
   }
   if (command === "start") {
-    await runStart();
+    await runStart({ configRoot });
     return;
   }
   if (command === "sync") {
-    const result = await runSync();
+    const result = await runSync({ configRoot });
     if (result.added.length === 0) {
-      console.log("No new CLIs detected.");
+      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).");
+      log(`Added ${result.added.length} runtime(s): ${result.added.map((r) => `${r.cli} (${r.id})`).join(", ")}.`);
+      log("Restart the daemon to pick up the new runtime(s).");
     }
     return;
   }
@@ -3056,11 +3110,11 @@ async function main() {
     await runUpdate({ skipPrompt });
     return;
   }
-  console.error(`Unknown command: ${command}`);
+  error(`Unknown command: ${command}`);
   printHelp();
   process.exit(2);
 }
 main().catch((err) => {
-  console.error(err instanceof Error ? err.stack ?? err.message : String(err));
+  error(err instanceof Error ? err.stack ?? err.message : String(err));
   process.exit(1);
 });

package/package.json

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