@linzumi/cli 0.0.42-beta → 0.0.44-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.42-beta --version
+npx -y @linzumi/cli@0.0.44-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -2461,6 +2461,8 @@ function shellCommandTokens(command) {
 var codexTypingHeartbeatMs = 5000;
 var defaultStreamFlushIntervalMs = 150;
 var maxForwardedTurnIds = 64;
+var maxClaimedKandanMessageKeys = 1024;
+var claimedKandanMessageKeys = new Set;
 async function attachChannelSession(args) {
   const session = args.options.channelSession;
   const chatTopic = `chat:${session.workspaceSlug}:${session.channelSlug}`;
@@ -2609,6 +2611,7 @@ async function attachChannelSession(args) {
       clearPendingStreamFlushTimers(state);
       rejectPendingApprovalRequests(state, new Error("runner closed"));
       await stopCodexTyping(args, state);
+      releaseKandanMessageClaims(state);
     }
   };
 }
@@ -2650,6 +2653,7 @@ function initialChannelSessionState(cursor, rootSeq, kandanThreadId, codexThread
     forwardedTurnIds: new Set,
     forwardingTurnIds: new Set,
     retryableTurnIds: new Set,
+    claimedKandanMessageKeys: new Set,
     localTuiTurnIds: new Set,
     mirroredTuiInputProjections: createBoundedCache(maxForwardedTurnIds),
     pendingTuiInputMirrors: new Map,
@@ -2667,6 +2671,7 @@ function initialChannelSessionState(cursor, rootSeq, kandanThreadId, codexThread
     pendingApprovalRequests: new Map,
     approvalPromptChain: Promise.resolve(),
     pendingPortForwardRequests: new Map,
+    portForwardPreviousProcessingStates: new Map,
     queuedPortForwardCandidates: new Map,
     approvedForwardPorts: new Set,
     approvedForwardTargets: new Map,
@@ -2991,6 +2996,9 @@ async function resolvePendingPortForwardRequest(args, state, payloadContext, con
   state.pendingPortForwardRequests.delete(control.requestId);
   if (control.decision === "deny") {
     state.dismissedForwardTargets.set(request.port, approvedTargetFromRequest(request));
+    await publishForwardPortResolvedEvent(args, request, {
+      decision: "deny"
+    });
     await publishMessageStateForPortForwardResult(args, state, request, "failed");
     args.log("port_forward.request_denied", {
       request_id: control.requestId,
@@ -3010,7 +3018,10 @@ async function resolvePendingPortForwardRequest(args, state, payloadContext, con
     processName: processIdentity?.appName ?? null,
     processIconKey: processIdentity?.iconKey ?? null
   });
-  await publishForwardPortResolvedEvent(args, request, capabilities);
+  await publishForwardPortResolvedEvent(args, request, {
+    decision: "approve",
+    capabilities
+  });
   await publishMessageStateForPortForwardResult(args, state, request, "processed");
   await publishPortForwardReadyMessage(args, state, payloadContext, request);
   args.log("port_forward.request_approved", {
@@ -3095,12 +3106,14 @@ async function publishPortForwardPrompt(args, state, payloadContext, candidate)
     candidate
   });
   state.pendingPortForwardRequests.set(requestId, request);
+  if (state.activeProcessingState !== undefined) {
+    state.portForwardPreviousProcessingStates.set(requestId, state.activeProcessingState);
+  }
   const processIdentity = guessCanonicalProcessFromCommand(candidate.command);
   const processIconPath = processIdentity?.iconKey === undefined ? undefined : `/web/process-icons/${processIdentity.iconKey}.png`;
   const processName = processIdentity?.appName ?? label;
-  await publishForwardPortRequestedEvent(args, request);
-  await publishMessageState(args, state.kandanThreadId, sourceSeq, {
-    status: "processing",
+  state.activeProcessingState = {
+    seq: sourceSeq,
     reason: "awaiting approval",
     approval: {
       requestId,
@@ -3129,7 +3142,13 @@ async function publishPortForwardPrompt(args, state, payloadContext, candidate)
       allowedActorSlug: args.options.channelSession.listenUser,
       allowedActorUserId: args.options.channelSession.listenUser.toLowerCase() === (payloadContext.runnerIdentity.actorUsername ?? "").toLowerCase() ? payloadContext.runnerIdentity.actorUserId : undefined
     }
+  };
+  await publishMessageState(args, state.kandanThreadId, sourceSeq, {
+    status: "processing",
+    reason: "awaiting approval",
+    approval: state.activeProcessingState.approval
   });
+  await publishForwardPortRequestedEvent(args, state, request, processIdentity);
   args.log("port_forward.request_pending", {
     request_id: requestId,
     port: candidate.port,
@@ -3170,6 +3189,10 @@ async function expireLostPendingPortForwardRequest(args, state, payloadContext,
     return;
   }
   state.pendingPortForwardRequests.delete(request.requestId);
+  await publishForwardPortResolvedEvent(args, request, {
+    decision: "expired",
+    reason: "listener_exited"
+  });
   await publishMessageStateForPortForwardResult(args, state, request, "failed", "port_forward_listener_exited");
   args.log("port_forward.pending_request_expired", {
     request_id: request.requestId,
@@ -3216,17 +3239,23 @@ async function publishPortForwardReadyMessage(args, state, payloadContext, reque
     }
   }, args.log);
 }
-async function publishForwardPortRequestedEvent(args, request) {
+async function publishForwardPortRequestedEvent(args, state, request, processIdentity) {
   await pushOptional(args.kandan, args.topic, "forward_port_requested", {
     instanceId: args.instanceId,
     requestId: request.requestId,
+    sourceSeq: request.sourceSeq,
     port: request.port,
     pid: request.pid,
     command: request.command,
+    codexThreadId: state.codexThreadId ?? null,
+    kandanThreadId: state.kandanThreadId ?? null,
+    channelSlug: args.options.channelSession.channelSlug ?? null,
+    ...processIdentity?.appName === undefined ? {} : { processName: processIdentity.appName },
+    ...processIdentity?.iconKey === undefined ? {} : { processIconKey: processIdentity.iconKey },
     ...request.cwd === undefined ? {} : { cwd: request.cwd }
   }, args.log);
 }
-async function publishForwardPortResolvedEvent(args, request, capabilities) {
+async function publishForwardPortResolvedEvent(args, request, result) {
   await pushOptional(args.kandan, args.topic, "forward_port_resolved", {
     instanceId: args.instanceId,
     requestId: request.requestId,
@@ -3234,18 +3263,52 @@ async function publishForwardPortResolvedEvent(args, request, capabilities) {
     pid: request.pid,
     command: request.command,
     ...request.cwd === undefined ? {} : { cwd: request.cwd },
-    decision: "approve",
-    ...capabilities === undefined ? {} : { capabilities }
+    sourceSeq: request.sourceSeq,
+    decision: result.decision,
+    ...result.reason === undefined ? {} : { reason: result.reason },
+    ...result.capabilities === undefined ? {} : { capabilities: result.capabilities }
   }, args.log);
 }
 async function publishMessageStateForPortForwardResult(args, state, request, status, failedReason = "port_forward_denied") {
   if (state.kandanThreadId === undefined) {
     return;
   }
+  const previousProcessingState = state.portForwardPreviousProcessingStates.get(request.requestId);
+  state.portForwardPreviousProcessingStates.delete(request.requestId);
   const activeProcessingState = state.activeProcessingState;
   if (activeProcessingState !== undefined && activeProcessingState.seq === request.sourceSeq) {
-    await publishMessageState(args, state.kandanThreadId, request.sourceSeq, processingMessageStateFromActive(activeProcessingState), undefined, undefined, state.codexThreadId);
-    return;
+    const resolvingActiveApproval = activeProcessingState.reason === "awaiting approval" && activeProcessingState.approval.requestId === request.requestId;
+    if (resolvingActiveApproval) {
+      state.activeProcessingState = undefined;
+      if (previousProcessingState !== undefined && previousProcessingState.seq === request.sourceSeq) {
+        state.activeProcessingState = previousProcessingState;
+        await publishMessageState(args, state.kandanThreadId, request.sourceSeq, processingMessageStateFromActive(previousProcessingState), undefined, undefined, state.codexThreadId);
+        return;
+      }
+      switch (state.turn.status) {
+        case "active":
+        case "completing":
+          if (state.turn.queuedSeq === request.sourceSeq) {
+            state.activeProcessingState = {
+              seq: request.sourceSeq,
+              reason: "running terminal command"
+            };
+            await publishMessageState(args, state.kandanThreadId, request.sourceSeq, {
+              status: "processing",
+              reason: "running terminal command"
+            });
+            return;
+          }
+          break;
+        case "idle":
+        case "starting":
+          break;
+      }
+    }
+    if (!resolvingActiveApproval) {
+      await publishMessageState(args, state.kandanThreadId, request.sourceSeq, processingMessageStateFromActive(activeProcessingState), undefined, undefined, state.codexThreadId);
+      return;
+    }
   }
   switch (status) {
     case "processed":
@@ -3376,6 +3439,15 @@ async function handleKandanChatEvent(args, state, runnerIdentity, payloadContext
     });
     return;
   }
+  if (!claimKandanMessage(args, state, event)) {
+    args.log("kandan.message_ignored", {
+      seq: event.seq,
+      actor_slug: event.actorSlug ?? null,
+      actor_user_id: event.actorUserId ?? null,
+      reason: "duplicate_message_claim"
+    });
+    return;
+  }
   enqueuePendingKandanMessage(state.queue, {
     seq: event.seq,
     actorSlug: event.actorSlug,
@@ -3392,6 +3464,44 @@ async function handleKandanChatEvent(args, state, runnerIdentity, payloadContext
   await publishKandanMessageState(args, event, { status: "queued" });
   await drainKandanMessageQueue(args, state, payloadContext);
 }
+function kandanMessageClaimKey(args, threadId, seq) {
+  const session = args.options.channelSession;
+  return [
+    args.options.runnerId,
+    args.instanceId,
+    session.workspaceSlug,
+    session.channelSlug,
+    threadId,
+    String(seq)
+  ].join(":");
+}
+function claimKandanMessage(args, state, event) {
+  const threadId = event.threadId;
+  if (threadId === undefined) {
+    return true;
+  }
+  const key = kandanMessageClaimKey(args, threadId, event.seq);
+  if (claimedKandanMessageKeys.has(key)) {
+    return false;
+  }
+  claimedKandanMessageKeys.add(key);
+  state.claimedKandanMessageKeys.add(key);
+  if (state.claimedKandanMessageKeys.size > maxClaimedKandanMessageKeys) {
+    const overflow = state.claimedKandanMessageKeys.size - maxClaimedKandanMessageKeys;
+    const expiredKeys = Array.from(state.claimedKandanMessageKeys).slice(0, overflow);
+    for (const expiredKey of expiredKeys) {
+      state.claimedKandanMessageKeys.delete(expiredKey);
+      claimedKandanMessageKeys.delete(expiredKey);
+    }
+  }
+  return true;
+}
+function releaseKandanMessageClaims(state) {
+  for (const key of state.claimedKandanMessageKeys) {
+    claimedKandanMessageKeys.delete(key);
+  }
+  state.claimedKandanMessageKeys.clear();
+}
 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");
@@ -3554,7 +3664,16 @@ async function drainKandanMessageQueue(args, state, payloadContext) {
           new_codex_thread_id: newCodexThreadId
         });
         await postCodexThreadReboundMessage(args, state, payloadContext, oldCodexThreadId, newCodexThreadId);
-        state.pendingReconnectContextInjection = await fetchReconnectContextInjection(args, state);
+        try {
+          state.pendingReconnectContextInjection = await fetchReconnectContextInjection(args, state);
+        } catch (contextError) {
+          state.pendingReconnectContextInjection = undefined;
+          args.log("codex.thread_reconnect_context_failed", {
+            kandan_thread_id: state.kandanThreadId,
+            codex_thread_id: newCodexThreadId,
+            message: contextError instanceof Error ? contextError.message : String(contextError)
+          });
+        }
         requeuePendingKandanMessageFront(state.queue, next);
         state.turn = { status: "idle" };
         await drainKandanMessageQueue(args, state, payloadContext);
@@ -4913,6 +5032,9 @@ async function refreshActiveProcessingState(args, state, turnId, reason) {
   if (state.activeProcessingState?.seq === seq && state.activeProcessingState.reason === reason) {
     return;
   }
+  if (state.activeProcessingState?.seq === seq && state.activeProcessingState.reason === "awaiting approval") {
+    return;
+  }
   state.activeProcessingState = { seq, reason };
   await publishMessageState(args, state.kandanThreadId, seq, {
     status: "processing",
@@ -4924,6 +5046,14 @@ async function refreshActiveProcessingHeartbeat(args, state) {
   if (activeProcessingState === undefined || state.kandanThreadId === undefined) {
     return;
   }
+  if (activeProcessingState.reason === "awaiting approval") {
+    switch (activeProcessingState.approval.kind) {
+      case "local_runner_port_forward":
+        return;
+      default:
+        break;
+    }
+  }
   await publishMessageState(args, state.kandanThreadId, activeProcessingState.seq, processingMessageStateFromActive(activeProcessingState), undefined, undefined, state.codexThreadId);
 }
 function clearActiveProcessingState(state, seq) {
@@ -8133,7 +8263,7 @@ function realpathOrResolved(pathValue) {
 }
 
 // src/version.ts
-var linzumiCliVersion = "0.0.42-beta";
+var linzumiCliVersion = "0.0.44-beta";
 var linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
 
 // src/runnerLock.ts
@@ -8502,6 +8632,8 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   const allowedForwardPorts = options.allowedForwardPorts ?? [];
   const liveForwardPorts = new Set(allowedForwardPorts);
   const managedForwardPorts = new Set;
+  const kandanControlPort = explicitUrlPort(options.kandanUrl);
+  const suppressedForwardPorts = () => suppressedForwardPortsForRunner(kandanControlPort, managedForwardPorts);
   const forwardPortAttributions = new Map;
   const setForwardPortAttribution = (port, attribution) => {
     forwardPortAttributions.set(port, {
@@ -8509,7 +8641,8 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       codexThreadId: attribution.codexThreadId ?? null,
       channelSlug: attribution.channelSlug ?? null,
       processName: attribution.processName ?? null,
-      processIconKey: attribution.processIconKey ?? null
+      processIconKey: attribution.processIconKey ?? null,
+      localEditor: attribution.localEditor === true
     });
   };
   const clearForwardPortAttribution = (port) => {
@@ -8523,7 +8656,8 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       codexThreadId: attribution?.codexThreadId ?? null,
       channelSlug: attribution?.channelSlug ?? null,
       processName: attribution?.processName ?? null,
-      processIconKey: attribution?.processIconKey ?? null
+      processIconKey: attribution?.processIconKey ?? null,
+      localEditor: attribution?.localEditor === true
     };
   });
   const allowedCwds = { value: [...options.allowedCwds] };
@@ -8534,11 +8668,35 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     value: { status: "disabled" }
   };
   const localEditorGeneration = { value: 0 };
+  const localEditorForwardState = {
+    watcher: undefined,
+    approvedPorts: new Set,
+    approvedTargets: new Map,
+    dismissedTargets: new Map,
+    pendingRequests: new Map,
+    queuedCandidates: new Map
+  };
   cleanup.actions.push(() => {
     if (localEditorState.value.status === "running") {
       localEditorState.value.process.kill("SIGINT");
       localEditorState.value.collaboration?.process.kill("SIGINT");
     }
+    localEditorForwardState.watcher?.close();
+  });
+  const pendingEditorForwardPortRequests = () => Array.from(localEditorForwardState.pendingRequests.values()).sort((left, right) => left.port - right.port).map((request) => {
+    const processIdentity = guessCanonicalProcessFromCommand(request.command);
+    const label = processIdentity?.appName ?? portForwardPromptLabel(approvedTargetFromRequest(request));
+    return {
+      requestId: request.requestId,
+      port: request.port,
+      pid: request.pid,
+      command: request.command,
+      ...request.cwd === undefined ? {} : { cwd: request.cwd },
+      summary: `Make ${label} on port ${request.port} accessible on Linzumi?`,
+      reason: portForwardPromptReason(approvedTargetFromRequest(request)),
+      ...processIdentity?.appName === undefined ? {} : { processName: processIdentity.appName },
+      ...processIdentity?.iconKey === undefined ? {} : { processIconKey: processIdentity.iconKey }
+    };
   });
   const capabilitiesPayload = () => ({
     codexAppServer: true,
@@ -8550,6 +8708,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     portForwarding: liveForwardPorts.size > 0,
     allowedPorts: Array.from(liveForwardPorts).sort((left, right) => left - right),
     forwardedPortAttributions: buildForwardPortAttributionPayload(),
+    pendingEditorForwardPortRequests: pendingEditorForwardPortRequests(),
     toolStatus: options.dependencyStatus === undefined ? null : dependencyStatusPayload(options.dependencyStatus),
     editorRuntime: options.dependencyStatus?.editorRuntime === undefined ? null : dependencyStatusPayload(options.dependencyStatus).editorRuntime,
     ...localEditorCapabilities(options.editorRuntime, allowedCwds.value, localEditorState.value)
@@ -8561,6 +8720,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   const joinPayload = () => ({
     clientName: "kandan-local-codex-runner",
     clientId,
+    runnerPid: process.pid,
     version: linzumiCliVersion,
     workspace: runnerWorkspaceSlug(options) ?? null,
     channel: options.channelSession?.channelSlug ?? null,
@@ -8598,12 +8758,204 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       });
     });
   };
+  const pushEditorPortForwardEvent = (event, payload) => {
+    kandan.push(topic, event, payload).catch((error) => {
+      log(`kandan.${event}_push_failed`, {
+        message: error instanceof Error ? error.message : String(error)
+      });
+    });
+  };
+  const revokeEditorForwardPort = (port, reason) => {
+    const target = localEditorForwardState.approvedTargets.get(port);
+    localEditorForwardState.approvedPorts.delete(port);
+    localEditorForwardState.approvedTargets.delete(port);
+    liveForwardPorts.delete(port);
+    clearForwardPortAttribution(port);
+    pushEditorPortForwardEvent("forward_port_revoked", {
+      instanceId,
+      port,
+      ...target === undefined ? {} : {
+        pid: target.pid,
+        command: target.command,
+        ...target.cwd === undefined ? {} : { cwd: target.cwd }
+      },
+      reason,
+      capabilities: revocationCapabilities(capabilitiesPayload(), port)
+    });
+  };
+  const clearEditorPortForwarding = (reason) => {
+    localEditorForwardState.watcher?.close();
+    localEditorForwardState.watcher = undefined;
+    localEditorForwardState.pendingRequests.clear();
+    localEditorForwardState.queuedCandidates.clear();
+    const revokedPorts = Array.from(localEditorForwardState.approvedPorts);
+    for (const port of revokedPorts) {
+      revokeEditorForwardPort(port, reason);
+    }
+    localEditorForwardState.dismissedTargets.clear();
+    return revokedPorts;
+  };
+  const drainQueuedEditorPortForwardPrompt = () => {
+    if (localEditorForwardState.pendingRequests.size > 0 || localEditorForwardState.queuedCandidates.size === 0) {
+      return;
+    }
+    const next = Array.from(localEditorForwardState.queuedCandidates.values()).sort((left, right) => left.port - right.port)[0];
+    if (next === undefined) {
+      return;
+    }
+    localEditorForwardState.queuedCandidates.delete(next.port);
+    publishEditorPortForwardPrompt(next);
+    if (localEditorForwardState.pendingRequests.size === 0) {
+      drainQueuedEditorPortForwardPrompt();
+    }
+  };
+  const publishEditorPortForwardPrompt = (candidate) => {
+    const review = reviewPortForwardCandidate({
+      candidate,
+      threadBound: true,
+      suppressedPorts: new Set(suppressedForwardPorts()),
+      approvedPorts: localEditorForwardState.approvedPorts,
+      approvedTargets: localEditorForwardState.approvedTargets,
+      dismissedTargets: localEditorForwardState.dismissedTargets,
+      pendingRequests: Array.from(localEditorForwardState.pendingRequests.values())
+    });
+    switch (review.type) {
+      case "skip":
+        return;
+      case "remember_approved_target":
+        localEditorForwardState.approvedTargets.set(review.target.port, review.target);
+        return;
+      case "revoke_and_prompt":
+        if (localEditorForwardState.pendingRequests.size > 0) {
+          localEditorForwardState.queuedCandidates.set(candidate.port, candidate);
+          return;
+        }
+        revokeEditorForwardPort(review.revoked.port, review.reason);
+        break;
+      case "prompt":
+        if (localEditorForwardState.pendingRequests.size > 0) {
+          localEditorForwardState.queuedCandidates.set(candidate.port, candidate);
+          return;
+        }
+        break;
+    }
+    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 === undefined ? {} : { cwd: request.cwd },
+      ...processIdentity?.appName === undefined ? {} : { processName: processIdentity.appName },
+      ...processIdentity?.iconKey === undefined ? {} : { processIconKey: processIdentity.iconKey },
+      capabilities: capabilitiesPayload()
+    });
+  };
+  const expireLostEditorPortForwardCandidate = (candidate) => {
+    const queuedCandidate = localEditorForwardState.queuedCandidates.get(candidate.port);
+    if (queuedCandidate !== undefined && sameForwardCandidate(queuedCandidate, candidate)) {
+      localEditorForwardState.queuedCandidates.delete(candidate.port);
+      return;
+    }
+    const pendingRequest = localEditorForwardState.pendingRequests.get(candidate.port);
+    if (pendingRequest !== undefined && sameForwardCandidate(approvedTargetFromRequest(pendingRequest), candidate)) {
+      localEditorForwardState.pendingRequests.delete(candidate.port);
+      pushEditorPortForwardEvent("forward_port_revoked", {
+        instanceId,
+        port: candidate.port,
+        pid: candidate.pid,
+        command: candidate.command,
+        ...candidate.cwd === undefined ? {} : { cwd: candidate.cwd },
+        reason: "listener_exited",
+        capabilities: revocationCapabilities(capabilitiesPayload(), candidate.port)
+      });
+      drainQueuedEditorPortForwardPrompt();
+      return;
+    }
+    if (localEditorForwardState.approvedPorts.has(candidate.port)) {
+      revokeEditorForwardPort(candidate.port, "listener_exited");
+    }
+  };
+  const resolveEditorPortForwardRequest = (control) => {
+    const request = Array.from(localEditorForwardState.pendingRequests.values()).find((request2) => request2.requestId === control.requestId);
+    if (request === undefined) {
+      return;
+    }
+    localEditorForwardState.pendingRequests.delete(request.port);
+    if (control.decision === "deny") {
+      localEditorForwardState.dismissedTargets.set(request.port, approvedTargetFromRequest(request));
+      pushEditorPortForwardEvent("forward_port_resolved", {
+        instanceId,
+        requestId: request.requestId,
+        source: "local_editor",
+        port: request.port,
+        pid: request.pid,
+        command: request.command,
+        ...request.cwd === undefined ? {} : { cwd: request.cwd },
+        decision: "deny",
+        capabilities: capabilitiesPayload()
+      });
+      drainQueuedEditorPortForwardPrompt();
+      return { instanceId, ok: true };
+    }
+    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
+    });
+    pushEditorPortForwardEvent("forward_port_resolved", {
+      instanceId,
+      requestId: request.requestId,
+      source: "local_editor",
+      port: request.port,
+      pid: request.pid,
+      command: request.command,
+      ...request.cwd === undefined ? {} : { cwd: request.cwd },
+      decision: "approve",
+      capabilities: capabilitiesPayload()
+    });
+    drainQueuedEditorPortForwardPrompt();
+    return { instanceId, ok: true, port: request.port };
+  };
+  const startLocalEditorPortForwardWatcher = (state) => {
+    if (state.process.pid === undefined) {
+      log("port_forward.local_editor_watch_skipped", {
+        reason: "editor_pid_missing"
+      });
+      return;
+    }
+    localEditorForwardState.watcher?.close();
+    localEditorForwardState.watcher = startPortForwardWatcher({
+      rootPid: state.process.pid,
+      onCandidate: publishEditorPortForwardPrompt,
+      onCandidateLost: expireLostEditorPortForwardCandidate,
+      onError: (error) => {
+        log("port_forward.local_editor_watch_failed", {
+          message: error.message
+        });
+      }
+    });
+  };
   const watchLocalEditorExit = (state, generation, initialStatusPushed) => {
     const handleExit = () => {
       if (localEditorGeneration.value !== generation || localEditorState.value.status !== "running" || localEditorState.value.process !== state.process) {
         return;
       }
       localEditorState.value = { status: "disabled" };
+      const revokedEditorPorts = clearEditorPortForwarding("editor_exited");
       liveForwardPorts.delete(state.port);
       managedForwardPorts.delete(state.port);
       if (state.collaboration !== undefined) {
@@ -8616,7 +8968,11 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
         cwd: state.cwd,
         capabilities: {
           ...capabilitiesPayload(),
-          revokedPorts: state.collaboration === undefined ? [state.port] : [state.port, state.collaboration.serverPort]
+          revokedPorts: state.collaboration === undefined ? [state.port, ...revokedEditorPorts] : [
+            state.port,
+            state.collaboration.serverPort,
+            ...revokedEditorPorts
+          ]
         }
       });
     };
@@ -8674,7 +9030,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       launchTui: options.launchTui,
       enablePortForwardWatch: true,
       initialForwardPorts: allowedForwardPorts,
-      suppressedForwardPorts: () => Array.from(managedForwardPorts),
+      suppressedForwardPorts,
       onForwardPortApproved: (port, attribution) => {
         liveForwardPorts.add(port);
         setForwardPortAttribution(port, attribution);
@@ -8729,7 +9085,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
         launchTui: false,
         enablePortForwardWatch: true,
         initialForwardPorts: allowedForwardPorts,
-        suppressedForwardPorts: () => Array.from(managedForwardPorts),
+        suppressedForwardPorts,
         onForwardPortApproved: (port, attribution) => {
           liveForwardPorts.add(port);
           setForwardPortAttribution(port, attribution);
@@ -8900,6 +9256,11 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
         if (result.ok) {
           localEditorGeneration.value += 1;
           const editorGeneration = localEditorGeneration.value;
+          const restartedEditorRevokedPorts = localEditorState.value.status === "running" ? [
+            localEditorState.value.port,
+            ...localEditorState.value.collaboration === undefined ? [] : [localEditorState.value.collaboration.serverPort],
+            ...clearEditorPortForwarding("editor_restarted")
+          ] : [];
           if (localEditorState.value.status === "running") {
             liveForwardPorts.delete(localEditorState.value.port);
             managedForwardPorts.delete(localEditorState.value.port);
@@ -8919,10 +9280,14 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
             instanceId,
             requestId: control.requestId,
             ok: true,
-            capabilities: capabilitiesPayload(),
+            capabilities: {
+              ...capabilitiesPayload(),
+              ...restartedEditorRevokedPorts.length === 0 ? {} : { revokedPorts: restartedEditorRevokedPorts }
+            },
             ...result.event
           });
           if (result.state.status === "running") {
+            startLocalEditorPortForwardWatcher(result.state);
             watchLocalEditorExit(result.state, editorGeneration, initialStatusPushed);
           }
           return initialStatusPushed;
@@ -8955,6 +9320,17 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       pushHeartbeat();
       return;
     }
+    if (isResolvePortForwardRequestControl(control)) {
+      const response = resolveEditorPortForwardRequest(control);
+      if (response !== undefined) {
+        kandan.push(topic, "codex_response", response).catch((error) => {
+          log("kandan.control_response_push_failed", {
+            message: error instanceof Error ? error.message : String(error)
+          });
+        });
+        return;
+      }
+    }
     if (isSetPortForwardEnabledControl(control)) {
       switch (control.enabled) {
         case true:
@@ -8964,6 +9340,8 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
           liveForwardPorts.delete(control.port);
           managedForwardPorts.delete(control.port);
           clearForwardPortAttribution(control.port);
+          localEditorForwardState.approvedPorts.delete(control.port);
+          localEditorForwardState.approvedTargets.delete(control.port);
           kandan.push(topic, "forward_port_revoked", {
             instanceId,
             port: control.port,
@@ -9155,6 +9533,24 @@ function codexTuiArgs(codexUrl, codexThreadId, session, fast) {
   const overrides = codexTuiConfigArgs(session, fast);
   return codexThreadId === undefined ? ["--remote", codexUrl, ...overrides] : ["resume", "--remote", codexUrl, ...overrides, codexThreadId];
 }
+function suppressedForwardPortsForRunner(kandanControlPort, managedForwardPorts) {
+  const suppressedPorts = new Set(managedForwardPorts);
+  if (kandanControlPort !== undefined) {
+    suppressedPorts.add(kandanControlPort);
+  }
+  return Array.from(suppressedPorts).sort((left, right) => left - right);
+}
+function explicitUrlPort(url) {
+  const parsed = new URL(url);
+  if (parsed.port === "") {
+    return;
+  }
+  const port = Number.parseInt(parsed.port, 10);
+  if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+    throw new Error(`invalid Kandan URL port: ${url}`);
+  }
+  return port;
+}
 function codexTuiConfigArgs(session, fast) {
   const modelArgs = session?.model === undefined ? [] : ["--model", session.model];
   const reasoningArgs = session?.reasoningEffort === undefined ? [] : ["-c", `model_reasoning_effort="${session.reasoningEffort}"`];
@@ -9571,6 +9967,9 @@ function isUpdateRunnerConfigControl(control) {
 function isSetPortForwardEnabledControl(control) {
   return control.type === "set_port_forward_enabled" && Number.isInteger(control.port) && control.port > 0 && control.port <= 65535;
 }
+function isResolvePortForwardRequestControl(control) {
+  return control.type === "resolve_port_forward_request" && typeof control.requestId === "string" && (control.decision === "approve" || control.decision === "deny");
+}
 function normalizeAllowedCwds(values) {
   return Array.from(new Set(values.flatMap((value) => {
     const normalized = value.trim();

package/package.json

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