cumora 0.1.45 → 0.1.47

package/dist/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 // ../server/src/agents/computer/daemon.ts
+import { createHash } from "node:crypto";
 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";
@@ -56,8 +57,37 @@ async function exists(p) {
   }
 }
 async function ensureCommonHome(home) {
+  await mkdir(join(home, "memory"), { recursive: true });
   await mkdir(join(home, "notes"), { recursive: true });
   await mkdir(join(home, "workspace"), { recursive: true });
+  const memoryIndex = join(home, "memory", "MEMORY.md");
+  if (!await exists(memoryIndex)) {
+    await writeFile(
+      memoryIndex,
+      "# Memory index\n\nOne line per durable fact, pointing at the file that holds it:\n`- [Title](file.md) \u2014 one-line hook`\n\nWrite the fact itself in its own `memory/<topic>.md` file; keep this index short.\n",
+      "utf8"
+    );
+  }
+}
+var MAX_FAILURE_LINES = 30;
+var MAX_FAILURE_CHARS = 4e3;
+var ANSI_RE = /\x1B\[[0-?]*[ -/]*[@-~]/g;
+function cleanLine(line) {
+  return line.replace(ANSI_RE, "").replace(/\r/g, "").trim();
+}
+function pushTail(lines, line) {
+  if (!line) return;
+  lines.push(line);
+  if (lines.length > MAX_FAILURE_LINES) lines.shift();
+}
+function failurePreview(args) {
+  const parts = [];
+  if (args.stderr.length > 0) parts.push(args.stderr.join("\n"));
+  if (args.stdout.length > 0) parts.push(args.stdout.join("\n"));
+  const detail = parts.join("\n").trim();
+  const prefix = args.signalName ? `process terminated by ${args.signalName}` : `process exited with code ${args.exitCode}`;
+  return detail ? `${prefix}
+${detail}`.slice(0, MAX_FAILURE_CHARS) : prefix;
 }
 function spawnEngine(bin, args, { home, env, onLog, signal }) {
   return new Promise((resolve, reject) => {
@@ -66,20 +96,29 @@ function spawnEngine(bin, args, { home, env, onLog, signal }) {
       child.kill("SIGTERM");
     };
     signal.addEventListener("abort", onAbort, { once: true });
-    const pump = (buf) => {
+    const stderrTail = [];
+    const stdoutTail = [];
+    const pump = (stream, buf) => {
       for (const line of buf.toString("utf8").split("\n")) {
-        if (line.trim()) onLog(line);
+        const cleaned = cleanLine(line);
+        if (!cleaned) continue;
+        pushTail(stream === "stderr" ? stderrTail : stdoutTail, cleaned);
+        onLog(cleaned);
       }
     };
-    child.stdout.on("data", pump);
-    child.stderr.on("data", pump);
+    child.stdout.on("data", (buf) => pump("stdout", buf));
+    child.stderr.on("data", (buf) => pump("stderr", buf));
     child.on("error", (err) => {
       signal.removeEventListener("abort", onAbort);
       reject(err);
     });
-    child.on("close", (code) => {
+    child.on("close", (code, signalName) => {
       signal.removeEventListener("abort", onAbort);
-      resolve({ exitCode: code ?? 0 });
+      const exitCode = code ?? (signalName ? 128 : 1);
+      resolve({
+        exitCode,
+        error: exitCode === 0 ? void 0 : failurePreview({ exitCode, signalName, stderr: stderrTail, stdout: stdoutTail })
+      });
     });
   });
 }
@@ -92,7 +131,13 @@ 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 and your working directory \u2014 it persists
 across wakes and is yours alone. Its layout:
-- \`CLAUDE.md\` (this file) + \`memory/\` + \`notes/\` \u2014 your durable memory and notes.
+- \`CLAUDE.md\` (this file) \u2014 always loaded each wake; keep it short.
+- \`memory/\` \u2014 your durable memory. There is NO hidden memory store: to remember
+  something across wakes you MUST write it to a file here (e.g. \`memory/<topic>.md\`)
+  and add a one-line pointer in \`memory/MEMORY.md\`. Saying "I'll remember" without
+  writing a file means you will NOT remember. At the start of each wake, read
+  \`memory/MEMORY.md\` (and the files it points to) to recall what you know.
+- \`notes/\` \u2014 scratch notes and drafts.
 - \`.claude/skills/\` \u2014 your skills.
 - \`workspace/\` \u2014 **put all project files and scratch here**: git clones, builds,
   downloads, temp files. Always \`cd workspace\` (or use \`workspace/\u2026\` paths) for
@@ -177,6 +222,7 @@ 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;
+var MAX_VISIBLE_ERROR_CHARS = 900;
 function parseArgs(argv) {
   const out = {};
   for (let i = 0; i < argv.length; i++) {
@@ -210,6 +256,49 @@ async function runtimeBest(serverUrl, path, token, body) {
     return null;
   }
 }
+async function runtimeGet(serverUrl, path, token) {
+  try {
+    const res = await fetch(`${serverUrl}/runtime${path}`, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    return res.ok ? await res.json().catch(() => null) : null;
+  } catch {
+    return null;
+  }
+}
+function hashText(text) {
+  return createHash("sha1").update(text).digest("hex").slice(0, 12);
+}
+function conciseError(text) {
+  return text.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "").replace(/\r/g, "").trim().slice(0, MAX_VISIBLE_ERROR_CHARS);
+}
+function authFailureHint(engine, detail) {
+  if (!/(auth|login|token|quota|credit|billing|subscription|rate limit|usage limit|api key)/i.test(detail)) {
+    return "Check the daemon terminal for details, then wake the agent again.";
+  }
+  if (engine === "claude") {
+    return "Open Claude Code on that computer and sign in, refresh quota, or add credits, then wake the agent again.";
+  }
+  return "Open Codex on that computer and refresh its login or quota, then wake the agent again.";
+}
+function missingEngineMessage() {
+  return [
+    "no supported local agent engine found on PATH",
+    "",
+    "Install and sign in to at least one of:",
+    "  - Claude Code: install the `claude` CLI, then run `claude` once to sign in",
+    "  - Codex: install the `codex` CLI, then run `codex` once to sign in",
+    "",
+    "After that, rerun:",
+    "  npx cumora agent computer --pair <code>"
+  ].join("\n");
+}
+async function requireLocalEngine() {
+  const engines = await detectEngines();
+  if (engines.length === 0) throw new Error(missingEngineMessage());
+  return engines;
+}
 async function loadConfig() {
   try {
     return JSON.parse(await readFile(CONFIG_PATH, "utf8"));
@@ -265,10 +354,7 @@ async function detectHostName() {
   return base || "My computer";
 }
 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 engines = await requireLocalEngine();
   const paired = await api(
     serverUrl,
     "/api/computers/pair",
@@ -332,16 +418,93 @@ var AgentRunner = class {
       CUMORA_AGENT_ID: this.agent.id
     };
   }
-  prompt() {
+  visibleEngineError(exitCode, detail) {
+    const raw = conciseError(detail || `process exited with code ${exitCode}`);
+    const redacted = raw.split(this.home).join("<agent home>").split(homedir()).join("~");
+    return `local ${this.adapter.id} failed (exit ${exitCode}): ${redacted}`;
+  }
+  async publishEngineFailure(args) {
+    if (args.runId) {
+      await runtimeBest(this.cfg.serverUrl, "/events", args.token, {
+        runId: args.runId,
+        kind: "engine.failed",
+        level: "error",
+        title: `${this.adapter.id} exited ${args.exitCode}`,
+        data: { error: args.error },
+        stage: "failed"
+      });
+    }
+    const hint = authFailureHint(this.adapter.id, args.error);
+    const conversationIds = await this.failureConversationIds(args.token, args.conversationId);
+    await Promise.all(conversationIds.map((conversationId) => runtimeBest(this.cfg.serverUrl, "/notices", args.token, {
+      conversationId,
+      agentId: this.agent.id,
+      noticeKind: "byoa_engine_failed",
+      text: `${this.agent.name} could not run on local ${this.adapter.id}: ${args.error}
+${hint}`,
+      dedupeKey: `byoa_engine_failed:${this.agent.id}:${conversationId}:${hashText(args.error)}`,
+      dedupeTtlSec: 900
+    })));
+  }
+  async failureConversationIds(token, conversationId) {
+    if (conversationId) return [conversationId];
+    const inbox = await runtimeGet(this.cfg.serverUrl, "/inbox", token);
+    const ids = /* @__PURE__ */ new Set();
+    for (const row of inbox?.rows ?? []) {
+      if (typeof row.conversation_id === "string" && row.conversation_id) ids.add(row.conversation_id);
+      if (ids.size >= 5) break;
+    }
+    return [...ids];
+  }
+  /** Preload the memory index (memory/MEMORY.md) so it's ALWAYS in the wake
+   *  prompt — the lightweight BYOA analog of the cloud agent's RAG memory
+   *  preload. We inject only the small index; the agent opens detail files on
+   *  demand. Capped so a runaway index can't blow up the prompt. */
+  async memoryDigest() {
+    try {
+      const txt = (await readFile(join2(this.home, "memory", "MEMORY.md"), "utf8")).trim();
+      if (!txt) return "";
+      return txt.length > 4e3 ? `${txt.slice(0, 4e3)}
+\u2026(truncated \u2014 cat the file for the rest)` : txt;
+    } catch {
+      return "";
+    }
+  }
+  async inboxTriage(token) {
+    return runtimeGet(this.cfg.serverUrl, "/inbox-triage", token);
+  }
+  formatTriageNote(triage) {
+    if (!triage) return "";
+    const note = typeof triage?.promptNote === "string" ? triage.promptNote.trim() : "";
+    if (!note) return "";
+    const state = triage.actionable === false ? "not relevant" : "relevant";
+    const source = typeof triage.source === "string" ? triage.source : "server";
+    const reason = typeof triage.reason === "string" && triage.reason.trim() ? `
+Reason: ${triage.reason.trim().slice(0, 500)}` : "";
+    return `Small-brain inbox triage (${state}, ${source}): ${note}${reason}`;
+  }
+  prompt(memoryDigest, triageNote) {
     return `You've been woken because there's new activity in your Cumora conversations.
 
-Use the \`cumora\` tool to catch up and respond:
+` + (triageNote ? `${triageNote}
+
+` : ``) + `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
+3. \`cumora glance <conversationId>\` \u2014 in group threads, read the room right before replying
+4. \`cumora reply <conversationId> '<text>'\` \u2014 reply in your own voice
+
+` + (memoryDigest ? `Your memory index (\`memory/MEMORY.md\`) \u2014 consult before replying; \`cat memory/<file>\` for any detail it points to:
+${memoryDigest}
+
+` : ``) + `Memory is your ONLY durable store. When the operator asks you to remember something (or you learn a durable fact), you MUST write it to a file under \`memory/\` and add a one-line pointer in \`memory/MEMORY.md\` \u2014 actually run the write. Saying "got it, I'll remember" does NOT persist anything.
 
 Mentions: to notify or address a specific teammate, write @<their-id> using their participant id (the short id shown in \`cumora messages\` and \`cumora participants\`), NOT their display name. "@Alex P" does nothing; "@alex-3f9a" actually pings them. Run \`cumora participants\` if you need to look up an id.
 
+When a HUMAN says \`@all\` in a group conversation, they addressed YOU too. Do not silently ack an @all just because it is simple. If it is a greeting like "hello @all" or "hi @all", reply briefly as yourself. If it asks every agent to introduce themselves, vote, count, or each give an answer, you should answer your part. Before replying in a group, run \`cumora glance <conversationId>\` so you do not duplicate a peer's identical answer.
+
+Concrete task handoff: if the human asks for one concrete deliverable in a group (generate images, draft the email, summarize the thread, make the chart, fix X) and another teammate has clearly claimed or is already executing that exact task, stay quiet unless you have been specifically named or the result lands and needs your specific missing contribution. Do not add side commentary while a teammate is working.
+
 Know when to stay quiet \u2014 this is how teams avoid endless back-and-forth:
 - Read the WHOLE thread first, including your own past replies. If you've already made your point, don't repeat it. Saying nothing is better than echoing.
 - Only reply where you genuinely add something the thread doesn't already have. Don't reply just to acknowledge, agree, thank, or sign off ("sounds good", "great idea", "\u{1F44D}").
@@ -367,24 +530,43 @@ If nothing genuinely needs you, it's fine to do nothing and stop. When finished,
         const token = this.token;
         const convo = this.lastWakeConvo;
         this.lastWakeConvo = null;
+        const triage = await this.inboxTriage(token);
+        if (triage?.actionable === false) {
+          const reason = typeof triage.reason === "string" ? triage.reason : "not relevant";
+          console.log(`[computer] ${this.agent.id} skipped by small-brain inbox triage: ${reason}`);
+          await runtimeBest(this.cfg.serverUrl, "/status", token, { status: "avail" });
+          continue;
+        }
         await runtimeBest(this.cfg.serverUrl, "/status", token, { status: "thinking" });
         let typingTimer;
         if (convo) {
           const ping = () => {
             void runtimeBest(this.cfg.serverUrl, "/typing", token, { conversationId: convo, done: false });
           };
+          const thinkingPing = () => {
+            void runtimeBest(this.cfg.serverUrl, "/thinking/mark", token, { conversationIds: [convo], ttlSec: 60 });
+          };
           ping();
-          typingTimer = setInterval(ping, 6e3);
+          thinkingPing();
+          typingTimer = setInterval(() => {
+            ping();
+            thinkingPing();
+          }, 6e3);
         }
         const run = await runtimeBest(this.cfg.serverUrl, "/runs", token, {
           trigger: { source: "byoa", engine: this.adapter.id }
         });
         const controller = new AbortController();
         let exitCode = 0;
+        let engineError = null;
         try {
+          const [memoryDigest, triageNote] = await Promise.all([
+            this.memoryDigest(),
+            Promise.resolve(this.formatTriageNote(triage))
+          ]);
           const result = await this.adapter.run({
             home: this.home,
-            prompt: this.prompt(),
+            prompt: this.prompt(memoryDigest, triageNote),
             env: this.engineEnv(),
             model: this.agent.model,
             fastModel: this.agent.fastModel,
@@ -392,17 +574,32 @@ If nothing genuinely needs you, it's fine to do nothing and stop. When finished,
             signal: controller.signal
           });
           exitCode = result.exitCode;
+          if (result.error) engineError = this.visibleEngineError(exitCode, result.error);
         } catch (err) {
           console.error(`[computer] ${this.agent.id} engine spawn failed:`, err instanceof Error ? err.message : err);
           exitCode = 1;
+          engineError = this.visibleEngineError(exitCode, err instanceof Error ? err.stack || err.message : String(err));
         } finally {
           if (typingTimer) clearInterval(typingTimer);
-          if (convo) await runtimeBest(this.cfg.serverUrl, "/typing", token, { conversationId: convo, done: true });
+          if (convo) {
+            await runtimeBest(this.cfg.serverUrl, "/typing", token, { conversationId: convo, done: true });
+            await runtimeBest(this.cfg.serverUrl, "/thinking/unmark", token, { conversationIds: [convo] });
+          }
+        }
+        if (engineError) {
+          await this.publishEngineFailure({
+            token,
+            runId: run?.runId,
+            conversationId: convo,
+            error: engineError,
+            exitCode
+          });
         }
         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})`
+            summary: engineError ?? `byoa ${this.adapter.id} run (exit ${exitCode})`,
+            error: engineError
           });
         }
         await runtimeBest(this.cfg.serverUrl, "/status", token, { status: "avail" });
@@ -453,10 +650,12 @@ async function doRun(serverOverride) {
     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;
+  let available;
+  try {
+    available = await requireLocalEngine();
+  } catch (err) {
+    console.error(`[computer] ${err instanceof Error ? err.message : String(err)}`);
+    process.exitCode = 70;
     return;
   }
   console.log(`[computer] starting ${cfg.computerId} @ ${cfg.serverUrl} (engines: ${available.join(", ")})`);
@@ -546,4 +745,9 @@ async function main() {
   );
   process.exit(argv.length ? 1 : 0);
 }
-void main();
+void main().catch((err) => {
+  const message = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`cumora: ${message}
+`);
+  process.exit(70);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cumora",
-  "version": "0.1.45",
+  "version": "0.1.47",
   "description": "Run your Cumora agents on your own machine or VPS, powered by your local Claude Code or Codex CLI (BYOA).",
   "type": "module",
   "bin": {