@linzumi/cli 0.0.36-beta → 0.0.38-beta

package/README.md

@@ -63,7 +63,7 @@ Install the CLI or run it with `npx`:
 
 ```bash
 npm install -g @linzumi/cli@latest
-npx -y @linzumi/cli@0.0.36-beta --version
+npx -y @linzumi/cli@0.0.38-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -1481,7 +1481,7 @@ var maxForwardedTurnIds = 64;
 async function attachChannelSession(args) {
   const session = args.options.channelSession;
   const chatTopic = `chat:${session.workspaceSlug}:${session.channelSlug}`;
-  const state = initialChannelSessionState(0, session.kandanThreadId, args.options);
+  const state = initialChannelSessionState(0, session.rootSeq, session.kandanThreadId, session.codexThreadId, args.options);
   const joined = await args.kandan.join(chatTopic, { last_seq: 0 }, {
     rejoinPayload: () => ({ last_seq: state.minSeq })
   });
@@ -1599,6 +1599,7 @@ async function attachChannelSession(args) {
       }
     },
     handleControl: (control) => handleChannelSessionControl(args, state, payloadContext, control),
+    startThreadMessageTurn: (message) => startThreadMessageTurn(args, state, payloadContext, message),
     currentRuntimeSettings: () => state.runtimeSettings,
     currentCodexThreadId: () => state.codexThreadId,
     currentKandanThreadId: () => state.kandanThreadId,
@@ -1641,11 +1642,11 @@ async function bindCurrentCodexThread(args, state) {
     instance_id: args.instanceId
   });
 }
-function initialChannelSessionState(cursor, kandanThreadId, options) {
+function initialChannelSessionState(cursor, rootSeq, kandanThreadId, codexThreadId, options) {
   return {
-    rootSeq: undefined,
+    rootSeq,
     kandanThreadId,
-    codexThreadId: undefined,
+    codexThreadId,
     turn: { status: "idle" },
     closed: false,
     minSeq: cursor,
@@ -1682,7 +1683,7 @@ function initialChannelSessionState(cursor, kandanThreadId, options) {
   };
 }
 function startPortForwardWatchIfEnabled(args, state, payloadContext) {
-  if (args.options.enablePortForwardWatch !== true || state.portForwardWatcher !== undefined) {
+  if (args.options.enablePortForwardWatch !== true || state.portForwardWatcher !== undefined || state.kandanThreadId === undefined || state.codexThreadId === undefined) {
     return;
   }
   const { start: configuredStart, ...watchOptions } = args.options.portForwardWatcher ?? {};
@@ -1712,6 +1713,8 @@ async function bindChannelSession(args, state, payloadContext) {
     if (state.rootSeq !== undefined) {
       state.minSeq = Math.max(state.minSeq, state.rootSeq);
     }
+  } else if (state.codexThreadId !== undefined) {
+    await bindCurrentCodexThread(args, state);
   } else {
     const resolved = await pushOk(args.kandan, args.topic, "session:resolve_thread_session", {
       workspace: session.workspaceSlug,
@@ -1723,13 +1726,7 @@ async function bindChannelSession(args, state, payloadContext) {
     if (state.codexThreadId === undefined) {
       throw new Error("Kandan thread root metadata did not include a Codex thread id");
     }
-    await pushOk(args.kandan, args.topic, "session:post_thread_message", {
-      workspace: session.workspaceSlug,
-      channel: session.channelSlug,
-      thread_id: state.kandanThreadId,
-      body: availabilityMessage(args.options, codexVersion, state.codexThreadId),
-      payload: localRunnerPayload(args.options, args.instanceId, "availability", state.codexThreadId, payloadContext)
-    });
+    await bindCurrentCodexThread(args, state);
   }
 }
 async function handleChannelSessionControl(args, state, payloadContext, control) {
@@ -1745,7 +1742,10 @@ async function handleChannelSessionControl(args, state, payloadContext, control)
   if (control.type !== "interrupt_queued_messages") {
     return;
   }
-  if (state.codexThreadId === undefined || state.kandanThreadId === undefined || control.threadId !== state.codexThreadId) {
+  if (state.codexThreadId !== control.threadId) {
+    return;
+  }
+  if (state.codexThreadId === undefined || state.kandanThreadId === undefined) {
     return { instanceId: args.instanceId, ok: false, error: "thread_not_bound" };
   }
   const interrupted = interruptPendingKandanMessages(state.queue, control.throughSeq);
@@ -1795,7 +1795,10 @@ async function handleChannelSessionControl(args, state, payloadContext, control)
   };
 }
 function updateSessionSettings(args, state, control) {
-  if (state.codexThreadId === undefined || control.threadId !== state.codexThreadId) {
+  if (state.codexThreadId !== control.threadId) {
+    return;
+  }
+  if (state.codexThreadId === undefined) {
     return { instanceId: args.instanceId, ok: false, error: "thread_not_bound" };
   }
   state.runtimeSettings = mergeRuntimeSettings(state.runtimeSettings, control);
@@ -1822,7 +1825,10 @@ function updateSessionSettings(args, state, control) {
   };
 }
 async function resolvePendingCodexApprovalRequest(args, state, control) {
-  if (state.codexThreadId === undefined || state.kandanThreadId === undefined || control.threadId !== state.codexThreadId) {
+  if (state.codexThreadId !== control.threadId) {
+    return;
+  }
+  if (state.codexThreadId === undefined || state.kandanThreadId === undefined) {
     return { instanceId: args.instanceId, ok: false, error: "thread_not_bound" };
   }
   const approval = state.pendingApprovalRequests.get(approvalRequestKey(control.requestId, control.sourceSeq));
@@ -1836,7 +1842,7 @@ async function resolvePendingCodexApprovalRequest(args, state, control) {
   await publishMessageState(args, state.kandanThreadId, approval.sourceSeq, {
     status: "processing",
     reason: "streaming response"
-  });
+  }, undefined, undefined, state.codexThreadId);
   args.log("codex.approval_request_resolved", {
     request_id: control.requestId,
     source_seq: control.sourceSeq,
@@ -1846,6 +1852,10 @@ async function resolvePendingCodexApprovalRequest(args, state, control) {
   return { instanceId: args.instanceId, ok: true };
 }
 async function resolvePendingPortForwardRequest(args, state, payloadContext, control) {
+  const request = state.pendingPortForwardRequests.get(control.requestId);
+  if (request === undefined) {
+    return;
+  }
   if (!portForwardControlSenderAllowed(args, payloadContext, control)) {
     args.log("port_forward.request_resolution_ignored", {
       request_id: control.requestId,
@@ -1855,10 +1865,6 @@ async function resolvePendingPortForwardRequest(args, state, payloadContext, con
     });
     return { instanceId: args.instanceId, ok: false, error: "sender_not_allowed" };
   }
-  const request = state.pendingPortForwardRequests.get(control.requestId);
-  if (request === undefined) {
-    return { instanceId: args.instanceId, ok: false, error: "port_forward_request_not_found" };
-  }
   state.pendingPortForwardRequests.delete(control.requestId);
   if (control.decision === "deny") {
     state.dismissedForwardTargets.set(request.port, approvedTargetFromRequest(request));
@@ -2175,6 +2181,7 @@ async function handleKandanChatEvent(args, state, runnerIdentity, payloadContext
       state.kandanThreadId = event.threadId;
     }
   }
+  startPortForwardWatchIfEnabled(args, state, payloadContext);
   if (event.threadId !== state.kandanThreadId) {
     args.log("kandan.message_ignored", {
       seq: event.seq,
@@ -2204,6 +2211,27 @@ async function handleKandanChatEvent(args, state, runnerIdentity, payloadContext
   await publishKandanMessageState(args, event, { status: "queued" });
   await drainKandanMessageQueue(args, state, payloadContext);
 }
+async function startThreadMessageTurn(args, state, payloadContext, message) {
+  if (state.kandanThreadId === undefined || state.codexThreadId === undefined) {
+    throw new Error("cannot start a local Codex turn before thread binding");
+  }
+  const queued = {
+    seq: message.seq,
+    actorSlug: message.actorSlug,
+    actorUserId: message.actorUserId,
+    body: message.body,
+    attachments: []
+  };
+  enqueuePendingKandanMessage(state.queue, queued);
+  args.log("kandan.message_queued", {
+    seq: queued.seq,
+    actor_slug: queued.actorSlug ?? null,
+    actor_user_id: queued.actorUserId ?? null,
+    queue_depth: pendingKandanMessageQueueLength(state.queue)
+  });
+  await publishQueuedMessageState(args, state, queued, { status: "queued" });
+  await drainKandanMessageQueue(args, state, payloadContext);
+}
 async function bindUnboundHistoricalThread(args, state, event) {
   if (event.threadId === undefined || event.replyToSeq === undefined) {
     return false;
@@ -2362,7 +2390,11 @@ async function drainKandanMessageQueue(args, state, payloadContext) {
 }
 async function handleCodexServerRequest(args, state, payloadContext, request) {
   const params = objectValue(request.params) ?? {};
-  const turnId = stringValue(params.turnId);
+  const turnId = codexNotificationTurnId(params);
+  const threadId = codexNotificationThreadId(params);
+  if (state.closed || !codexNotificationBelongsToSession(state, threadId, turnId)) {
+    return;
+  }
   if (codexApprovalRequestCanAutoAccept(state.runtimeSettings, request.method)) {
     args.log("codex.server_request_auto_accepted", {
       method: request.method,
@@ -2405,7 +2437,7 @@ async function requestKandanApproval(args, state, request, turnId, payloadContex
     status: "processing",
     reason: "awaiting approval",
     approval
-  });
+  }, undefined, undefined, state.codexThreadId);
   args.log("codex.approval_request_pending", {
     request_id: approval.requestId,
     source_seq: sourceSeq,
@@ -3576,12 +3608,13 @@ async function publishQueuedMessageState(args, state, message, messageState) {
   }
   await publishMessageState(args, state.kandanThreadId, message.seq, messageState, message.actorSlug, message.actorUserId);
 }
-async function publishMessageState(args, threadId, seq, state, actorSlug, actorUserId) {
+async function publishMessageState(args, threadId, seq, state, actorSlug, actorUserId, codexThreadId) {
   const session = args.options.channelSession;
   const payload = {
     workspace: session.workspaceSlug,
     channel: session.channelSlug,
     thread_id: threadId,
+    ...codexThreadId === undefined ? {} : { codex_thread_id: codexThreadId },
     seq,
     status: state.status,
     ..."reason" in state ? { reason: state.reason } : {},
@@ -3639,7 +3672,7 @@ async function refreshActiveProcessingHeartbeat(args, state) {
   if (activeProcessingState === undefined || state.kandanThreadId === undefined) {
     return;
   }
-  await publishMessageState(args, state.kandanThreadId, activeProcessingState.seq, processingMessageStateFromActive(activeProcessingState));
+  await publishMessageState(args, state.kandanThreadId, activeProcessingState.seq, processingMessageStateFromActive(activeProcessingState), undefined, undefined, state.codexThreadId);
 }
 function clearActiveProcessingState(state, seq) {
   if (state.activeProcessingState?.seq === seq) {
@@ -4305,12 +4338,21 @@ async function respondToServerRequest(websocket, request, callbacks) {
       }));
       return;
     }
-    const callback = Array.from(callbacks)[0];
-    if (callback === undefined) {
-      throw new Error(`unhandled Codex app-server request: ${request.method}`);
+    for (const callback of callbacks) {
+      const result = await callback(request);
+      if (result !== undefined) {
+        websocket.send(JSON.stringify({ jsonrpc: "2.0", id: request.id, result }));
+        return;
+      }
     }
-    const result = await callback(request);
-    websocket.send(JSON.stringify({ jsonrpc: "2.0", id: request.id, result }));
+    websocket.send(JSON.stringify({
+      jsonrpc: "2.0",
+      id: request.id,
+      error: {
+        code: -32601,
+        message: `unhandled Codex app-server request: ${request.method}`
+      }
+    }));
   } catch (error) {
     websocket.send(JSON.stringify({
       jsonrpc: "2.0",
@@ -6981,7 +7023,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     await Promise.all(Array.from(dynamicChannelSessions.values(), (session) => session.close()));
     dynamicChannelSessions.clear();
   });
-  const attachStartedThreadSession = async (control, cwd) => {
+  const attachStartedThreadSession = async (control, cwd, codexThreadId) => {
     const workspaceSlug = normalizedWorkDescription(control.workspace);
     const channelSlug = normalizedWorkDescription(control.channel);
     const kandanThreadId = normalizedWorkDescription(control.threadId);
@@ -6992,6 +7034,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     if (listenUser === undefined) {
       throw new Error("missing listen user for Commander-started Codex session");
     }
+    const runtimeSettings = startInstanceRuntimeSettings(options, control);
     const session = await attachChannelSession({
       kandan,
       codex,
@@ -7021,16 +7064,19 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
           workspaceSlug,
           channelSlug,
           kandanThreadId,
+          rootSeq: integerValue(control.rootSeq),
+          codexThreadId,
           listenUser,
-          model: control.model,
-          reasoningEffort: control.reasoningEffort,
-          sandbox: control.sandbox,
-          approvalPolicy: control.approvalPolicy
+          model: runtimeSettings.model,
+          reasoningEffort: runtimeSettings.reasoningEffort,
+          sandbox: runtimeSettings.sandbox,
+          approvalPolicy: runtimeSettings.approvalPolicy
         }
       },
       log
     });
     dynamicChannelSessions.set(kandanThreadId, session);
+    return session;
   };
   const heartbeatPayload = () => ({
     instanceId,
@@ -7401,6 +7447,7 @@ async function applyControl(codex, kandan, topic, instanceId, options, allowedCw
         ensureCodexProjectTrusted(cwd.cwd);
       }
       const developerPrompt = normalizedWorkDescription(control.developerPrompt);
+      const runtimeSettings = startInstanceRuntimeSettings(options, control);
       const response = await codex.request("thread/start", {
         cwd: cwd.cwd,
         serviceName: "kandan-local-runner",
@@ -7409,25 +7456,34 @@ async function applyControl(codex, kandan, topic, instanceId, options, allowedCw
           cwd: cwd.cwd,
           developerPrompt
         }),
-        ...control.model === undefined ? {} : { model: control.model },
-        ...control.reasoningEffort === undefined ? {} : { reasoningEffort: control.reasoningEffort },
-        ...control.approvalPolicy === undefined ? {} : { approvalPolicy: control.approvalPolicy },
-        ...control.sandbox === undefined ? {} : { sandbox: control.sandbox },
-        ...control.fast === true ? { serviceTier: "fast" } : {}
+        ...runtimeSettings.model === undefined ? {} : { model: runtimeSettings.model },
+        ...runtimeSettings.reasoningEffort === undefined ? {} : { reasoningEffort: runtimeSettings.reasoningEffort },
+        ...runtimeSettings.approvalPolicy === undefined ? {} : { approvalPolicy: runtimeSettings.approvalPolicy },
+        ...runtimeSettings.sandbox === undefined ? {} : { sandbox: runtimeSettings.sandbox },
+        ...runtimeSettings.fast === true ? { serviceTier: "fast" } : {}
       });
       const codexThreadId = extractStartedThreadId(response);
       const workDescription = normalizedWorkDescription(control.workDescription);
       if (codexThreadId !== undefined && developerPrompt !== undefined) {
         await postVisibleDeveloperPrompt(kandan, topic, control, developerPrompt, codexThreadId);
       }
-      if (codexThreadId !== undefined && onStartedThread !== undefined) {
-        await onStartedThread(control, cwd.cwd);
-      }
+      const startedThreadSession = codexThreadId !== undefined && onStartedThread !== undefined ? await onStartedThread(control, cwd.cwd, codexThreadId) : undefined;
       if (codexThreadId !== undefined && workDescription !== undefined) {
-        await codex.request("turn/start", {
-          threadId: codexThreadId,
-          input: [{ type: "text", text: workDescription }]
-        });
+        const rootSeq = integerValue(control.rootSeq);
+        if (startedThreadSession !== undefined && rootSeq !== undefined) {
+          const identity = identityFromAccessToken(options.token);
+          await startedThreadSession.startThreadMessageTurn({
+            seq: rootSeq,
+            body: workDescription,
+            actorSlug: identity.actorUsername,
+            actorUserId: identity.actorUserId
+          });
+        } else {
+          await codex.request("turn/start", {
+            threadId: codexThreadId,
+            input: [{ type: "text", text: workDescription }]
+          });
+        }
       }
       return {
         instanceId,
@@ -7486,6 +7542,7 @@ async function applyControl(codex, kandan, topic, instanceId, options, allowedCw
     case "kill_instance":
     case "interrupt_queued_messages":
     case "resolve_codex_approval_request":
+    case "resolve_port_forward_request":
     case "forward_http_request":
     case "forward_websocket_open":
     case "forward_websocket_send":
@@ -7575,6 +7632,16 @@ ${developerPrompt}`,
     client_message_id: `codex-start-instructions-${threadId}`
   });
 }
+function startInstanceRuntimeSettings(options, control) {
+  const session = options.channelSession;
+  return {
+    model: control.model ?? session?.model,
+    reasoningEffort: control.reasoningEffort ?? session?.reasoningEffort,
+    approvalPolicy: control.approvalPolicy ?? session?.approvalPolicy,
+    sandbox: control.sandbox ?? session?.sandbox,
+    fast: control.fast ?? options.fast
+  };
+}
 async function startOwnedCodexAppServer(options) {
   ensureCodexProjectTrusted(options.cwd);
   return await startCodexAppServer(options.codexBin, options.cwd, {
@@ -9421,7 +9488,7 @@ async function main(args) {
       process.stdout.write(connectGuideText());
       return;
     case "version":
-      process.stdout.write(`linzumi 0.0.36-beta
+      process.stdout.write(`linzumi 0.0.38-beta
 `);
       return;
     case "auth":
@@ -9935,7 +10002,7 @@ async function parseRunnerArgs(args, deps = {
     process.exit(0);
   }
   if (values.get("version") === true) {
-    process.stdout.write(`linzumi 0.0.36-beta
+    process.stdout.write(`linzumi 0.0.38-beta
 `);
     process.exit(0);
   }

package/package.json

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