@lumi.ai/runner 0.5.5 → 0.5.6

package/dist/cli.js

@@ -7,7 +7,7 @@ import { Command } from "commander";
 import os3 from "node:os";
 import {
   collection as collection5,
-  deleteField,
+  deleteField as deleteField2,
   doc as doc7,
   getDoc as getDoc5,
   getDocs as getDocs4,
@@ -231,6 +231,164 @@ function jobTarget(job) {
   return null;
 }
 
+// ../shared/dist/jobProgress.js
+var MAX_JOB_STEPS = 10;
+var MAX_STEP_LABEL = 80;
+var MAX_STEP_DETAIL = 120;
+function clampStepText(text, max) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length <= max ? flat : `${flat.slice(0, max - 1)}\u2026`;
+}
+function firstLine(text) {
+  return text.split("\n").find((l) => l.trim()) ?? "";
+}
+function str(input, key) {
+  if (!input || typeof input !== "object")
+    return void 0;
+  const value = input[key];
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function basename(path5) {
+  const parts = path5.split(/[\\/]/).filter(Boolean);
+  return parts[parts.length - 1] ?? path5;
+}
+function hostOf(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return "";
+  }
+}
+var WORKSPACE_PREFIX = "mcp__workspace__";
+var MCP_PREFIX = "mcp__";
+var WORKSPACE_LABELS = {
+  ship_info: "Checking the Ship",
+  agent_list: "Looking up the crew",
+  task_list: "Looking through the board",
+  task_get: "Reading a task",
+  task_create: "Creating a task",
+  task_update_status: "Moving a task",
+  task_assign: "Assigning a task",
+  task_relate: "Linking two tasks",
+  task_comment: "Commenting on a task",
+  approval_request: "Asking for approval",
+  approval_decide: "Answering an approval",
+  run_report: "Writing its run report",
+  knowledge_get: "Reading the knowledge base",
+  knowledge_write: "Writing to the knowledge base",
+  media_get: "Opening an attachment",
+  media_attach: "Attaching a file",
+  memory_write: "Updating its notes",
+  chat_get: "Reading the conversation",
+  chat_send: "Writing its reply"
+};
+var BUILTIN_LABELS = {
+  Bash: "Running a command",
+  Read: "Reading a file",
+  Write: "Writing a file",
+  Edit: "Editing a file",
+  MultiEdit: "Editing a file",
+  Glob: "Looking for files",
+  Grep: "Searching the code",
+  WebSearch: "Searching the web",
+  WebFetch: "Reading a web page",
+  TodoWrite: "Planning its next steps",
+  Task: "Delegating to a sub-agent"
+};
+function workspaceDetail(tool, input) {
+  switch (tool) {
+    case "task_list":
+      return str(input, "status") ?? str(input, "query");
+    case "task_get":
+      return str(input, "taskId");
+    case "task_create":
+      return str(input, "title");
+    case "task_update_status":
+      return str(input, "status");
+    case "task_relate":
+      return str(input, "blockedBy") ? "blocked by" : str(input, "waitingOn") ? "waiting on" : void 0;
+    case "task_comment": {
+      const content = str(input, "content");
+      return content ? firstLine(content) : void 0;
+    }
+    case "approval_request":
+      return str(input, "action") ?? str(input, "summary");
+    case "knowledge_get":
+      return str(input, "slug") ?? str(input, "find") ?? "the catalog";
+    case "knowledge_write":
+      return str(input, "slug");
+    case "media_get":
+      return str(input, "mediaId");
+    case "media_attach":
+      return str(input, "name");
+    default:
+      return void 0;
+  }
+}
+function builtinDetail(tool, input) {
+  switch (tool) {
+    case "Bash":
+      return str(input, "command");
+    case "Read":
+    case "Write":
+    case "Edit":
+    case "MultiEdit": {
+      const path5 = str(input, "file_path");
+      return path5 ? basename(path5) : void 0;
+    }
+    case "Glob":
+    case "Grep":
+      return str(input, "pattern");
+    case "WebSearch":
+      return str(input, "query");
+    case "WebFetch": {
+      const url = str(input, "url");
+      return url ? hostOf(url) || void 0 : void 0;
+    }
+    case "Task":
+      return str(input, "description");
+    default:
+      return void 0;
+  }
+}
+function describeToolUse(name, input, opts) {
+  if (name.startsWith(WORKSPACE_PREFIX)) {
+    const tool = name.slice(WORKSPACE_PREFIX.length);
+    return {
+      kind: "tool",
+      label: WORKSPACE_LABELS[tool] ?? "Working",
+      detail: workspaceDetail(tool, input)
+    };
+  }
+  if (name.startsWith(MCP_PREFIX)) {
+    const rest = name.slice(MCP_PREFIX.length);
+    const split = rest.indexOf("__");
+    const key = split < 0 ? rest : rest.slice(0, split);
+    const tool = split < 0 ? void 0 : rest.slice(split + 2);
+    return {
+      kind: "tool",
+      label: `Using ${opts?.mcpNames?.[key] ?? key}`,
+      detail: tool || void 0
+    };
+  }
+  const label = BUILTIN_LABELS[name];
+  if (label)
+    return { kind: "tool", label, detail: builtinDetail(name, input) };
+  return { kind: "tool", label: "Working" };
+}
+function describeAssistantText(text) {
+  return { kind: "saying", label: "Working it out", detail: firstLine(text) || void 0 };
+}
+function pushJobStep(progress, step, max = MAX_JOB_STEPS) {
+  const steps = [...progress?.steps ?? [], step];
+  return {
+    seq: (progress?.seq ?? 0) + 1,
+    updatedAt: step.at,
+    // Keep the NEWEST `max`, oldest first — a reader renders top to bottom.
+    steps: steps.slice(Math.max(0, steps.length - max))
+  };
+}
+
 // ../shared/dist/knowledge.js
 var KNOWLEDGE_CATALOG_MAX_CHARS = 1500;
 var KNOWLEDGE_CATALOG_SUMMARIES = 8;
@@ -581,7 +739,7 @@ function mcpUrl(config2) {
 }
 
 // src/version.ts
-var RUNNER_VERSION = true ? "0.5.5" : "0.0.0-dev";
+var RUNNER_VERSION = true ? "0.5.6" : "0.0.0-dev";
 
 // src/auth.ts
 import { signInWithCustomToken } from "firebase/auth";
@@ -1416,6 +1574,31 @@ import { spawn as spawn3 } from "node:child_process";
 import fs3 from "node:fs";
 import os2 from "node:os";
 import path3 from "node:path";
+
+// src/engines/claudeEvents.ts
+function stepsFromClaudeEvent(event, opts) {
+  const type = typeof event?.type === "string" ? event.type : "";
+  if (type === "assistant") {
+    const message = event.message;
+    const content = Array.isArray(message?.content) ? message.content : [];
+    const steps = [];
+    for (const block of content) {
+      if (!block || typeof block !== "object") continue;
+      if (block.type === "tool_use" && typeof block.name === "string") {
+        steps.push(describeToolUse(block.name, block.input, { mcpNames: opts?.mcpNames }));
+      } else if (block.type === "thinking" || block.type === "redacted_thinking") {
+        steps.push({ kind: "thinking", label: "Thinking" });
+      } else if (block.type === "text" && typeof block.text === "string" && block.text.trim()) {
+        steps.push(describeAssistantText(block.text));
+      }
+    }
+    return steps;
+  }
+  if (type === "result") return [{ kind: "done", label: "Finished" }];
+  return [];
+}
+
+// src/engines/claude.ts
 function normalizeClaudeUsage(resultEvent, model, fallbackDurationS) {
   const result = resultEvent ?? {};
   const u = result.usage ?? {};
@@ -1559,6 +1742,8 @@ async function runSession(input, bin, dirs) {
       GIT_CONFIG_VALUE_0: "https://github.com/"
     } : {}
   };
+  const mcpNames = {};
+  for (const s of input.extraMcpServers ?? []) mcpNames[s.key] = s.name || s.key;
   const startedAt = Date.now();
   const lines = [];
   const stderrLines = [];
@@ -1591,6 +1776,9 @@ async function runSession(input, bin, dirs) {
           const event = JSON.parse(line);
           if (event.type === "result") resultEvent = event;
           if (event.type === "assistant") input.log("claude: assistant turn");
+          if (input.onStep) {
+            for (const step of stepsFromClaudeEvent(event, { mcpNames })) input.onStep(step);
+          }
         } catch {
         }
       }
@@ -1864,6 +2052,7 @@ function selectDispatch(input) {
 import {
   addDoc,
   collection as collection4,
+  deleteField,
   doc as doc6,
   getDocs as getDocs3,
   limit as fsLimit,
@@ -1915,6 +2104,16 @@ async function finalizeJob(db, shipId, job, input) {
       endedAt: now,
       usage: u,
       transcriptPath: input.transcriptPath,
+      // §15.36. The live strip dies with the run — the transcript is the record, and a settled job
+      // still carrying steps would show a spinner over work that finished.
+      //
+      // `stopRequestedAt` is cleared on EVERY terminal path, including a plain `done`: the marker
+      // is self-consuming (§15.13's `startAt` shape), and leaving one behind on a job that
+      // succeeded anyway is what would let the watchdog's stop branch re-examine settled jobs
+      // forever. Deleting an absent field is not an affected key, so both are legal whether or not
+      // anything ever set them.
+      progress: deleteField(),
+      stopRequestedAt: deleteField(),
       ...input.error ? { error: input.error.slice(0, 1500) } : {},
       // Omitted rather than written empty, so a job that had none looks exactly like every job
       // written before §15.31 — there is nothing to migrate and nothing to read defensively.
@@ -1947,7 +2146,9 @@ async function requeueForRetry(db, shipId, job, error) {
     tx.update(doc6(db, COLLECTIONS.ships, shipId, COLLECTIONS.jobs, job.id), {
       status: "queued",
       attempt: job.attempt + 1,
-      error: error.slice(0, 1500)
+      error: error.slice(0, 1500),
+      // The steps describe an attempt that is over; the next one starts its own stream.
+      progress: deleteField()
     });
   });
 }
@@ -1956,7 +2157,15 @@ async function releaseJob(db, shipId, job, reason) {
     status: "queued",
     runnerId: "",
     startedAt: 0,
-    error: reason.slice(0, 1500)
+    error: reason.slice(0, 1500),
+    // §15.36: cleared here too, not only on the terminal paths. A released job sits `queued`
+    // waiting to be re-claimed, and steps left behind would show a live-looking strip describing a
+    // session that is no longer running anywhere.
+    //
+    // `stopRequestedAt` deliberately SURVIVES a release. The job goes back on the queue still
+    // carrying the request, so whichever daemon claims it next honours the stop instead of running
+    // work somebody already asked to end.
+    progress: deleteField()
   });
 }
 async function markTaskFailed(db, shipId, job, error, statuses) {
@@ -1979,6 +2188,25 @@ ${error.slice(0, 800)}
     });
   });
 }
+async function markTaskStopped(db, shipId, job, stoppedBy) {
+  const taskRef = doc6(db, COLLECTIONS.ships, shipId, COLLECTIONS.tasks, job.taskId);
+  await addDoc(collection4(taskRef, COLLECTIONS.activity), {
+    author: { type: "agent", id: job.agentId },
+    createdAt: Date.now(),
+    kind: "comment",
+    content: `This run was stopped by ${stoppedBy} before it finished. The task is unchanged.`
+  });
+}
+async function markChatStopped(db, shipId, job, stoppedBy) {
+  const chatRef = doc6(db, COLLECTIONS.ships, shipId, COLLECTIONS.chats, job.chatId);
+  const content = `Stopped by ${stoppedBy} before I finished. Write again to start a fresh run.`;
+  await addDoc(collection4(chatRef, COLLECTIONS.chatMessages), {
+    author: { type: "agent", id: job.agentId },
+    content,
+    chars: content.length,
+    createdAt: Date.now()
+  });
+}
 async function markChatFailed(db, shipId, job, error) {
   const shipRef = doc6(db, COLLECTIONS.ships, shipId);
   const chatRef = doc6(shipRef, COLLECTIONS.chats, job.chatId);
@@ -2033,11 +2261,96 @@ async function ensureChatReply(db, shipId, job, resultText) {
   return resultText.trim() ? "posted-final-text" : "posted-silence-note";
 }
 
+// src/jobs/progress.ts
+var PROGRESS_FLUSH_MS = 3e3;
+var PROGRESS_DENIALS_BEFORE_PROBE = 2;
+function redactStep(step, secrets) {
+  const label = clampStepText(redactTranscript(step.label, secrets), MAX_STEP_LABEL);
+  if (step.detail === void 0) return { ...step, label };
+  const detail = clampStepText(redactTranscript(step.detail, secrets), MAX_STEP_DETAIL);
+  return detail ? { ...step, label, detail } : { at: step.at, kind: step.kind, label };
+}
+function isDenied(error) {
+  const code = error?.code ?? "";
+  return code === "permission-denied" || code.endsWith("/permission-denied");
+}
+function createProgressWriter(deps) {
+  const now = deps.now ?? Date.now;
+  const flushMs = deps.flushMs ?? PROGRESS_FLUSH_MS;
+  let progress;
+  let pending = [];
+  let timer = null;
+  let lastWriteAt = 0;
+  let inFlight = false;
+  let denials = 0;
+  let closed = false;
+  let loggedFailure = false;
+  function flush() {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (closed || inFlight || pending.length === 0) return;
+    const secrets = deps.secrets();
+    for (const step of pending) progress = pushJobStep(progress, redactStep(step, secrets));
+    pending = [];
+    lastWriteAt = now();
+    inFlight = true;
+    const snapshot = progress;
+    void deps.write(snapshot).then(() => {
+      denials = 0;
+    }).catch((e) => {
+      if (isDenied(e)) {
+        denials += 1;
+        if (denials >= PROGRESS_DENIALS_BEFORE_PROBE) {
+          closed = true;
+          deps.onDenied();
+        }
+        return;
+      }
+      denials = 0;
+      if (!loggedFailure) {
+        loggedFailure = true;
+        deps.log(`progress write failed (further ones silent): ${e instanceof Error ? e.message : e}`);
+      }
+    }).finally(() => {
+      inFlight = false;
+      if (pending.length > 0 && !closed) schedule();
+    });
+  }
+  function schedule() {
+    if (closed || timer) return;
+    const due = lastWriteAt + flushMs - now();
+    if (due <= 0 && !inFlight) {
+      flush();
+      return;
+    }
+    timer = setTimeout(flush, Math.max(due, 0));
+    timer.unref?.();
+  }
+  return {
+    push(step) {
+      if (closed) return;
+      pending.push({ ...step, at: now() });
+      schedule();
+    },
+    stop() {
+      closed = true;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      pending = [];
+    }
+  };
+}
+
 // src/daemon.ts
 var HEARTBEAT_MS = 3e4;
 var JOB_TIMEOUT_MS = 20 * 60 * 1e3;
 var MAX_ATTEMPTS = 2;
 var SHUTDOWN_GRACE_MS = 1e4;
+var STOP_POLL_MS = 5e3;
 async function startDaemon() {
   const moved = migrateLegacyDir();
   let config2 = requireConfig();
@@ -2424,6 +2737,23 @@ async function startDaemon() {
       ...job.workflowName ? { workflowName: job.workflowName } : {},
       startedAt: Date.now()
     };
+    const stopPoll = setInterval(() => {
+      void (async () => {
+        if (slot.stop) return;
+        try {
+          const snap = await getDoc5(
+            doc7(sess(shipId).fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.jobs, job.id)
+          );
+          const fresh = snap.data();
+          if (!fresh?.stopRequestedAt || slot.stop) return;
+          slot.stop = { at: fresh.stopRequestedAt, by: fresh.stopRequestedBy?.id ?? "someone" };
+          log2(`Job ${job.id}: stop requested \u2014 ending the session.`);
+          slot.abort.abort();
+        } catch {
+        }
+      })();
+    }, STOP_POLL_MS);
+    stopPoll.unref();
     await setAgentStatus(shipId, job.agentId, "working");
     void heartbeat();
     const wake = config2.keepAwake === false ? null : inhibitSleep(`Crew job ${job.id}`);
@@ -2450,6 +2780,37 @@ async function startDaemon() {
     let githubToken;
     let extraMcpServers = [];
     let statuses = DEFAULT_TASK_STATUSES;
+    let knownSecrets = [];
+    const progress = createProgressWriter({
+      write: (p) => updateDoc2(doc7(sess(shipId).fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.jobs, job.id), {
+        progress: p
+      }),
+      secrets: () => knownSecrets,
+      // Two consecutive DENIALS mean this job is no longer ours to write — a force-stop took it, or
+      // the machine was revoked. The §15.30 door: the news arrives as `permission-denied`.
+      //
+      // A PROBE RATHER THAN A BARE ABORT, and it is not optional. If a deploy lands the daemon
+      // before the rules, every progress write is denied on a perfectly healthy job, and aborting
+      // on that signal alone would kill live work for the length of the rollout. One read settles
+      // which of the two it is.
+      onDenied: () => {
+        void (async () => {
+          try {
+            const snap = await getDoc5(
+              doc7(sess(shipId).fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.jobs, job.id)
+            );
+            const fresh = snap.data();
+            if (!fresh || fresh.status !== "running" || fresh.runnerId !== config2.runnerId) {
+              log2(`Job ${job.id} is no longer this machine's to run \u2014 ending the session.`);
+              slot.abort.abort();
+            }
+          } catch {
+          }
+        })();
+      },
+      log: log2
+    });
+    progress.push({ kind: "start", label: "Starting up" });
     try {
       const secrets = await loadSecrets(shipId);
       const packed = target.kind === "chat" ? { kind: "chat", ctx: await loadChatContext(sess(shipId).fb.db, shipId, { ...job, chatId: target.chatId }) } : { kind: "task", ctx: await loadJobContext(sess(shipId).fb.db, shipId, { ...job, taskId: target.taskId }) };
@@ -2503,6 +2864,15 @@ async function startDaemon() {
         throw e;
       }
       if (slot.abort.signal.aborted) throw new Error("Stopped before the session started.");
+      knownSecrets = [
+        idToken,
+        secrets?.claudeToken,
+        githubToken,
+        secrets?.githubPat,
+        // §15.31. BOTH the composed header value and the bare credential — see
+        // `mcpSecretsToRedact` for why one of them is not enough.
+        ...mcpSecretsToRedact(extraMcpServers)
+      ];
       const session = await getDriver(engineId).run({
         prompt,
         agent,
@@ -2515,17 +2885,13 @@ async function startDaemon() {
         githubToken,
         timeoutMs: JOB_TIMEOUT_MS,
         signal: slot.abort.signal,
-        log: log2
+        log: log2,
+        // §15.36. The driver emits Crew's step vocabulary; the writer coalesces, redacts and
+        // persists. A throw here must never reach the driver's stdout loop, which is why `push`
+        // swallows everything.
+        onStep: (step) => progress.push(step)
       });
-      transcript = redactTranscript(session.transcript, [
-        idToken,
-        secrets?.claudeToken,
-        githubToken,
-        secrets?.githubPat,
-        // §15.31. BOTH the composed header value and the bare credential — see
-        // `mcpSecretsToRedact` for why one of them is not enough.
-        ...mcpSecretsToRedact(extraMcpServers)
-      ]);
+      transcript = redactTranscript(session.transcript, knownSecrets);
       usage = session.usage;
       if (session.limit && getEngine(engineId).usageWindows) {
         sessionLimit = session.limit;
@@ -2545,11 +2911,29 @@ async function startDaemon() {
       transient = isTransientFirestoreError(e);
     }
     wake?.release();
+    progress.stop();
+    clearInterval(stopPoll);
     try {
       if (!serving.has(shipId)) {
         log2(
           `Job ${job.id} stopped \u2014 Ship ${shipId} removed this machine mid-run. The Ship has put the job back on its own queue; nothing more is written from here.`
         );
+      } else if (slot.stop && failure) {
+        const transcriptPath = transcript ? await uploadTranscript(sess(shipId).fb.storage, shipId, job.id, transcript) : "";
+        await finalizeJob(sess(shipId).fb.db, shipId, job, {
+          status: "stopped",
+          usage,
+          transcriptPath,
+          mcpServers: extraMcpServers.map((s) => s.key)
+        });
+        const by = slot.stop.by;
+        if (target.kind === "chat") {
+          await markChatStopped(sess(shipId).fb.db, shipId, { ...job, chatId: target.chatId }, by);
+        } else {
+          await markTaskStopped(sess(shipId).fb.db, shipId, { ...job, taskId: target.taskId }, by);
+        }
+        log2(`Job ${job.id} STOPPED by ${by} (attempt ${job.attempt}).`);
+        notify("Crew job stopped", `${targetLabel} was stopped before it finished.`);
       } else if (shuttingDown) {
         await releaseJob(
           sess(shipId).fb.db,
@@ -2690,8 +3074,8 @@ async function startDaemon() {
           {
             status: "offline",
             lastSeenAt: now,
-            currentJob: deleteField(),
-            currentJobs: deleteField()
+            currentJob: deleteField2(),
+            currentJobs: deleteField2()
           },
           { merge: true }
         );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumi.ai/runner",
-  "version": "0.5.5",
+  "version": "0.5.6",
   "type": "module",
   "description": "Lumi Crew runner daemon — claims jobs from your Ships and executes them as headless Claude sessions on your own machine.",
   "//name": "The ONLY package in this monorepo published to the public registry, so it is the one that does not follow the internal @lumi/crew-* convention: `@lumi` is not a scope we own, `@lumi.ai` is (the npm org). The workspace DIRECTORY stays packages/crew/runner — renaming the package is not renaming the folder.",