@linzumi/cli 0.0.36-beta → 0.0.37-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.37-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,
@@ -1712,6 +1713,15 @@ 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);
+    switch (state.rootSeq) {
+      case undefined:
+        await postBoundThreadAvailability(args, state, payloadContext, codexVersion);
+        break;
+      default:
+        break;
+    }
   } else {
     const resolved = await pushOk(args.kandan, args.topic, "session:resolve_thread_session", {
       workspace: session.workspaceSlug,
@@ -1723,15 +1733,22 @@ 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 postBoundThreadAvailability(args, state, payloadContext, codexVersion);
   }
 }
+async function postBoundThreadAvailability(args, state, payloadContext, codexVersion) {
+  if (state.kandanThreadId === undefined || state.codexThreadId === undefined) {
+    throw new Error("cannot post local Codex availability before thread binding");
+  }
+  const session = args.options.channelSession;
+  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)
+  });
+}
 async function handleChannelSessionControl(args, state, payloadContext, control) {
   if (control.type === "update_session_settings") {
     return updateSessionSettings(args, state, control);
@@ -1745,7 +1762,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 +1815,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 +1845,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 +1862,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 +1872,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 +1885,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));
@@ -2204,6 +2230,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 +2409,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 +2456,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 +3627,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 +3691,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 +4357,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 +7042,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);
@@ -7021,6 +7082,8 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
           workspaceSlug,
           channelSlug,
           kandanThreadId,
+          rootSeq: integerValue(control.rootSeq),
+          codexThreadId,
           listenUser,
           model: control.model,
           reasoningEffort: control.reasoningEffort,
@@ -7031,6 +7094,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       log
     });
     dynamicChannelSessions.set(kandanThreadId, session);
+    return session;
   };
   const heartbeatPayload = () => ({
     instanceId,
@@ -7420,14 +7484,23 @@ async function applyControl(codex, kandan, topic, instanceId, options, allowedCw
       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 +7559,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":
@@ -9421,7 +9495,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.37-beta
 `);
       return;
     case "auth":
@@ -9935,7 +10009,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.37-beta
 `);
     process.exit(0);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "0.0.36-beta",
+  "version": "0.0.37-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": {