@linzumi/cli 0.0.28-beta → 0.0.30-beta

package/README.md

@@ -26,7 +26,7 @@ codex \
   -c sandbox_workspace_write.network_access=true \
   --ask-for-approval never \
   --sandbox danger-full-access \
-  -- 'Follow https://linzumi.com/agents.md to get me "wow"'
+  -- 'Follow https://linzumi.com/agents.md to get me to "wow"'
 ```
 
 That's the launch path: the first Codex is only the bootstrapper. It
@@ -293,7 +293,7 @@ intentionally. Every action is auditable from the thread.
 ## Pinning a version
 
 ```bash
-npm install -g @linzumi/cli@0.0.28-beta
+npm install -g @linzumi/cli@0.0.30-beta
 linzumi --version
 ```
 

package/dist/index.js

@@ -6622,6 +6622,60 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     cleanup.actions.push(() => channelSession.close());
     kandan.onReconnect(() => channelSession.handleKandanReconnect());
   }
+  const dynamicChannelSessions = new Map;
+  cleanup.actions.push(async () => {
+    await Promise.all(Array.from(dynamicChannelSessions.values(), (session) => session.close()));
+    dynamicChannelSessions.clear();
+  });
+  const attachStartedThreadSession = async (control, cwd) => {
+    const workspaceSlug = normalizedWorkDescription(control.workspace);
+    const channelSlug = normalizedWorkDescription(control.channel);
+    const kandanThreadId = normalizedWorkDescription(control.threadId);
+    if (workspaceSlug === undefined || channelSlug === undefined || kandanThreadId === undefined || dynamicChannelSessions.has(kandanThreadId)) {
+      return;
+    }
+    const listenUser = options.channelSession?.listenUser ?? identityFromAccessToken(options.token).actorUsername;
+    if (listenUser === undefined) {
+      throw new Error("missing listen user for Commander-started Codex session");
+    }
+    const session = await attachChannelSession({
+      kandan,
+      codex,
+      topic,
+      instanceId,
+      options: {
+        token: options.token,
+        runnerId: options.runnerId,
+        cwd,
+        codexBin: options.codexBin,
+        fast: control.fast ?? options.fast,
+        launchTui: false,
+        enablePortForwardWatch: true,
+        initialForwardPorts: allowedForwardPorts,
+        suppressedForwardPorts: () => Array.from(managedForwardPorts),
+        onForwardPortApproved: (port) => {
+          liveForwardPorts.add(port);
+          return capabilitiesPayload();
+        },
+        onForwardPortRevoked: (port) => {
+          liveForwardPorts.delete(port);
+          return capabilitiesPayload();
+        },
+        channelSession: {
+          workspaceSlug,
+          channelSlug,
+          kandanThreadId,
+          listenUser,
+          model: control.model,
+          reasoningEffort: control.reasoningEffort,
+          sandbox: control.sandbox,
+          approvalPolicy: control.approvalPolicy
+        }
+      },
+      log
+    });
+    dynamicChannelSessions.set(kandanThreadId, session);
+  };
   const heartbeatPayload = () => ({
     instanceId,
     codexUrl,
@@ -6684,6 +6738,9 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       metadata
     });
     channelSession?.handleCodexNotification(notification.method, params);
+    for (const session of dynamicChannelSessions.values()) {
+      session.handleCodexNotification(notification.method, params);
+    }
   });
   const handleControl = (control) => {
     log("kandan.control", { control });
@@ -6777,11 +6834,11 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       pushHeartbeat();
       return;
     }
-    (channelSession?.handleControl(control) ?? Promise.resolve(undefined)).then((handled) => {
+    resolveSessionControl(channelSession, dynamicChannelSessions, control).then((handled) => {
       if (handled !== undefined) {
         return handled;
       }
-      return applyControl(codex, kandan, topic, instanceId, options, allowedCwds.value, control);
+      return applyControl(codex, kandan, topic, instanceId, options, allowedCwds.value, control, attachStartedThreadSession);
     }).then((response) => {
       return kandan.push(topic, "codex_response", response);
     }).catch((error) => {
@@ -6802,6 +6859,19 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
 function controlTargetsInstance(control, instanceId) {
   return control.instanceId === undefined || control.instanceId === instanceId;
 }
+async function resolveSessionControl(channelSession, dynamicChannelSessions, control) {
+  const primaryHandled = await (channelSession?.handleControl(control) ?? Promise.resolve(undefined));
+  if (primaryHandled !== undefined) {
+    return primaryHandled;
+  }
+  for (const session of dynamicChannelSessions.values()) {
+    const handled = await session.handleControl(control);
+    if (handled !== undefined) {
+      return handled;
+    }
+  }
+  return;
+}
 async function closeCleanupStack(cleanup) {
   if (cleanup.closePromise !== undefined) {
     return cleanup.closePromise;
@@ -6916,7 +6986,7 @@ async function prepareCodexThreadForTuiResume(codex, codexThreadId) {
     throw new Error(`failed to verify Codex TUI resume: ${verified.error.message}`);
   }
 }
-async function applyControl(codex, kandan, topic, instanceId, options, allowedCwds, control) {
+async function applyControl(codex, kandan, topic, instanceId, options, allowedCwds, control, onStartedThread) {
   switch (control.type) {
     case "start_instance": {
       const cwd = resolveAllowedCwd(control.cwd, allowedCwds);
@@ -6949,7 +7019,10 @@ async function applyControl(codex, kandan, topic, instanceId, options, allowedCw
       const codexThreadId = extractStartedThreadId(response);
       const workDescription = normalizedWorkDescription(control.workDescription);
       if (codexThreadId !== undefined && developerPrompt !== undefined) {
-        await postVisibleDeveloperPrompt(kandan, topic, control, developerPrompt);
+        await postVisibleDeveloperPrompt(kandan, topic, control, developerPrompt, codexThreadId);
+      }
+      if (codexThreadId !== undefined && onStartedThread !== undefined) {
+        await onStartedThread(control, cwd.cwd);
       }
       if (codexThreadId !== undefined && workDescription !== undefined) {
         await codex.request("turn/start", {
@@ -7078,7 +7151,7 @@ work in the approved project folder, keep preview servers reachable through the
 secure tunnel, and keep the Linzumi thread truthful.
 </task_reminder>`;
 }
-async function postVisibleDeveloperPrompt(kandan, topic, control, developerPrompt) {
+async function postVisibleDeveloperPrompt(kandan, topic, control, developerPrompt, codexThreadId) {
   const workspace = normalizedWorkDescription(control.workspace);
   const channel = normalizedWorkDescription(control.channel);
   const threadId = normalizedWorkDescription(control.threadId);
@@ -7093,8 +7166,11 @@ async function postVisibleDeveloperPrompt(kandan, topic, control, developerPromp
 
 ${developerPrompt}`,
     payload: {
-      local_codex_runner: {
-        event_type: "codex_start_instructions"
+      metadata: {
+        local_codex_runner: {
+          event_type: "codex_start_instructions",
+          codex_thread_id: codexThreadId
+        }
       }
     },
     client_message_id: `codex-start-instructions-${threadId}`
@@ -8836,7 +8912,7 @@ async function main(args) {
       process.stdout.write(connectGuideText());
       return;
     case "version":
-      process.stdout.write(`linzumi 0.0.28-beta
+      process.stdout.write(`linzumi 0.0.30-beta
 `);
       return;
     case "auth":
@@ -9343,7 +9419,7 @@ async function parseRunnerArgs(args, deps = {
     process.exit(0);
   }
   if (values.get("version") === true) {
-    process.stdout.write(`linzumi 0.0.28-beta
+    process.stdout.write(`linzumi 0.0.30-beta
 `);
     process.exit(0);
   }

package/package.json

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