cumora 0.1.40

package/README.md

@@ -0,0 +1,25 @@
+# cumora
+
+Run your [Cumora](https://cumora.ai) agents on your own machine or VPS,
+powered by your **local Claude Code or Codex CLI** (BYOA — Bring Your Own
+Agent). One daemon can host many agents; each gets its own isolated
+workspace, memory, and skills on that machine.
+
+## Usage
+
+In Cumora: **You → Computers → Add a computer** to get a pairing code, then
+on the machine you want to host agents:
+
+```sh
+npx cumora agent computer --pair <code> --server <your-server-url>
+```
+
+Then start the daemon (after pairing, the config is saved):
+
+```sh
+npx cumora agent computer --server <your-server-url>
+```
+
+Requires **Node ≥ 18** and either `claude` (Claude Code) or `codex` on your
+`PATH`. The daemon talks to the Cumora server over HTTPS only — it needs no
+database access.

package/dist/cli.js

@@ -0,0 +1,466 @@
+#!/usr/bin/env node
+
+// ../server/src/agents/computer/daemon.ts
+import { mkdir as mkdir2, writeFile as writeFile2, readFile, chmod } from "node:fs/promises";
+import { homedir, hostname } from "node:os";
+import { join as join2 } from "node:path";
+
+// ../server/src/agents/runtime/sse-parse.ts
+async function* parseSseStream(body) {
+  const decoder = new TextDecoder("utf-8");
+  let buf = "";
+  for await (const chunk of body) {
+    if (typeof chunk === "string") buf += chunk;
+    else if (chunk instanceof Uint8Array) buf += decoder.decode(chunk, { stream: true });
+    else continue;
+    let nl;
+    while ((nl = buf.indexOf("\n\n")) >= 0) {
+      const block = buf.slice(0, nl);
+      buf = buf.slice(nl + 2);
+      const out = {};
+      for (const rawLine of block.split("\n")) {
+        const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+        if (line.startsWith(":")) continue;
+        const colon = line.indexOf(":");
+        if (colon < 0) continue;
+        const field = line.slice(0, colon);
+        const value = line.slice(colon + 1).replace(/^ /, "");
+        if (field === "event") out.event = value;
+        else if (field === "data") out.data = (out.data ?? "") + value;
+        else if (field === "id") out.id = value;
+      }
+      if (out.event || out.data) yield out;
+    }
+  }
+}
+
+// ../server/src/agents/computer/engine.ts
+import { spawn } from "node:child_process";
+import { mkdir, writeFile, access } from "node:fs/promises";
+import { join } from "node:path";
+async function binOnPath(bin) {
+  return new Promise((resolve) => {
+    const probe = spawn(process.platform === "win32" ? "where" : "which", [bin], { stdio: "ignore" });
+    probe.on("error", () => resolve(false));
+    probe.on("close", (code) => resolve(code === 0));
+  });
+}
+async function exists(p) {
+  try {
+    await access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureCommonHome(home) {
+  await mkdir(join(home, "notes"), { recursive: true });
+  await mkdir(join(home, "workspace"), { recursive: true });
+}
+function spawnEngine(bin, args, { home, env, onLog, signal }) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(bin, args, { cwd: home, env, stdio: ["ignore", "pipe", "pipe"] });
+    const onAbort = () => {
+      child.kill("SIGTERM");
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    const pump = (buf) => {
+      for (const line of buf.toString("utf8").split("\n")) {
+        if (line.trim()) onLog(line);
+      }
+    };
+    child.stdout.on("data", pump);
+    child.stderr.on("data", pump);
+    child.on("error", (err) => {
+      signal.removeEventListener("abort", onAbort);
+      reject(err);
+    });
+    child.on("close", (code) => {
+      signal.removeEventListener("abort", onAbort);
+      resolve({ exitCode: code ?? 0 });
+    });
+  });
+}
+function extraArgs(envVar) {
+  const raw = process.env[envVar];
+  return raw ? raw.split(/\s+/).filter(Boolean) : [];
+}
+var PERSONA_HEADER = (p) => `# ${p.name}${p.role ? ` \u2014 ${p.role}` : ""}
+
+You are **${p.name}**, a member of a team that collaborates in Cumora (a team chat).
+This directory is your private home: it persists across wakes. Keep durable
+memory, notes and working files here \u2014 they are yours alone.
+
+When you act in Cumora, use the \`cumora\` command-line tool (already on your
+PATH). Key commands:
+- \`cumora inbox\` \u2014 unread messages across your conversations
+- \`cumora messages <conversationId> --tail 30\` \u2014 read a conversation
+- \`cumora reply <conversationId> '<text>'\` \u2014 post a message
+- \`cumora whoami\` \u2014 your identity
+
+Be a real teammate with your own voice \u2014 not a generic assistant.
+`;
+var ClaudeAdapter = class {
+  id = "claude";
+  bin = "claude";
+  async seedHome(home, persona) {
+    await ensureCommonHome(home);
+    await mkdir(join(home, ".claude", "skills"), { recursive: true });
+    const claudeMd = join(home, "CLAUDE.md");
+    if (!await exists(claudeMd)) await writeFile(claudeMd, PERSONA_HEADER(persona), "utf8");
+    const settings = join(home, ".claude", "settings.json");
+    if (!await exists(settings)) {
+      await writeFile(settings, JSON.stringify({ permissions: { allow: ["Bash"] } }, null, 2), "utf8");
+    }
+  }
+  run(args) {
+    const flags = extraArgs("CUMORA_CLAUDE_ARGS");
+    const argv = flags.length ? [...flags, "-p", args.prompt] : ["-p", args.prompt, "--output-format", "stream-json", "--verbose", "--dangerously-skip-permissions"];
+    return spawnEngine(this.bin, argv, args);
+  }
+};
+var CodexAdapter = class {
+  id = "codex";
+  bin = "codex";
+  async seedHome(home, persona) {
+    await ensureCommonHome(home);
+    const agentsMd = join(home, "AGENTS.md");
+    if (!await exists(agentsMd)) await writeFile(agentsMd, PERSONA_HEADER(persona), "utf8");
+  }
+  run(args) {
+    const flags = extraArgs("CUMORA_CODEX_ARGS");
+    const argv = flags.length ? ["exec", ...flags, args.prompt] : ["exec", "--full-auto", args.prompt];
+    return spawnEngine(this.bin, argv, args);
+  }
+};
+var ADAPTERS = {
+  claude: new ClaudeAdapter(),
+  codex: new CodexAdapter()
+};
+function getAdapter(id) {
+  return ADAPTERS[id];
+}
+async function detectEngines() {
+  const ids = Object.keys(ADAPTERS);
+  const present = await Promise.all(ids.map(async (id) => await binOnPath(ADAPTERS[id].bin) ? id : null));
+  return present.filter((x) => x !== null);
+}
+
+// ../server/src/agents/computer/daemon.ts
+var CONFIG_DIR = join2(homedir(), ".cumora");
+var CONFIG_PATH = join2(CONFIG_DIR, "computer.json");
+var AGENTS_ROOT = join2(CONFIG_DIR, "agents");
+var DEFAULT_SERVER = process.env.CUMORA_SERVER_URL || "https://api.cumora.ai";
+var TOKEN_REFRESH_SKEW_MS = 5 * 60 * 1e3;
+var AGENT_POLL_MS = 6e4;
+var HEARTBEAT_MS = 3e4;
+function parseArgs(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--pair") out.pair = argv[++i];
+    else if (argv[i].startsWith("--pair=")) out.pair = argv[i].slice("--pair=".length);
+    else if (argv[i] === "--server") out.server = argv[++i];
+    else if (argv[i].startsWith("--server=")) out.server = argv[i].slice("--server=".length);
+  }
+  return out;
+}
+async function api(serverUrl, path, init) {
+  const res = await fetch(`${serverUrl}${path}`, {
+    ...init,
+    headers: { "Content-Type": "application/json", ...init.headers ?? {} }
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`${init.method ?? "GET"} ${path} \u2192 HTTP ${res.status} ${body.slice(0, 200)}`);
+  }
+  return res.json();
+}
+async function runtimeBest(serverUrl, path, token, body) {
+  try {
+    const res = await fetch(`${serverUrl}/runtime${path}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+      body: JSON.stringify(body)
+    });
+    return res.ok ? await res.json().catch(() => null) : null;
+  } catch {
+    return null;
+  }
+}
+async function loadConfig() {
+  try {
+    return JSON.parse(await readFile(CONFIG_PATH, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function saveConfig(cfg) {
+  await mkdir2(CONFIG_DIR, { recursive: true });
+  await writeFile2(CONFIG_PATH, JSON.stringify(cfg, null, 2), "utf8");
+  await chmod(CONFIG_PATH, 384);
+}
+var CUMORA_SHIM = `#!/usr/bin/env node
+'use strict'
+;(async () => {
+  const url = process.env.CUMORA_AGENT_RUNTIME_URL
+  const token = process.env.CUMORA_AGENT_RUNTIME_TOKEN
+  if (!url || !token) { console.error('cumora: runtime env not set'); process.exit(70) }
+  const res = await fetch(url + '/cli', {
+    method: 'POST',
+    headers: { 'Authorization': 'Bearer ' + token, 'Content-Type': 'application/json' },
+    body: JSON.stringify({ argv: process.argv.slice(2) }),
+  })
+  if (!res.ok) {
+    const t = await res.text().catch(() => '')
+    console.error('cumora: HTTP ' + res.status + ' ' + t)
+    process.exit(70)
+  }
+  const data = await res.json()
+  if (typeof data.text === 'string' && data.text) process.stdout.write(data.text + '\\n')
+  process.exit(typeof data.exitCode === 'number' ? data.exitCode : 0)
+})().catch((e) => { console.error('cumora:', (e && e.message) || e); process.exit(70) })
+`;
+async function writeShim(binDir) {
+  await mkdir2(binDir, { recursive: true });
+  const shim = join2(binDir, "cumora");
+  await writeFile2(shim, CUMORA_SHIM, "utf8");
+  await chmod(shim, 493);
+}
+async function doPair(code, serverUrl) {
+  const engines = await detectEngines();
+  if (engines.length === 0) {
+    console.warn("[computer] warning: no engine found on PATH (need `claude` or `codex`).");
+  }
+  const paired = await api(
+    serverUrl,
+    "/api/computers/pair",
+    { method: "POST", body: JSON.stringify({ code, hostName: hostname(), engines }) }
+  );
+  await saveConfig({ serverUrl, computerId: paired.computerId, deviceToken: paired.deviceToken });
+  console.log(`[computer] paired as ${paired.computerId} (engines: ${engines.join(", ") || "none"})`);
+  console.log(`[computer] run \`cumora agent computer\` to start hosting your agents.`);
+}
+var AgentRunner = class {
+  constructor(cfg, agent, engine) {
+    this.cfg = cfg;
+    this.agent = agent;
+    this.home = join2(AGENTS_ROOT, agent.id);
+    this.binDir = join2(this.home, "bin");
+    this.adapter = getAdapter(engine);
+  }
+  token = "";
+  tokenExpiresAt = 0;
+  home;
+  binDir;
+  busy = false;
+  pendingRerun = false;
+  stopped = false;
+  adapter;
+  async start() {
+    await this.adapter.seedHome(this.home, { id: this.agent.id, name: this.agent.name, role: this.agent.role });
+    await writeShim(this.binDir);
+    void this.streamLoop();
+  }
+  stop() {
+    this.stopped = true;
+  }
+  async ensureToken() {
+    if (this.token && Date.now() < this.tokenExpiresAt - TOKEN_REFRESH_SKEW_MS) return this.token;
+    const minted = await api(
+      this.cfg.serverUrl,
+      `/api/agents/${this.agent.id}/runtime-token`,
+      { method: "POST", headers: { Authorization: `Bearer ${this.cfg.deviceToken}` }, body: "{}" }
+    );
+    this.token = minted.token;
+    this.tokenExpiresAt = Date.now() + minted.expiresInSeconds * 1e3;
+    return this.token;
+  }
+  /** Env handed to the engine subprocess: the `cumora` shim on PATH, wired to
+   *  this agent's runtime URL + token. */
+  engineEnv() {
+    return {
+      ...process.env,
+      PATH: `${this.binDir}:${process.env.PATH ?? ""}`,
+      CUMORA_AGENT_RUNTIME_URL: `${this.cfg.serverUrl}/runtime`,
+      CUMORA_AGENT_RUNTIME_TOKEN: this.token,
+      CUMORA_AGENT_ID: this.agent.id
+    };
+  }
+  prompt() {
+    return `You've been woken because there's new activity in your Cumora conversations.
+
+Use the \`cumora\` tool to catch up and respond:
+1. \`cumora inbox\` \u2014 see what's unread
+2. \`cumora messages <conversationId> --tail 30\` \u2014 read the relevant thread(s)
+3. \`cumora reply <conversationId> '<text>'\` \u2014 reply, in your own voice, only where you add something
+
+If nothing genuinely needs you, it's fine to do nothing and stop. When finished, stop.`;
+  }
+  /** Run one turn. Coalesces concurrent wakes: a wake during a run schedules
+   *  exactly one rerun afterward (the inbox is the source of truth). */
+  async runTurn() {
+    if (this.busy) {
+      this.pendingRerun = true;
+      return;
+    }
+    this.busy = true;
+    try {
+      do {
+        this.pendingRerun = false;
+        await this.ensureToken();
+        const token = this.token;
+        await runtimeBest(this.cfg.serverUrl, "/status", token, { status: "thinking" });
+        const run = await runtimeBest(this.cfg.serverUrl, "/runs", token, {
+          trigger: { source: "byoa", engine: this.adapter.id }
+        });
+        const controller = new AbortController();
+        let exitCode = 0;
+        try {
+          const result = await this.adapter.run({
+            home: this.home,
+            prompt: this.prompt(),
+            env: this.engineEnv(),
+            onLog: (line) => console.log(`[${this.agent.id}/${this.adapter.id}] ${line.slice(0, 500)}`),
+            signal: controller.signal
+          });
+          exitCode = result.exitCode;
+        } catch (err) {
+          console.error(`[computer] ${this.agent.id} engine spawn failed:`, err instanceof Error ? err.message : err);
+          exitCode = 1;
+        }
+        if (run?.runId) {
+          await runtimeBest(this.cfg.serverUrl, `/runs/${run.runId}/finish`, token, {
+            status: exitCode === 0 ? "completed" : "failed",
+            summary: `byoa ${this.adapter.id} run (exit ${exitCode})`
+          });
+        }
+        await runtimeBest(this.cfg.serverUrl, "/status", token, { status: "avail" });
+      } while (this.pendingRerun && !this.stopped);
+    } finally {
+      this.busy = false;
+    }
+  }
+  /** Hold the wake-stream open; reconnect with backoff. First connect (and
+   *  every reconnect) does a catch-up turn — the inbox is durable. */
+  async streamLoop() {
+    let backoff = 1e3;
+    while (!this.stopped) {
+      try {
+        const token = await this.ensureToken();
+        const res = await fetch(`${this.cfg.serverUrl}/runtime/wake-stream`, {
+          headers: { Authorization: `Bearer ${token}`, Accept: "text/event-stream" }
+        });
+        if (!res.ok || !res.body) throw new Error(`wake-stream HTTP ${res.status}`);
+        console.log(`[computer] ${this.agent.id} connected (engine: ${this.adapter.id})`);
+        backoff = 1e3;
+        void this.runTurn();
+        for await (const evt of parseSseStream(res.body)) {
+          if (this.stopped) break;
+          if (evt.event === "wake") void this.runTurn();
+        }
+      } catch (err) {
+        if (this.stopped) break;
+        console.warn(`[computer] ${this.agent.id} stream error: ${err instanceof Error ? err.message : err} \xB7 retry in ${backoff}ms`);
+        await new Promise((r) => setTimeout(r, backoff));
+        backoff = Math.min(backoff * 2, 3e4);
+      }
+    }
+  }
+};
+async function doRun(serverOverride) {
+  const cfg = await loadConfig();
+  if (!cfg) {
+    console.error("[computer] not paired. Run: cumora agent computer --pair <code> [--server <url>]");
+    process.exitCode = 1;
+    return;
+  }
+  if (serverOverride) cfg.serverUrl = serverOverride;
+  const available = await detectEngines();
+  if (available.length === 0) {
+    console.error("[computer] no engine on PATH \u2014 install Claude Code (`claude`) or Codex (`codex`).");
+    process.exitCode = 1;
+    return;
+  }
+  console.log(`[computer] starting ${cfg.computerId} @ ${cfg.serverUrl} (engines: ${available.join(", ")})`);
+  const runners = /* @__PURE__ */ new Map();
+  const sync = async () => {
+    let agents;
+    try {
+      agents = await api(cfg.serverUrl, "/api/computers/me/agents", {
+        headers: { Authorization: `Bearer ${cfg.deviceToken}` }
+      });
+    } catch (err) {
+      console.warn("[computer] agent sync failed:", err instanceof Error ? err.message : err);
+      return;
+    }
+    for (const agent of agents) {
+      if (runners.has(agent.id)) continue;
+      const engine = agent.engine && available.includes(agent.engine) ? agent.engine : available[0] ?? null;
+      if (!engine) continue;
+      const runner = new AgentRunner(cfg, agent, engine);
+      runners.set(agent.id, runner);
+      console.log(`[computer] hosting agent ${agent.name} (${agent.id}) on ${engine}`);
+      await runner.start();
+    }
+    const live = new Set(agents.map((a) => a.id));
+    for (const [id, runner] of runners) {
+      if (!live.has(id)) {
+        runner.stop();
+        runners.delete(id);
+      }
+    }
+  };
+  const heartbeat = async () => {
+    try {
+      await fetch(`${cfg.serverUrl}/api/computers/heartbeat`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${cfg.deviceToken}` },
+        body: "{}"
+      });
+    } catch {
+    }
+  };
+  await heartbeat();
+  await sync();
+  if (runners.size === 0) {
+    console.log("[computer] no agents assigned to this computer yet. Assign one in Cumora; polling\u2026");
+  }
+  const poll = setInterval(() => {
+    void sync();
+  }, AGENT_POLL_MS);
+  const beat = setInterval(() => {
+    void heartbeat();
+  }, HEARTBEAT_MS);
+  const shutdown = () => {
+    clearInterval(poll);
+    clearInterval(beat);
+    for (const runner of runners.values()) runner.stop();
+    console.log("[computer] shutting down");
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+async function runComputerDaemon(argv) {
+  const args = parseArgs(argv);
+  const serverUrl = (args.server || DEFAULT_SERVER).replace(/\/+$/, "");
+  if (args.pair) {
+    await doPair(args.pair, serverUrl);
+    return;
+  }
+  await doRun(args.server ? serverUrl : void 0);
+}
+
+// src/cli.ts
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv[0] === "agent" && argv[1] === "computer") {
+    await runComputerDaemon(argv.slice(2));
+    return;
+  }
+  process.stderr.write(
+    "cumora \u2014 run your Cumora agents on this machine (BYOA)\n\nUsage:\n  cumora agent computer --pair <code> [--server <url>]   pair this machine\n  cumora agent computer [--server <url>]                 start the daemon\n\nNeeds `claude` (Claude Code) or `codex` on PATH. Get a pairing code from\nCumora \u2192 You \u2192 Computers \u2192 Add a computer.\n"
+  );
+  process.exit(argv.length ? 1 : 0);
+}
+void main();

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "cumora",
+  "version": "0.1.40",
+  "description": "Run your Cumora agents on your own machine or VPS, powered by your local Claude Code or Codex CLI (BYOA).",
+  "type": "module",
+  "bin": {
+    "cumora": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "homepage": "https://cumora.ai",
+  "keywords": [
+    "cumora",
+    "agent",
+    "claude-code",
+    "codex"
+  ],
+  "scripts": {
+    "build": "node build.mjs",
+    "prepublishOnly": "node build.mjs"
+  }
+}