@linzumi/cli 0.0.65-beta → 0.0.66-beta

package/README.md

@@ -33,10 +33,6 @@ Paste this into your terminal:
 npx -y @linzumi/cli@latest signup
 ```
 
-![Linzumi signup terminal flow showing local checks, selected repos, and started agents](docs/images/signup-terminal.png)
-
-![Linzumi Mission Control with started agent work in a split-pane workspace](docs/images/signup-mission-control.png)
-
 Linzumi will ask for your email, send you a sign-in code, help you pick
 the repos where Codex may work, start useful first tasks, and open
 Mission Control in your browser with the work already running.
@@ -62,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.65-beta --version
+npx -y @linzumi/cli@0.0.66-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -2175,6 +2175,7 @@ function startPortForwardWatcher(options) {
   const scanListenSockets = options.scanListenSockets ?? readListenSocketRows;
   const scanProcessCwds = options.scanProcessCwds ?? readProcessCwdRows;
   const nowMs = options.nowMs ?? Date.now;
+  const commanderBoundPids = validPidSet(options.commanderBoundPids ?? []);
   const candidateStabilityByPort = /* @__PURE__ */ new Map();
   const emittedByPort = /* @__PURE__ */ new Map();
   const missingByPort = /* @__PURE__ */ new Map();
@@ -2187,11 +2188,13 @@ function startPortForwardWatcher(options) {
     void Promise.resolve().then(async () => {
       const descendants = descendantPidSet(scanProcesses(), rootPid);
       const sockets = scanListenSockets();
-      const candidatePids = sockets.filter((socket) => descendants.has(socket.pid)).map((socket) => socket.pid);
+      const observedPids = /* @__PURE__ */ new Set([...descendants, ...commanderBoundPids]);
+      const candidatePids = sockets.filter((socket) => observedPids.has(socket.pid)).map((socket) => socket.pid);
       const candidates = detectedForwardCandidates(
         sockets,
-        descendants,
-        scanProcessCwds(candidatePids)
+        observedPids,
+        scanProcessCwds(candidatePids),
+        commanderBoundPids
       );
       const scanTimeMs = nowMs();
       const stable = stableForwardCandidates(
@@ -2289,7 +2292,7 @@ function stableForwardCandidates(previousObservedByPort, candidates, nowMs, debo
   return { nextObservedByPort, stableCandidates };
 }
 function sameForwardCandidate(left, right) {
-  return left.port === right.port && left.pid === right.pid;
+  return left.port === right.port && left.pid === right.pid && normalizedPortKind(left.portKind) === normalizedPortKind(right.portKind);
 }
 function descendantPidSet(rows, rootPid) {
   const childrenByParent = /* @__PURE__ */ new Map();
@@ -2309,17 +2312,25 @@ function descendantPidSet(rows, rootPid) {
   }
   return descendants;
 }
-function detectedForwardCandidates(sockets, descendantPids, processCwds = /* @__PURE__ */ new Map()) {
+function detectedForwardCandidates(sockets, descendantPids, processCwds = /* @__PURE__ */ new Map(), commanderBoundPids = /* @__PURE__ */ new Set()) {
   return sockets.filter((socket) => descendantPids.has(socket.pid)).filter((socket) => socket.port > 0 && socket.port < 65536).sort((left, right) => left.port - right.port).map((socket) => {
     const cwd = processCwds.get(socket.pid);
+    const portKind = commanderBoundPids.size === 0 ? void 0 : commanderBoundPids.has(socket.pid) ? "commander_bound" : "descendant";
     return {
       port: socket.port,
       pid: socket.pid,
       command: socket.command,
+      ...portKind === void 0 ? {} : { portKind },
       ...cwd === void 0 ? {} : { cwd }
     };
   });
 }
+function validPidSet(pids) {
+  return new Set(pids.filter((pid) => Number.isInteger(pid) && pid > 0));
+}
+function normalizedPortKind(portKind) {
+  return portKind ?? "descendant";
+}
 function parseProcessRows(output) {
   return output.split("\n").map((line) => line.trim()).filter((line) => line !== "").map((line) => {
     const match = line.match(/^(\d+)\s+(\d+)\s+(.*)$/);
@@ -2453,7 +2464,7 @@ var defaultIntervalMs, defaultDebounceMs;
 var init_portForwardWatcher = __esm({
   "src/portForwardWatcher.ts"() {
     "use strict";
-    defaultIntervalMs = 2e3;
+    defaultIntervalMs = 1e3;
     defaultDebounceMs = 750;
   }
 });
@@ -2503,6 +2514,7 @@ function pendingRequestFromCandidate(options) {
     port: options.candidate.port,
     pid: options.candidate.pid,
     command: options.candidate.command,
+    ...options.candidate.portKind === void 0 ? {} : { portKind: options.candidate.portKind },
     ...options.candidate.cwd === void 0 ? {} : { cwd: options.candidate.cwd },
     sourceSeq: options.sourceSeq
   };
@@ -2512,6 +2524,7 @@ function approvedTargetFromRequest(request) {
     port: request.port,
     pid: request.pid,
     command: request.command,
+    ...request.portKind === void 0 ? {} : { portKind: request.portKind },
     ...request.cwd === void 0 ? {} : { cwd: request.cwd }
   };
 }
@@ -3726,13 +3739,7 @@ async function updateSessionSettings(args, state, payloadContext, control) {
     fast: state.runtimeSettings.fast ?? null,
     allow_port_forwarding_by_default: state.runtimeSettings.allowPortForwardingByDefault ?? null
   });
-  if (state.runtimeSettings.allowPortForwardingByDefault === true) {
-    await approvePendingPortForwardRequestsByDefault(
-      args,
-      state,
-      payloadContext
-    );
-  }
+  await approvePendingPortForwardRequestsByDefault(args, state, payloadContext);
   await tryResumeCodexThreadForPendingRuntimeSettings(args, state);
   return {
     instanceId: args.instanceId,
@@ -3964,7 +3971,8 @@ async function approvePortForwardRequest(args, state, request, options) {
     codexThreadId: state.codexThreadId ?? null,
     channelSlug: args.options.channelSession.channelSlug ?? null,
     processName: processIdentity?.appName ?? null,
-    processIconKey: processIdentity?.iconKey ?? null
+    processIconKey: processIdentity?.iconKey ?? null,
+    linzumiCliManaged: request.portKind === "commander_bound"
   });
   await publishForwardPortResolvedEvent(args, state, request, {
     decision: "approve",
@@ -4015,7 +4023,7 @@ async function publishPortForwardPrompt(args, state, payloadContext, candidate)
     dismissedTargets: state.dismissedForwardTargets,
     pendingRequests: Array.from(state.pendingPortForwardRequests.values())
   });
-  const allowByDefault = state.runtimeSettings.allowPortForwardingByDefault === true;
+  const allowByDefault = true;
   switch (review.type) {
     case "skip":
       return;
@@ -6969,7 +6977,7 @@ function mergeRuntimeSettings(current, update) {
     ),
     sandbox,
     fast: update.fast ?? current.fast,
-    allowPortForwardingByDefault: update.allowPortForwardingByDefault ?? current.allowPortForwardingByDefault
+    allowPortForwardingByDefault: true
   };
 }
 function mergeOptionalApprovalPolicyRuntimeSetting(current, update, sandbox) {
@@ -7989,7 +7997,9 @@ function linzumiMcpServerConfig(options) {
       options.kandanUrl,
       ...options.authFilePath === void 0 ? [] : ["--auth-file", options.authFilePath],
       ...options.delegationAuthFilePath === void 0 ? [] : ["--delegation-auth-file", options.delegationAuthFilePath],
-      ...options.ownerUsername === void 0 ? [] : ["--owner-username", options.ownerUsername]
+      ...options.ownerUsername === void 0 ? [] : ["--owner-username", options.ownerUsername],
+      "--mode",
+      options.operatingMode ?? "text"
     ],
     env: {
       ...options.accessToken === void 0 ? {} : { LINZUMI_MCP_ACCESS_TOKEN: options.accessToken }
@@ -11685,7 +11695,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.65-beta";
+    linzumiCliVersion = "0.0.66-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -12819,6 +12829,7 @@ import {
   rmSync as rmSync3,
   statSync
 } from "node:fs";
+import { createServer as createServer3 } from "node:http";
 import { homedir as homedir8, hostname as hostname2, tmpdir as tmpdir3 } from "node:os";
 import { dirname as dirname7, join as join11, resolve as resolve6 } from "node:path";
 async function runLocalCodexRunner(options) {
@@ -12876,7 +12887,8 @@ async function runThreadCodexWorker(options) {
   bindThreadCodexWorkerIpc(codex);
   process.send({
     type: "linzumi_thread_codex_worker_ready",
-    kandanThreadId: options.threadProcess.kandanThreadId
+    kandanThreadId: options.threadProcess.kandanThreadId,
+    commanderManagedPorts: commanderManagedPortsForStartedCodex(started)
   });
   await waitForThreadCodexWorkerStop(started.process);
   stop();
@@ -12888,6 +12900,12 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   const managedForwardPorts = /* @__PURE__ */ new Set();
   const kandanControlPort = explicitUrlPort(options.kandanUrl);
   const suppressedForwardPorts = () => suppressedForwardPortsForRunner(kandanControlPort, managedForwardPorts);
+  const commanderBoundE2eHttpProbe = shouldStartCommanderBoundForwardWatcher(
+    options
+  ) ? await startCommanderBoundE2eHttpProbe(log) : void 0;
+  if (commanderBoundE2eHttpProbe !== void 0) {
+    cleanup.actions.push(() => commanderBoundE2eHttpProbe.close());
+  }
   const forwardPortAttributions = /* @__PURE__ */ new Map();
   const setForwardPortAttribution = (port, attribution) => {
     forwardPortAttributions.set(port, {
@@ -12897,12 +12915,30 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       processName: attribution.processName ?? null,
       processIconKey: attribution.processIconKey ?? null,
       localEditor: attribution.localEditor === true,
-      agentProvider: attribution.agentProvider ?? null
+      agentProvider: attribution.agentProvider ?? null,
+      linzumiCliManaged: attribution.linzumiCliManaged === true
     });
   };
   const clearForwardPortAttribution = (port) => {
     forwardPortAttributions.delete(port);
   };
+  const markCommanderManagedForwardPort = (port, attribution = {}) => {
+    liveForwardPorts.add(port);
+    managedForwardPorts.add(port);
+    setForwardPortAttribution(port, {
+      processName: attribution.processName ?? null,
+      processIconKey: attribution.processIconKey ?? null,
+      agentProvider: attribution.agentProvider ?? null,
+      linzumiCliManaged: true
+    });
+  };
+  const clearCommanderManagedForwardPort = (port) => {
+    managedForwardPorts.delete(port);
+    clearForwardPortAttribution(port);
+    if (!allowedForwardPorts.includes(port)) {
+      liveForwardPorts.delete(port);
+    }
+  };
   const buildForwardPortAttributionPayload = () => Array.from(liveForwardPorts).sort((left, right) => left - right).map((port) => {
     const attribution = forwardPortAttributions.get(port);
     return {
@@ -12913,7 +12949,8 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       processName: attribution?.processName ?? null,
       processIconKey: attribution?.processIconKey ?? null,
       localEditor: attribution?.localEditor === true,
-      agentProvider: attribution?.agentProvider ?? null
+      agentProvider: attribution?.agentProvider ?? null,
+      linzumiCliManaged: attribution?.linzumiCliManaged === true || managedForwardPorts.has(port)
     };
   });
   const startupAllowedCwds = normalizeAllowedCwds(options.allowedCwds);
@@ -13034,6 +13071,16 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   if (codexUrl === void 0) {
     throw new Error("missing codex app-server websocket URL");
   }
+  if (started !== void 0) {
+    const appServerPort = explicitUrlPort(codexUrl);
+    if (appServerPort !== void 0) {
+      markCommanderManagedForwardPort(appServerPort, {
+        processName: "Codex app-server",
+        processIconKey: "codex",
+        agentProvider: "codex"
+      });
+    }
+  }
   const instanceId = `codex-${randomUUID3()}`;
   const publishLocalEditorStatus = (payload) => {
     void kandan.push(topic, "local_editor_status", payload).catch((error) => {
@@ -13049,6 +13096,18 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       });
     });
   };
+  const commanderBoundForwardWatcher = shouldStartCommanderBoundForwardWatcher(
+    options
+  ) ? startCommanderBoundForwardWatcher({
+    log,
+    instanceId,
+    markCommanderManagedForwardPort,
+    clearCommanderManagedForwardPort,
+    managedForwardPorts,
+    capabilitiesPayload,
+    pushForwardPortEvent: pushEditorPortForwardEvent
+  }) : void 0;
+  cleanup.actions.push(() => commanderBoundForwardWatcher?.close());
   const revokeEditorForwardPort = (port, reason) => {
     const target = localEditorForwardState.approvedTargets.get(port);
     localEditorForwardState.approvedPorts.delete(port);
@@ -13095,6 +13154,37 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       drainQueuedEditorPortForwardPrompt();
     }
   };
+  const approveEditorPortForwardCandidate = (candidate) => {
+    const request = pendingRequestFromCandidate({
+      requestId: `editor-port-forward-auto-${randomUUID3()}`,
+      sourceSeq: 0,
+      candidate
+    });
+    localEditorForwardState.approvedPorts.add(request.port);
+    localEditorForwardState.approvedTargets.set(
+      request.port,
+      approvedTargetFromRequest(request)
+    );
+    liveForwardPorts.add(request.port);
+    const processIdentity = guessCanonicalProcessFromCommand(request.command);
+    setForwardPortAttribution(request.port, {
+      localEditor: true,
+      processName: processIdentity?.appName ?? null,
+      processIconKey: processIdentity?.iconKey ?? null,
+      linzumiCliManaged: request.portKind === "commander_bound"
+    });
+    pushEditorPortForwardEvent("forward_port_resolved", {
+      instanceId,
+      requestId: request.requestId,
+      source: "local_editor",
+      port: request.port,
+      pid: request.pid,
+      command: request.command,
+      ...request.cwd === void 0 ? {} : { cwd: request.cwd },
+      decision: "approve",
+      capabilities: capabilitiesPayload()
+    });
+  };
   const publishEditorPortForwardPrompt = (candidate) => {
     const review = reviewPortForwardCandidate({
       candidate,
@@ -13117,15 +13207,9 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
         );
         return;
       case "revoke_and_prompt":
-        if (localEditorForwardState.pendingRequests.size > 0) {
-          localEditorForwardState.queuedCandidates.set(
-            candidate.port,
-            candidate
-          );
-          return;
-        }
         revokeEditorForwardPort(review.revoked.port, review.reason);
-        break;
+        approveEditorPortForwardCandidate(candidate);
+        return;
       case "replace_pending":
         localEditorForwardState.pendingRequests.delete(review.expired.port);
         pushEditorPortForwardEvent("forward_port_resolved", {
@@ -13140,44 +13224,12 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
           reason: review.reason,
           capabilities: capabilitiesPayload()
         });
-        if (localEditorForwardState.pendingRequests.size > 0) {
-          localEditorForwardState.queuedCandidates.set(
-            review.candidate.port,
-            review.candidate
-          );
-          return;
-        }
-        break;
+        approveEditorPortForwardCandidate(review.candidate);
+        return;
       case "prompt":
-        if (localEditorForwardState.pendingRequests.size > 0) {
-          localEditorForwardState.queuedCandidates.set(
-            candidate.port,
-            candidate
-          );
-          return;
-        }
-        break;
+        approveEditorPortForwardCandidate(candidate);
+        return;
     }
-    const requestId = `editor-port-forward-${randomUUID3()}`;
-    const request = pendingRequestFromCandidate({
-      requestId,
-      sourceSeq: 0,
-      candidate
-    });
-    localEditorForwardState.pendingRequests.set(request.port, request);
-    const processIdentity = guessCanonicalProcessFromCommand(candidate.command);
-    pushEditorPortForwardEvent("forward_port_requested", {
-      instanceId,
-      requestId,
-      source: "local_editor",
-      port: request.port,
-      pid: request.pid,
-      command: request.command,
-      ...request.cwd === void 0 ? {} : { cwd: request.cwd },
-      ...processIdentity?.appName === void 0 ? {} : { processName: processIdentity.appName },
-      ...processIdentity?.iconKey === void 0 ? {} : { processIconKey: processIdentity.iconKey },
-      capabilities: capabilitiesPayload()
-    });
   };
   const expireLostEditorPortForwardCandidate = (candidate) => {
     const queuedCandidate = localEditorForwardState.queuedCandidates.get(
@@ -13248,7 +13300,8 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     setForwardPortAttribution(request.port, {
       localEditor: true,
       processName: processIdentity?.appName ?? null,
-      processIconKey: processIdentity?.iconKey ?? null
+      processIconKey: processIdentity?.iconKey ?? null,
+      linzumiCliManaged: request.portKind === "commander_bound"
     });
     pushEditorPortForwardEvent("forward_port_resolved", {
       instanceId,
@@ -13320,6 +13373,50 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       capabilities: revocationCapabilities(capabilitiesPayload(), port)
     });
   };
+  const approveClaudeCodeForwardCandidate = async (session, candidate) => {
+    const sourceSeq = session.currentSourceSeq() ?? session.rootSeq;
+    if (sourceSeq === void 0) {
+      log("port_forward.claude_code_auto_approval_skipped", {
+        reason: "source_seq_missing",
+        port: candidate.port,
+        pid: candidate.pid
+      });
+      return;
+    }
+    const request = pendingRequestFromCandidate({
+      requestId: `claude-port-forward-auto-${randomUUID3()}`,
+      sourceSeq,
+      candidate
+    });
+    session.approvedPorts.add(request.port);
+    session.approvedTargets.set(
+      request.port,
+      approvedTargetFromRequest(request)
+    );
+    liveForwardPorts.add(request.port);
+    const processIdentity = guessCanonicalProcessFromCommand(request.command);
+    setForwardPortAttribution(request.port, {
+      kandanThreadId: session.threadId,
+      codexThreadId: session.sessionId,
+      channelSlug: session.channel,
+      processName: processIdentity?.appName ?? null,
+      processIconKey: processIdentity?.iconKey ?? null,
+      agentProvider: "claude-code",
+      linzumiCliManaged: request.portKind === "commander_bound"
+    });
+    await kandan.push(topic, "forward_port_resolved", {
+      instanceId,
+      requestId: request.requestId,
+      port: request.port,
+      pid: request.pid,
+      command: request.command,
+      ...request.cwd === void 0 ? {} : { cwd: request.cwd },
+      sourceSeq: request.sourceSeq,
+      decision: "approve",
+      agentProvider: "claude-code",
+      capabilities: capabilitiesPayload()
+    });
+  };
   const publishClaudeCodeForwardPortPrompt = async (session, candidate) => {
     const review = reviewPortForwardCandidate({
       candidate,
@@ -13337,16 +13434,13 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
         session.approvedTargets.set(review.target.port, review.target);
         return;
       case "revoke_and_prompt":
-        if (session.pendingRequests.size > 0) {
-          session.queuedCandidates.set(candidate.port, candidate);
-          return;
-        }
         await revokeClaudeCodeForwardPort(
           session,
           review.revoked.port,
           review.reason
         );
-        break;
+        await approveClaudeCodeForwardCandidate(session, candidate);
+        return;
       case "replace_pending":
         session.pendingRequests.delete(review.expired.requestId);
         await kandan.push(topic, "forward_port_resolved", {
@@ -13371,83 +13465,12 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
           reason: "port_forward_listener_changed",
           sessionId: session.sessionId
         });
-        if (session.pendingRequests.size > 0) {
-          session.queuedCandidates.set(review.candidate.port, review.candidate);
-          return;
-        }
-        break;
+        await approveClaudeCodeForwardCandidate(session, review.candidate);
+        return;
       case "prompt":
-        if (session.pendingRequests.size > 0) {
-          session.queuedCandidates.set(candidate.port, candidate);
-          return;
-        }
-        break;
-    }
-    const sourceSeq = session.currentSourceSeq() ?? session.rootSeq;
-    if (sourceSeq === void 0) {
-      log("port_forward.claude_code_prompt_skipped", {
-        reason: "source_seq_missing",
-        port: candidate.port,
-        pid: candidate.pid
-      });
-      return;
+        await approveClaudeCodeForwardCandidate(session, candidate);
+        return;
     }
-    const requestId = `claude-port-forward-${randomUUID3()}`;
-    const request = pendingRequestFromCandidate({
-      requestId,
-      sourceSeq,
-      candidate
-    });
-    session.pendingRequests.set(requestId, request);
-    const processIdentity = guessCanonicalProcessFromCommand(candidate.command);
-    const processName = processIdentity?.appName ?? portForwardPromptLabel(candidate);
-    await kandan.push(topic, "message_state", {
-      workspace: session.workspace,
-      channel: session.channel,
-      thread_id: session.threadId,
-      seq: sourceSeq,
-      status: "processing",
-      reason: "awaiting approval",
-      codex_thread_id: session.sessionId,
-      agent_provider: "claude-code",
-      approval_request_id: requestId,
-      approval_kind: "local_runner_port_forward",
-      approval_summary: `Make ${processName} on port ${candidate.port} accessible on Linzumi?`,
-      approval_reason: portForwardPromptReason(candidate),
-      approval_port: candidate.port,
-      approval_pid: candidate.pid,
-      approval_command: candidate.command,
-      ...candidate.cwd === void 0 ? {} : { approval_cwd: candidate.cwd },
-      ...processIdentity?.appName === void 0 ? {} : { approval_process_name: processIdentity.appName },
-      ...processIdentity?.iconKey === void 0 ? {} : { approval_process_icon_key: processIdentity.iconKey },
-      approval_choices: [
-        {
-          decision: "approve",
-          label: "Enable",
-          description: `Allow Linzumi to proxy Claude Code preview port ${candidate.port}.`
-        },
-        {
-          decision: "deny",
-          label: "Deny",
-          description: `Keep Claude Code preview port ${candidate.port} private.`
-        }
-      ]
-    });
-    await kandan.push(topic, "forward_port_requested", {
-      instanceId,
-      requestId,
-      sourceSeq,
-      port: candidate.port,
-      pid: candidate.pid,
-      command: candidate.command,
-      codexThreadId: session.sessionId,
-      kandanThreadId: session.threadId,
-      channelSlug: session.channel,
-      agentProvider: "claude-code",
-      ...candidate.cwd === void 0 ? {} : { cwd: candidate.cwd },
-      ...processIdentity?.appName === void 0 ? {} : { processName: processIdentity.appName },
-      ...processIdentity?.iconKey === void 0 ? {} : { processIconKey: processIdentity.iconKey }
-    });
   };
   const expireLostClaudeCodeForwardCandidate = (session, candidate) => {
     const queuedCandidate = session.queuedCandidates.get(candidate.port);
@@ -13570,7 +13593,8 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
         channelSlug: session.channel,
         processName: processIdentity?.appName ?? null,
         processIconKey: processIdentity?.iconKey ?? null,
-        agentProvider: "claude-code"
+        agentProvider: "claude-code",
+        linzumiCliManaged: request.portKind === "commander_bound"
       });
       void Promise.all([
         kandan.push(topic, "forward_port_resolved", {
@@ -13885,7 +13909,8 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
         initialForwardPorts: allowedForwardPorts,
         portForwardWatcher: channelSessionPortForwardWatcherOptions({
           rootPid: portForwardWatcherRootPid,
-          start: options.portForwardWatcher
+          start: options.portForwardWatcher,
+          commanderBoundPids: args.commanderBoundPids
         }),
         suppressedForwardPorts,
         onForwardPortApproved: (port, attribution) => {
@@ -13999,6 +14024,13 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       }
       throw error;
     }
+    for (const port of handle.commanderManagedPorts ?? []) {
+      markCommanderManagedForwardPort(port.port, {
+        processName: port.processName,
+        processIconKey: port.processIconKey,
+        agentProvider: port.agentProvider
+      });
+    }
     try {
       const threadCodex = handle.codex;
       const closeThreadCodex = once(() => threadCodex.close());
@@ -14031,7 +14063,10 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
         cwd: startedCwd,
         codexThreadId,
         sessionCodex: threadCodex,
-        portForwardWatcherRootPid: handle.processPid
+        portForwardWatcherRootPid: handle.processPid,
+        commanderBoundPids: (handle.commanderManagedPorts ?? []).flatMap(
+          (port) => port.pid === void 0 ? [] : [port.pid]
+        )
       });
       switch (control.type) {
         case "start_instance": {
@@ -16742,18 +16777,138 @@ function startInstanceRuntimeSettings(options, control) {
     ),
     sandbox,
     fast: control.fast ?? options.fast,
-    allowPortForwardingByDefault: control.allowPortForwardingByDefault ?? defaults.allowPortForwardingByDefault
+    allowPortForwardingByDefault: true
   };
 }
 function channelSessionPortForwardWatcherOptions(args) {
   if (args.rootPid === void 0 && args.start === void 0) {
     return void 0;
   }
+  const commanderBoundPids = [
+    process.pid,
+    ...args.rootPid === void 0 ? [] : [args.rootPid],
+    ...args.commanderBoundPids ?? []
+  ];
   return {
     ...args.rootPid === void 0 ? {} : { rootPid: args.rootPid },
+    ...commanderBoundPids.length === 0 ? {} : { commanderBoundPids },
     ...args.start === void 0 ? {} : { start: args.start }
   };
 }
+function shouldStartCommanderBoundForwardWatcher(options) {
+  return options.threadProcess?.role !== "thread" && options.codexUrl === void 0;
+}
+async function startCommanderBoundE2eHttpProbe(log) {
+  const rawPort = process.env.LINZUMI_E2E_COMMANDER_BOUND_HTTP_PORT;
+  if (rawPort === void 0 || rawPort.trim() === "") {
+    return void 0;
+  }
+  const port = strictTcpPortFromEnv(
+    rawPort,
+    "LINZUMI_E2E_COMMANDER_BOUND_HTTP_PORT"
+  );
+  const server = createServer3((_request, response) => {
+    response.writeHead(200, { "content-type": "text/plain; charset=utf-8" });
+    response.end("linzumi commander-bound probe\n");
+  });
+  await listenOnLoopback(server, port);
+  log("runner.e2e_commander_bound_http_probe_started", { port });
+  return {
+    port,
+    close: () => closeHttpServer(server)
+  };
+}
+function strictTcpPortFromEnv(rawValue, envName) {
+  const trimmed = rawValue.trim();
+  const port = Number.parseInt(trimmed, 10);
+  if (!/^\d+$/u.test(trimmed) || !Number.isInteger(port)) {
+    throw new Error(`${envName} must be an integer TCP port`);
+  }
+  if (port <= 0 || port > 65535) {
+    throw new Error(`${envName} must be between 1 and 65535`);
+  }
+  return port;
+}
+function listenOnLoopback(server, port) {
+  return new Promise((resolve11, reject) => {
+    const onError = (error) => {
+      server.off("listening", onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve11();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(port, "127.0.0.1");
+  });
+}
+function closeHttpServer(server) {
+  if (!server.listening) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve11, reject) => {
+    server.close((error) => {
+      if (error !== void 0) {
+        reject(error);
+        return;
+      }
+      resolve11();
+    });
+  });
+}
+function startCommanderBoundForwardWatcher(args) {
+  return startPortForwardWatcher({
+    rootPid: process.pid,
+    commanderBoundPids: [process.pid],
+    onCandidate: (candidate) => {
+      if (candidate.portKind !== "commander_bound") {
+        return;
+      }
+      if (args.managedForwardPorts.has(candidate.port)) {
+        return;
+      }
+      const processIdentity = guessCanonicalProcessFromCommand(
+        candidate.command
+      );
+      args.markCommanderManagedForwardPort(candidate.port, {
+        processName: processIdentity?.appName ?? portForwardPromptLabel(candidate),
+        processIconKey: processIdentity?.iconKey ?? "terminal"
+      });
+      args.pushForwardPortEvent("forward_port_resolved", {
+        instanceId: args.instanceId,
+        requestId: `commander-bound-${candidate.pid}-${candidate.port}`,
+        port: candidate.port,
+        decision: "approve",
+        capabilities: args.capabilitiesPayload()
+      });
+    },
+    onCandidateLost: (candidate) => {
+      if (candidate.portKind !== "commander_bound") {
+        return;
+      }
+      if (!args.managedForwardPorts.has(candidate.port)) {
+        return;
+      }
+      args.clearCommanderManagedForwardPort(candidate.port);
+      args.pushForwardPortEvent("forward_port_revoked", {
+        instanceId: args.instanceId,
+        requestId: `commander-bound-${candidate.pid}-${candidate.port}`,
+        port: candidate.port,
+        decision: "revoked",
+        reason: "listener_exited",
+        capabilities: revocationCapabilities(
+          args.capabilitiesPayload(),
+          candidate.port
+        )
+      });
+    },
+    onError: (error) => args.log("port_forward.commander_bound_watch_failed", {
+      message: error.message
+    })
+  });
+}
 function threadRunnerOptions(args) {
   const runtimeSettings = startInstanceRuntimeSettings(
     args.options,
@@ -16916,6 +17071,7 @@ async function spawnLocalThreadRunnerProcess(options) {
     kandanThreadId: ready2.kandanThreadId,
     codex: connectThreadCodexWorkerIpc(child),
     processPid: child.pid,
+    commanderManagedPorts: ready2.commanderManagedPorts,
     onExit: (listener) => {
       if (exitState.exited) {
         queueMicrotask(listener);
@@ -16982,7 +17138,49 @@ function threadRunnerReadyMessage(message, expectedKandanThreadId) {
   if (kandanThreadId !== expectedKandanThreadId) {
     throw new Error("thread Codex worker reported invalid ready payload");
   }
-  return { kandanThreadId };
+  return {
+    kandanThreadId,
+    commanderManagedPorts: commanderManagedPortRecords(
+      message.commanderManagedPorts
+    )
+  };
+}
+function commanderManagedPortRecords(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((entry) => {
+    if (!isJsonObject(entry)) {
+      return [];
+    }
+    const port = integerValue(entry.port);
+    if (port === void 0 || port < 1 || port > 65535) {
+      return [];
+    }
+    const pid = integerValue(entry.pid);
+    const processName = stringValue(entry.processName);
+    const processIconKey = stringValue(entry.processIconKey);
+    const agentProvider = providerKindValue(entry.agentProvider);
+    return [
+      {
+        port,
+        ...pid === void 0 ? {} : { pid },
+        ...processName === void 0 ? {} : { processName },
+        ...processIconKey === void 0 ? {} : { processIconKey },
+        ...agentProvider === void 0 ? {} : { agentProvider }
+      }
+    ];
+  });
+}
+function providerKindValue(value) {
+  switch (stringValue(value)) {
+    case "codex":
+      return "codex";
+    case "claude-code":
+      return "claude-code";
+    default:
+      return void 0;
+  }
 }
 function waitForThreadCodexWorkerStop(codexProcess) {
   return new Promise((resolve11) => {
@@ -17070,7 +17268,7 @@ function threadRunnerCliArgs(options) {
       "--approval-policy",
       options.runtimeDefaults?.approvalPolicy
     ),
-    ...options.runtimeDefaults?.allowPortForwardingByDefault === true ? ["--allow-port-forwarding-by-default"] : []
+    "--allow-port-forwarding-by-default"
   ];
 }
 function redactedThreadRunnerCliArgs(args) {
@@ -17107,7 +17305,8 @@ async function startOwnedCodexAppServer(options, args = { linzumiMcp: true }) {
           argsPrefix: mcpCommand.argsPrefix,
           kandanUrl: options.kandanUrl,
           authFilePath: mcpAuth.path,
-          ownerUsername: mcpOwnerUsername(options)
+          ownerUsername: mcpOwnerUsername(options),
+          operatingMode: "text"
         })
       ]
     });
@@ -17125,6 +17324,21 @@ async function startOwnedCodexAppServer(options, args = { linzumiMcp: true }) {
     throw error;
   }
 }
+function commanderManagedPortsForStartedCodex(started) {
+  const port = explicitUrlPort(started.url);
+  if (port === void 0) {
+    return [];
+  }
+  return [
+    {
+      port,
+      ...started.process.pid === void 0 ? {} : { pid: started.process.pid },
+      processName: "Codex app-server",
+      processIconKey: "codex",
+      agentProvider: "codex"
+    }
+  ];
+}
 function mcpOwnerUsername(options) {
   return options.channelSession?.listenUser ?? identityFromAccessToken(options.token).actorUsername;
 }
@@ -54468,14 +54682,19 @@ function createLinzumiMcpApiClient(options) {
   const fetchImpl = options.fetchImpl ?? fetch;
   const baseUrl = kandanHttpBaseUrl(options.kandanUrl);
   const apiPrefix = options.authMode === "personal-agent-delegation" ? "/api/v2/personal-agent-mcp" : "/api/v2/local-runner-mcp";
+  const operatingMode = options.operatingMode ?? "text";
   const request = async (method, path2, params) => {
     const url = new URL(path2, baseUrl);
+    const paramsWithMode = {
+      ...params,
+      operating_mode: operatingMode
+    };
     const requestInit = {
       method,
       headers: { authorization: `Bearer ${options.accessToken}` }
     };
     if (method === "GET") {
-      for (const [key, value] of Object.entries(params)) {
+      for (const [key, value] of Object.entries(paramsWithMode)) {
         if (value !== void 0 && value !== null) {
           url.searchParams.set(key, String(value));
         }
@@ -54485,7 +54704,7 @@ function createLinzumiMcpApiClient(options) {
         ...requestInit.headers,
         "content-type": "application/json"
       };
-      requestInit.body = JSON.stringify(params);
+      requestInit.body = JSON.stringify(paramsWithMode);
     }
     const response = await fetchImpl(url, requestInit);
     const parsed = await response.json();
@@ -54522,6 +54741,7 @@ var mcpFlagDefinitions = /* @__PURE__ */ new Map([
   ["workspace", { kind: "value" }],
   ["channel", { kind: "value" }],
   ["owner-username", { kind: "value" }],
+  ["mode", { kind: "value" }],
   ["format", { kind: "value" }],
   ["command", { kind: "value" }],
   ["include-token", { kind: "boolean" }],
@@ -54552,8 +54772,8 @@ function mcpHelpText() {
   return `Linzumi MCP
 
 Usage:
-  linzumi mcp server --api-url <url> [--workspace <slug> --channel <slug>]
-  linzumi mcp server --api-url <url> --delegation-auth-file <path>
+  linzumi mcp server --api-url <url> [--mode voice|text] [--workspace <slug> --channel <slug>]
+  linzumi mcp server --api-url <url> --delegation-auth-file <path> [--mode voice|text]
   linzumi mcp config --api-url <url> --format codex|claude-code [--include-token]
   linzumi mcp doctor --api-url <url> [--workspace <slug> --channel <slug>]
 
@@ -54589,10 +54809,12 @@ async function runMcpServer(args) {
     channelSlug: stringValue3(values, "channel")
   });
   const ownerUsername = stringValue3(values, "owner-username") ?? process.env.LINZUMI_MCP_OWNER_USERNAME;
+  const operatingMode = mcpOperatingMode(stringValue3(values, "mode"));
   const client = createLinzumiMcpApiClient({
     kandanUrl,
     accessToken: auth.accessToken,
-    authMode: auth.mode
+    authMode: auth.mode,
+    operatingMode
   });
   const server = new McpServer({
     name: "linzumi",
@@ -54709,6 +54931,7 @@ async function runMcpConfig(args) {
   const values = strictFlagValues(args);
   const kandanUrl = required(values, "api-url");
   const format = stringValue3(values, "format") ?? "codex";
+  const operatingMode = mcpOperatingMode(stringValue3(values, "mode"));
   const token = values.get("include-token") === true ? (await resolveMcpAuth({
     kandanUrl,
     explicitToken: stringValue3(values, "token") ?? process.env.LINZUMI_MCP_ACCESS_TOKEN,
@@ -54722,7 +54945,8 @@ async function runMcpConfig(args) {
     kandanUrl,
     accessToken: token,
     delegationAuthFilePath: stringValue3(values, "delegation-auth-file"),
-    ownerUsername: stringValue3(values, "owner-username") ?? process.env.LINZUMI_MCP_OWNER_USERNAME
+    ownerUsername: stringValue3(values, "owner-username") ?? process.env.LINZUMI_MCP_OWNER_USERNAME,
+    operatingMode
   });
   switch (format) {
     case "codex":
@@ -54763,7 +54987,8 @@ async function runMcpDoctor(args) {
       const client = createLinzumiMcpApiClient({
         kandanUrl,
         accessToken: auth.accessToken,
-        authMode: auth.mode
+        authMode: auth.mode,
+        operatingMode: mcpOperatingMode(stringValue3(values, "mode"))
       });
       await client.validateAuth();
       break;
@@ -54838,6 +55063,17 @@ function stringValue3(values, key) {
   const value = values.get(key);
   return typeof value === "string" && value.trim() !== "" ? value : void 0;
 }
+function mcpOperatingMode(value) {
+  switch (value) {
+    case void 0:
+      return "text";
+    case "voice":
+    case "text":
+      return value;
+    default:
+      throw new Error("--mode must be voice or text");
+  }
+}
 function required(values, key) {
   const value = stringValue3(values, key);
   if (value === void 0) {
@@ -55406,10 +55642,7 @@ async function parseStartRunnerArgs(args, deps = {
       reasoningEffort: stringValue5(values, "reasoning-effort"),
       sandbox: stringValue5(values, "sandbox"),
       approvalPolicy: stringValue5(values, "approval-policy"),
-      allowPortForwardingByDefault: booleanFlagValue(
-        values,
-        "allow-port-forwarding-by-default"
-      ),
+      allowPortForwardingByDefault: true,
       streamFlushMs: positiveIntegerValue2(values, "stream-flush-ms")
     }
   };
@@ -55446,10 +55679,7 @@ async function parseAgentRunnerArgs(args, deps = {
     reasoningEffort: stringValue5(values, "reasoning-effort"),
     sandbox: stringValue5(values, "sandbox"),
     approvalPolicy: stringValue5(values, "approval-policy"),
-    allowPortForwardingByDefault: booleanFlagValue(
-      values,
-      "allow-port-forwarding-by-default"
-    ),
+    allowPortForwardingByDefault: true,
     streamFlushMs: positiveIntegerValue2(values, "stream-flush-ms")
   };
   const kandanUrl = kandanUrlValue(values) ?? agentApiUrlToKandanUrl(tokenFile.apiUrl);
@@ -55689,10 +55919,7 @@ function runnerRuntimeDefaultsFromValues(values) {
     reasoningEffort: stringValue5(values, "reasoning-effort"),
     approvalPolicy: stringValue5(values, "approval-policy"),
     sandbox: stringValue5(values, "sandbox"),
-    allowPortForwardingByDefault: booleanFlagValue(
-      values,
-      "allow-port-forwarding-by-default"
-    )
+    allowPortForwardingByDefault: true
   };
 }
 function kandanUrlValue(values) {
@@ -55710,9 +55937,6 @@ function requiredKandanUrl(values) {
   }
   return value;
 }
-function booleanFlagValue(values, key) {
-  return values.get(key) === true ? true : void 0;
-}
 function strictFlagValues2(args, definitions = flagDefinitions) {
   const values = /* @__PURE__ */ new Map();
   for (let index = 0; index < args.length; index += 1) {
@@ -56006,8 +56230,6 @@ Codex:
   --reasoning-effort <value>  Reasoning effort requested for Codex and shown in Linzumi
   --sandbox <value>           Sandbox metadata shown in Linzumi
   --approval-policy <value>   Approval-policy metadata shown in Linzumi
-  --allow-port-forwarding-by-default
-                              Auto-approve detected port-forward candidates for started sessions
   --stream-flush-ms <ms>      Batch live Codex deltas before Linzumi persistence, default 150
   --fast                      Mark this runner as low-latency/fast in the availability message
   --log-file <path>           JSONL event log path, default ~/.linzumi/logs/runner-events.jsonl

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "0.0.65-beta",
+  "version": "0.0.66-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": {
@@ -10,7 +10,6 @@
     "README.md",
     "bin",
     "dist",
-    "docs/images",
     "scripts"
   ],
   "scripts": {