@linzumi/cli 0.0.108-beta → 0.0.109-beta

package/README.md

@@ -58,7 +58,7 @@ Install the CLI or run it with `npx`:
 ```bash
 npm install -g @linzumi/cli@latest
 npx -y @linzumi/cli@latest signup
-npx -y @linzumi/cli@0.0.108-beta --version
+npx -y @linzumi/cli@0.0.109-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -20078,7 +20078,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.108-beta";
+    linzumiCliVersion = "0.0.109-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -25064,6 +25064,7 @@ async function openLocalCodexRunner(options, log2, cleanup, close, runnerDrainHo
   const latestResumeReconcileByThread = /* @__PURE__ */ new Map();
   let acceptingInbound = true;
   const inboundQueueWorkspace = () => runnerWorkspaceSlug(options) ?? "default";
+  const resolveRunnerBoundChannel = () => options.channelSession?.channelSlug ?? threadSessionRegistry.list()[0]?.channel;
   const durableInboundQueueFor = (channel, kandanThreadId) => {
     const workspace = inboundQueueWorkspace();
     const cacheKey = `${workspace}:${channel}:${kandanThreadId}`;
@@ -26845,7 +26846,25 @@ async function openLocalCodexRunner(options, log2, cleanup, close, runnerDrainHo
     }
     const record = threadSessionRegistry.list().find((entry) => entry.kandanThreadId === kandanThreadId);
     if (record === void 0) {
-      return "ignored";
+      const boundChannel = resolveRunnerBoundChannel();
+      if (boundChannel === void 0 || !acceptingInbound) {
+        return "ignored";
+      }
+      const queue2 = durableInboundQueueFor(boundChannel, kandanThreadId);
+      const enqueued = queue2.enqueue(
+        event.seq,
+        event.localRunnerEventType === void 0 ? "live" : "replay",
+        serializeKandanChatEventForQueue(event),
+        Date.now()
+      );
+      log2("runner.spawn_on_miss_enqueued_without_local_record", {
+        kandanThreadId,
+        channel: boundChannel,
+        seq: event.seq,
+        enqueued: enqueued.accepted
+      });
+      await publishUnroutedDurableEnqueueState(boundChannel, event);
+      return "spawned";
     }
     const queueChannel = record.channel;
     const watermarkKey = threadSourceSeqWatermarkKey(
@@ -26971,6 +26990,44 @@ async function openLocalCodexRunner(options, log2, cleanup, close, runnerDrainHo
       }
     });
   };
+  const drainThreadQueueAfterSpawn = async (kandanThreadId, spawnResponse) => {
+    if (spawnResponse !== void 0 && spawnResponse.ok === false) {
+      return;
+    }
+    if (!acceptingInbound) {
+      return;
+    }
+    const record = threadSessionRegistry.list().find((entry) => entry.kandanThreadId === kandanThreadId);
+    if (record === void 0) {
+      return;
+    }
+    const queue = durableInboundQueueFor(record.channel, kandanThreadId);
+    if (queue.entries().length === 0) {
+      return;
+    }
+    log2("runner.inbound_drain_after_spawn", {
+      kandanThreadId,
+      channel: record.channel,
+      pending: queue.entries().length
+    });
+    await drainOwnedThreadQueue(
+      record,
+      latestResumeReconcileByThread.get(kandanThreadId) ?? []
+    ).catch((error) => {
+      log2("runner.inbound_drain_after_spawn_failed", {
+        kandanThreadId,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    });
+  };
+  const startThreadRunnerProcessFromServerControl = async (control, cwd) => {
+    const response = await startThreadRunnerProcess(control, cwd);
+    const kandanThreadId = optionalThreadControlField(control, "threadId");
+    if (kandanThreadId !== void 0) {
+      await drainThreadQueueAfterSpawn(kandanThreadId, response);
+    }
+    return response;
+  };
   const consumeResumeReconcile = (reconcileValue) => {
     const byThread = /* @__PURE__ */ new Map();
     const entries = parseResumeReconcileEntries(reconcileValue);
@@ -27228,6 +27285,29 @@ async function openLocalCodexRunner(options, log2, cleanup, close, runnerDrainHo
       });
     }
   };
+  const publishUnroutedDurableEnqueueState = async (channel, event) => {
+    if (event.threadId === void 0) {
+      return;
+    }
+    const payload = {
+      workspace: inboundQueueWorkspace(),
+      channel,
+      thread_id: event.threadId,
+      instance_id: instanceId,
+      seq: event.seq,
+      status: "queued",
+      reason: "queued for durable resume"
+    };
+    try {
+      await kandan.push(topic, "message_state", payload);
+    } catch (error) {
+      log2("runner.spawn_on_miss_state_push_failed", {
+        thread_id: event.threadId,
+        status: "queued",
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  };
   const deadLetterPublisherFor = (record) => {
     return async ({ sourceSeq, reason, attempts, alreadyPublished }) => {
       log2("runner.inbound_dead_lettered", {
@@ -27738,7 +27818,7 @@ async function openLocalCodexRunner(options, log2, cleanup, close, runnerDrainHo
           control,
           log2,
           attachThreadSession,
-          shouldUseThreadProcesses(options) ? startThreadRunnerProcess : void 0,
+          shouldUseThreadProcesses(options) ? startThreadRunnerProcessFromServerControl : void 0,
           (id) => leaseEpochRegistry.current(id),
           commitLiveWorkerAcceptedSourceSeq,
           captureLiveFollowUpEvent,
@@ -31326,7 +31406,8 @@ ${developerPrompt}`,
       metadata: {
         local_codex_runner: {
           event_type: "codex_start_instructions",
-          codex_thread_id: codexThreadId
+          codex_thread_id: codexThreadId,
+          instructions_body: developerPrompt
         }
       }
     },
@@ -70921,22 +71002,49 @@ async function resolveMcpAuth(args) {
       mode: "personal-agent-delegation"
     };
   }
-  const token = args.explicitToken ?? readCachedLocalRunnerToken(args.kandanUrl, args.authFilePath)?.accessToken;
+  const accessToken = await resolveMcpLocalRunnerToken({
+    kandanUrl: args.kandanUrl,
+    explicitToken: args.explicitToken,
+    authFilePath: args.authFilePath,
+    workspaceSlug: args.workspaceSlug,
+    channelSlug: args.channelSlug
+  });
+  return { accessToken, mode: "local-runner" };
+}
+async function resolveMcpLocalRunnerToken(args, deps = {
+  readCachedToken: readCachedLocalRunnerToken,
+  validateTokenOutcome: validateLocalRunnerTokenOutcome,
+  resolveToken: resolveLocalRunnerToken
+}) {
+  const token = args.explicitToken ?? deps.readCachedToken(args.kandanUrl, args.authFilePath)?.accessToken;
   if (token === void 0) {
     throw new Error(
       "missing Linzumi MCP token; run linzumi auth or pass --token"
     );
   }
-  const valid = await validateLocalRunnerToken({
+  const outcome = await deps.validateTokenOutcome({
     kandanUrl: args.kandanUrl,
     accessToken: token,
     workspaceSlug: args.workspaceSlug,
     channelSlug: args.channelSlug
   });
-  if (!valid) {
-    throw new Error("Linzumi MCP token was rejected by the server");
+  if (outcome === "usable") {
+    return token;
+  }
+  const _recoverable = outcome;
+  void _recoverable;
+  try {
+    return await deps.resolveToken({
+      kandanUrl: args.kandanUrl,
+      workspaceSlug: args.workspaceSlug,
+      channelSlug: args.channelSlug,
+      authFilePath: args.authFilePath
+    });
+  } catch (error) {
+    throw new Error(
+      `Linzumi MCP token was rejected by the server and re-mint failed: ${error instanceof Error ? error.message : String(error)}`
+    );
   }
-  return { accessToken: token, mode: "local-runner" };
 }
 function mcpJsonResult(value) {
   return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "0.0.108-beta",
+  "version": "0.0.109-beta",
   "description": "Linzumi CLI \u2014 point a Codex agent at the real code on your laptop, with your team watching and steering from shared threads.",
   "type": "module",
   "bin": {