@linzumi/cli 0.0.39-beta → 0.0.40-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.39-beta --version
+npx -y @linzumi/cli@0.0.40-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -1,15 +1,16 @@
 // src/index.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { existsSync as existsSync10, readFileSync as readFileSync9, realpathSync as realpathSync5 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync9, realpathSync as realpathSync6 } from "node:fs";
 import { homedir as homedir9 } from "node:os";
-import { resolve as resolve8 } from "node:path";
+import { resolve as resolve9 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/runner.ts
 import { spawn as spawn6 } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
+import { realpathSync as realpathSync4 } from "node:fs";
 import { hostname as hostname2 } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join6, resolve as resolve5 } from "node:path";
 
 // src/channelSessionSupport.ts
 import { spawnSync } from "node:child_process";
@@ -2544,7 +2545,10 @@ function initialChannelSessionState(cursor, rootSeq, kandanThreadId, codexThread
     webSearchProgressForwardChain: Promise.resolve(),
     typingHeartbeat: undefined,
     typingHeartbeatInFlight: false,
-    runtimeSettings: runtimeSettingsFromOptions(options)
+    runtimeSettings: runtimeSettingsFromOptions(options),
+    pendingRuntimeSettingsResume: false,
+    runtimeSettingsGeneration: 0,
+    runtimeSettingsResumeChain: Promise.resolve()
   };
 }
 async function handleLostPortForwardCandidate(args, state, payloadContext, candidate) {
@@ -2682,7 +2686,7 @@ async function handleChannelSessionControl(args, state, payloadContext, control)
     interruptedQueuedMessages: interrupted.ok ? interrupted.selectedCount : 0
   };
 }
-function updateSessionSettings(args, state, control) {
+async function updateSessionSettings(args, state, control) {
   if (state.codexThreadId !== control.threadId) {
     return;
   }
@@ -2694,6 +2698,8 @@ function updateSessionSettings(args, state, control) {
     };
   }
   state.runtimeSettings = mergeRuntimeSettings(state.runtimeSettings, control);
+  state.pendingRuntimeSettingsResume = true;
+  state.runtimeSettingsGeneration += 1;
   publishRuntimeSettings(args, state).catch((error) => {
     args.log("kandan.session_settings_publish_failed", {
       message: error instanceof Error ? error.message : String(error)
@@ -2706,6 +2712,7 @@ function updateSessionSettings(args, state, control) {
     sandbox: state.runtimeSettings.sandbox ?? null,
     fast: state.runtimeSettings.fast ?? null
   });
+  await tryResumeCodexThreadForPendingRuntimeSettings(args, state);
   return {
     instanceId: args.instanceId,
     ok: true,
@@ -2716,6 +2723,71 @@ function updateSessionSettings(args, state, control) {
     fast: state.runtimeSettings.fast ?? null
   };
 }
+async function resumeCodexThreadForPendingRuntimeSettings(args, state) {
+  const requestedGeneration = state.runtimeSettingsGeneration;
+  const previousResume = state.runtimeSettingsResumeChain.catch(() => {
+    return;
+  });
+  const resume = previousResume.then(() => performCodexThreadResumeForPendingRuntimeSettings(args, state, requestedGeneration));
+  state.runtimeSettingsResumeChain = resume.then(() => {
+    return;
+  }, () => {
+    return;
+  });
+  return await resume;
+}
+async function performCodexThreadResumeForPendingRuntimeSettings(args, state, requestedGeneration) {
+  if (state.pendingRuntimeSettingsResume !== true || state.closed || state.turn.status !== "idle" || localTuiTurnIsActive(state)) {
+    return true;
+  }
+  const codexThreadId = state.codexThreadId;
+  if (codexThreadId === undefined) {
+    return true;
+  }
+  if (state.runtimeSettingsGeneration !== requestedGeneration) {
+    return false;
+  }
+  const resumeGeneration = requestedGeneration;
+  const resumeSettings = state.runtimeSettings;
+  const runtimeOptions = runtimeOptionsForSettings(args.options, resumeSettings);
+  const resumeParams = {
+    threadId: codexThreadId,
+    ...codexThreadRuntimeOverrides(runtimeOptions)
+  };
+  args.log("codex.session_settings_resume_requested", {
+    codex_thread_id: codexThreadId,
+    model: resumeSettings.model ?? null,
+    reasoning_effort: resumeSettings.reasoningEffort ?? null,
+    approval_policy: resumeSettings.approvalPolicy ?? null,
+    sandbox: resumeSettings.sandbox ?? null,
+    fast: resumeSettings.fast ?? null,
+    generation: resumeGeneration
+  });
+  const resumed = await args.codex.request("thread/resume", resumeParams);
+  if ("error" in resumed) {
+    throw new Error(`failed to resume Codex thread with updated settings: ${resumed.error.message}`);
+  }
+  if (state.pendingRuntimeSettingsResume === true && state.runtimeSettingsGeneration === resumeGeneration) {
+    state.pendingRuntimeSettingsResume = false;
+  }
+  args.log("codex.session_settings_resume_completed", {
+    codex_thread_id: codexThreadId,
+    generation: resumeGeneration,
+    current_generation: state.runtimeSettingsGeneration,
+    pending: state.pendingRuntimeSettingsResume
+  });
+  return state.pendingRuntimeSettingsResume !== true;
+}
+async function tryResumeCodexThreadForPendingRuntimeSettings(args, state) {
+  try {
+    return await resumeCodexThreadForPendingRuntimeSettings(args, state);
+  } catch (error) {
+    args.log("codex.session_settings_resume_failed", {
+      message: error instanceof Error ? error.message : String(error)
+    });
+    return false;
+  }
+}
 async function resolvePendingCodexApprovalRequest(args, state, control) {
   if (state.codexThreadId !== control.threadId) {
     return;
@@ -3277,6 +3349,10 @@ async function drainKandanMessageQueue(args, state, payloadContext) {
   if (state.closed || state.turn.status !== "idle" || localTuiTurnIsActive(state)) {
     return;
   }
+  const resumed = await tryResumeCodexThreadForPendingRuntimeSettings(args, state);
+  if (!resumed) {
+    return;
+  }
   const next = dequeuePendingKandanMessage(state.queue);
   if (next === undefined) {
     return;
@@ -3602,11 +3678,17 @@ async function forwardCompletedCodexTurn(args, state, turnId, payloadContext) {
     if (completingActiveTurn && state.turn.status === "completing" && state.turn.turnId === turnId) {
       state.turn = { status: "idle" };
       await stopCodexTyping(args, state);
-      await drainKandanMessageQueue(args, state, payloadContext);
+      const resumed = await tryResumeCodexThreadForPendingRuntimeSettings(args, state);
+      if (resumed) {
+        await drainKandanMessageQueue(args, state, payloadContext);
+      }
     }
     if (completingLocalTuiTurn && !completingActiveTurn) {
       await stopCodexTyping(args, state);
-      await drainKandanMessageQueue(args, state, payloadContext);
+      const resumed = await tryResumeCodexThreadForPendingRuntimeSettings(args, state);
+      if (resumed) {
+        await drainKandanMessageQueue(args, state, payloadContext);
+      }
     }
   }
 }
@@ -6271,7 +6353,6 @@ function codeServerSandboxProfile(options, codeServerBinDir) {
     "/etc",
     "/private/etc",
     "/opt/homebrew",
-    "/dev",
     ...options.codeServerRuntimeRoot === undefined ? [] : sandboxPathAliases(options.codeServerRuntimeRoot),
     codeServerBinDir
   ]);
@@ -6294,6 +6375,7 @@ function codeServerSandboxProfile(options, codeServerBinDir) {
     "(allow file-map-executable)",
     '(allow file-read* (literal "/") (literal "/private") (literal "/private/var"))',
     `(allow file-read* ${readOnlyRoots.map(sandboxSubpath).join(" ")})`,
+    '(allow file-read* file-write* (subpath "/dev"))',
     `(allow file-read* file-write* ${readWriteRoots.map(sandboxSubpath).join(" ")})`
   ].join(`
 `);
@@ -7955,6 +8037,9 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     };
   });
   const allowedCwds = { value: [...options.allowedCwds] };
+  const missingAllowedCwds = {
+    value: normalizeAllowedCwds(options.missingAllowedCwds ?? [])
+  };
   const localEditorState = {
     value: { status: "disabled" }
   };
@@ -7970,7 +8055,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     codexRemoteTui: true,
     startInstance: allowedCwds.value.length > 0,
     allowedCwds: allowedCwds.value,
-    missingConfiguredAllowedCwds: options.missingConfiguredAllowedCwds ?? [],
+    missingAllowedCwds: missingAllowedCwds.value,
     allowedCwdSuggestions: allowedCwdSuggestions(options.cwd, allowedCwds.value),
     portForwarding: liveForwardPorts.size > 0,
     allowedPorts: Array.from(liveForwardPorts).sort((left, right) => left - right),
@@ -7985,7 +8070,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   const joinPayload = () => ({
     clientName: "kandan-local-codex-runner",
     version: "0.0.1",
-    workspace: options.channelSession?.workspaceSlug ?? options.workspaceSlug ?? null,
+    workspace: runnerWorkspaceSlug(options) ?? null,
     channel: options.channelSession?.channelSlug ?? null,
     capabilities: capabilitiesPayload()
   });
@@ -8055,6 +8140,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   const codexThreads = options.channelSession === undefined ? await discoverCodexThreads(codex, options.cwd) : [];
   const discoveredCodexThreads = { value: codexThreads };
   const runnerHost = hostname2();
+  const runtimeDefaults = runnerRuntimeDefaults(options);
   const instancePayload = {
     instanceId,
     codexUrl,
@@ -8062,8 +8148,10 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     cwd: options.cwd,
     hostname: runnerHost,
     codexThreads,
-    model: options.channelSession?.model ?? null,
-    reasoningEffort: options.channelSession?.reasoningEffort ?? null,
+    workspace: runnerWorkspaceSlug(options) ?? null,
+    channel: options.channelSession?.channelSlug ?? null,
+    model: runtimeDefaults.model ?? null,
+    reasoningEffort: runtimeDefaults.reasoningEffort ?? null,
     fast: options.fast ?? false
   };
   await kandan.push(topic, "instance_started", instancePayload);
@@ -8108,9 +8196,9 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     dynamicChannelSessions.clear();
   });
   const attachThreadSession = async (control, cwd, codexThreadId) => {
-    const workspaceSlug = normalizedWorkDescription(control.workspace);
-    const channelSlug = normalizedWorkDescription(control.channel);
-    const kandanThreadId = normalizedWorkDescription(control.threadId);
+    const workspaceSlug = optionalThreadControlField(control, "workspace");
+    const channelSlug = optionalThreadControlField(control, "channel");
+    const kandanThreadId = optionalThreadControlField(control, "threadId");
     if (workspaceSlug === undefined || channelSlug === undefined || kandanThreadId === undefined) {
       return;
     }
@@ -8171,13 +8259,13 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     codexUrl,
     cwd: options.cwd,
     hostname: runnerHost,
-    workspace: options.channelSession?.workspaceSlug ?? options.workspaceSlug ?? null,
+    workspace: runnerWorkspaceSlug(options) ?? null,
     channel: options.channelSession?.channelSlug ?? null,
     threadId: channelSession?.currentKandanThreadId() ?? null,
     codexThreadId: channelSession?.currentCodexThreadId() ?? null,
     codexThreads: discoveredCodexThreads.value,
-    model: options.channelSession?.model ?? null,
-    reasoningEffort: options.channelSession?.reasoningEffort ?? null,
+    model: runtimeDefaults.model ?? null,
+    reasoningEffort: runtimeDefaults.reasoningEffort ?? null,
     fast: options.fast ?? false,
     capabilities: capabilitiesPayload()
   });
@@ -8342,7 +8430,9 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       return;
     }
     if (isUpdateRunnerConfigControl(control)) {
-      allowedCwds.value = normalizeAllowedCwds(control.allowedCwds);
+      const updatedAllowedCwds = configuredAllowedCwds(control.allowedCwds);
+      allowedCwds.value = updatedAllowedCwds.allowedCwds;
+      missingAllowedCwds.value = updatedAllowedCwds.missingAllowedCwds;
       pushHeartbeat();
       return;
     }
@@ -8374,7 +8464,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       if (handled !== undefined) {
         return handled;
       }
-      return applyControl(codex, kandan, topic, instanceId, options, allowedCwds.value, control, attachThreadSession);
+      return applyControl(codex, kandan, topic, instanceId, options, allowedCwds.value, control, log, attachThreadSession);
     }).then((response) => {
       return kandan.push(topic, "codex_response", response);
     }).catch((error) => {
@@ -8450,7 +8540,7 @@ async function discoverCodexThreads(codex, cwd) {
 }
 function extractStartedThreadId(response) {
   if ("error" in response) {
-    return;
+    throw new Error(`thread/start failed: ${response.error.message}`);
   }
   return stringValue(objectValue(objectValue(response.result)?.thread)?.id);
 }
@@ -8560,7 +8650,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, onStartedThread) {
+async function applyControl(codex, kandan, topic, instanceId, options, allowedCwds, control, log, onStartedThread) {
   switch (control.type) {
     case "start_instance": {
       const cwd = resolveAllowedCwd(control.cwd, allowedCwds);
@@ -8572,56 +8662,71 @@ async function applyControl(codex, kandan, topic, instanceId, options, allowedCw
           error: cwd.reason
         };
       }
-      if (options.codexUrl === undefined) {
-        ensureCodexProjectTrusted(cwd.cwd);
+      const processingStatePayload = startInstanceMessageStatePayload(control, "processing", "starting Codex session");
+      if (processingStatePayload !== undefined) {
+        kandan.push(topic, "message_state", processingStatePayload).catch((error) => {
+          log("kandan.start_instance_processing_state_push_failed", {
+            message: error instanceof Error ? error.message : String(error)
+          });
+        });
       }
-      const developerPrompt = normalizedWorkDescription(control.developerPrompt);
-      const runtimeSettings = startInstanceRuntimeSettings(options, control);
-      const response = await codex.request("thread/start", {
-        cwd: cwd.cwd,
-        serviceName: "kandan-local-runner",
-        personality: "pragmatic",
-        developerInstructions: commanderDeveloperInstructions({
+      try {
+        if (options.codexUrl === undefined) {
+          ensureCodexProjectTrusted(cwd.cwd);
+        }
+        const developerPrompt = normalizedWorkDescription(control.developerPrompt);
+        const runtimeSettings = startInstanceRuntimeSettings(options, control);
+        const response = await codex.request("thread/start", {
           cwd: cwd.cwd,
-          developerPrompt
-        }),
-        ...runtimeSettings.model === undefined ? {} : { model: runtimeSettings.model },
-        ...runtimeSettings.reasoningEffort === undefined ? {} : { reasoningEffort: runtimeSettings.reasoningEffort },
-        ...runtimeSettings.approvalPolicy === undefined ? {} : { approvalPolicy: runtimeSettings.approvalPolicy },
-        ...runtimeSettings.sandbox === undefined ? {} : { sandbox: runtimeSettings.sandbox },
-        ...runtimeSettings.fast === true ? { serviceTier: "fast" } : {}
-      });
-      const codexThreadId = extractStartedThreadId(response);
-      const workDescription = normalizedWorkDescription(control.workDescription);
-      if (codexThreadId !== undefined && developerPrompt !== undefined) {
-        await postVisibleDeveloperPrompt(kandan, topic, control, developerPrompt, codexThreadId);
-      }
-      const startedThreadSession = codexThreadId !== undefined && onStartedThread !== undefined ? await onStartedThread(control, cwd.cwd, codexThreadId) : undefined;
-      if (codexThreadId !== undefined && workDescription !== undefined) {
-        const rootSeq = integerValue(control.rootSeq);
-        const sourceSeq = integerValue(control.sourceSeq) ?? rootSeq;
-        if (startedThreadSession !== undefined && sourceSeq !== undefined) {
-          const identity = identityFromAccessToken(options.token);
-          await startedThreadSession.startThreadMessageTurn({
-            seq: sourceSeq,
-            body: workDescription,
-            actorSlug: identity.actorUsername,
-            actorUserId: identity.actorUserId
-          });
-        } else {
-          await codex.request("turn/start", {
-            threadId: codexThreadId,
-            input: [{ type: "text", text: workDescription }]
-          });
+          serviceName: "kandan-local-runner",
+          personality: "pragmatic",
+          developerInstructions: commanderDeveloperInstructions({
+            cwd: cwd.cwd,
+            developerPrompt
+          }),
+          ...runtimeSettings.model === undefined ? {} : { model: runtimeSettings.model },
+          ...runtimeSettings.reasoningEffort === undefined ? {} : { reasoningEffort: runtimeSettings.reasoningEffort },
+          ...runtimeSettings.approvalPolicy === undefined ? {} : { approvalPolicy: runtimeSettings.approvalPolicy },
+          ...runtimeSettings.sandbox === undefined ? {} : { sandbox: runtimeSettings.sandbox },
+          ...runtimeSettings.fast === true ? { serviceTier: "fast" } : {}
+        });
+        const codexThreadId = extractStartedThreadId(response);
+        const workDescription = normalizedWorkDescription(control.workDescription);
+        if (codexThreadId !== undefined && developerPrompt !== undefined) {
+          await postVisibleDeveloperPrompt(kandan, topic, control, developerPrompt, codexThreadId);
         }
+        const startedThreadSession = codexThreadId !== undefined && onStartedThread !== undefined ? await onStartedThread(control, cwd.cwd, codexThreadId) : undefined;
+        if (codexThreadId !== undefined && workDescription !== undefined) {
+          const rootSeq = integerValue(control.rootSeq);
+          const sourceSeq = integerValue(control.sourceSeq) ?? rootSeq;
+          if (startedThreadSession !== undefined && sourceSeq !== undefined) {
+            const identity = identityFromAccessToken(options.token);
+            await startedThreadSession.startThreadMessageTurn({
+              seq: sourceSeq,
+              body: workDescription,
+              actorSlug: identity.actorUsername,
+              actorUserId: identity.actorUserId
+            });
+          } else {
+            await codex.request("turn/start", {
+              threadId: codexThreadId,
+              input: [{ type: "text", text: workDescription }]
+            });
+          }
+        }
+        return {
+          instanceId,
+          controlType: control.type,
+          cwd: cwd.cwd,
+          matchedRoot: cwd.matchedRoot,
+          response
+        };
+      } catch (error) {
+        try {
+          await publishStartInstanceMessageState(kandan, topic, control, "failed", "failed to start Codex session");
+        } catch (_publishError) {}
+        throw error;
       }
-      return {
-        instanceId,
-        controlType: control.type,
-        cwd: cwd.cwd,
-        matchedRoot: cwd.matchedRoot,
-        response
-      };
     }
     case "reconnect_thread": {
       const cwd = resolveAllowedCwd(control.cwd, allowedCwds);
@@ -8786,9 +8891,9 @@ secure tunnel, and keep the Linzumi thread truthful.
 </task_reminder>`;
 }
 async function postVisibleDeveloperPrompt(kandan, topic, control, developerPrompt, codexThreadId) {
-  const workspace = normalizedWorkDescription(control.workspace);
-  const channel = normalizedWorkDescription(control.channel);
-  const threadId = normalizedWorkDescription(control.threadId);
+  const workspace = optionalThreadControlField(control, "workspace");
+  const channel = optionalThreadControlField(control, "channel");
+  const threadId = optionalThreadControlField(control, "threadId");
   if (workspace === undefined || channel === undefined || threadId === undefined) {
     return;
   }
@@ -8810,24 +8915,80 @@ ${developerPrompt}`,
     client_message_id: `codex-start-instructions-${threadId}`
   });
 }
+async function publishStartInstanceMessageState(kandan, topic, control, status, reason) {
+  const payload = startInstanceMessageStatePayload(control, status, reason);
+  if (payload === undefined) {
+    return;
+  }
+  await kandan.push(topic, "message_state", payload);
+}
+function startInstanceMessageStatePayload(control, status, reason) {
+  const rootSeq = integerValue(control.rootSeq);
+  const sourceSeq = integerValue(control.sourceSeq) ?? rootSeq;
+  if (sourceSeq === undefined) {
+    return;
+  }
+  const workspace = requiredStartInstanceControlField(control, "workspace");
+  const channel = requiredStartInstanceControlField(control, "channel");
+  const threadId = requiredStartInstanceControlField(control, "threadId");
+  return {
+    workspace,
+    channel,
+    thread_id: threadId,
+    seq: sourceSeq,
+    status,
+    reason
+  };
+}
+function requiredStartInstanceControlField(control, field) {
+  return requiredThreadControlField(control, field);
+}
+function requiredThreadControlField(control, field) {
+  const value = optionalThreadControlField(control, field);
+  if (value === undefined) {
+    throw new Error(`${control.type} control missing ${field}`);
+  }
+  return value;
+}
+function optionalThreadControlField(control, field) {
+  const value = stringValue(control[field])?.trim();
+  if (value === undefined || value === "") {
+    return;
+  }
+  return value;
+}
 function startInstanceRuntimeSettings(options, control) {
-  const session = options.channelSession;
+  const defaults = runnerRuntimeDefaults(options);
   return {
-    model: control.model ?? session?.model,
-    reasoningEffort: control.reasoningEffort ?? session?.reasoningEffort,
-    approvalPolicy: control.approvalPolicy ?? session?.approvalPolicy,
-    sandbox: control.sandbox ?? session?.sandbox,
+    model: control.model ?? defaults.model,
+    reasoningEffort: control.reasoningEffort ?? defaults.reasoningEffort,
+    approvalPolicy: control.approvalPolicy ?? defaults.approvalPolicy,
+    sandbox: control.sandbox ?? defaults.sandbox,
     fast: control.fast ?? options.fast
   };
 }
 async function startOwnedCodexAppServer(options) {
   ensureCodexProjectTrusted(options.cwd);
+  const defaults = runnerRuntimeDefaults(options);
   return await startCodexAppServer(options.codexBin, options.cwd, {
-    model: options.channelSession?.model,
-    reasoningEffort: options.channelSession?.reasoningEffort,
+    model: defaults.model,
+    reasoningEffort: defaults.reasoningEffort,
     fast: options.fast
   });
 }
+function runnerWorkspaceSlug(options) {
+  return options.channelSession?.workspaceSlug ?? options.workspaceSlug;
+}
+function runnerRuntimeDefaults(options) {
+  const session = options.channelSession;
+  const defaults = options.runtimeDefaults;
+  return {
+    model: defaults?.model ?? session?.model,
+    reasoningEffort: defaults?.reasoningEffort ?? session?.reasoningEffort,
+    approvalPolicy: defaults?.approvalPolicy ?? session?.approvalPolicy,
+    sandbox: defaults?.sandbox ?? session?.sandbox
+  };
+}
 function isUpdateRunnerConfigControl(control) {
   return control.type === "update_runner_config";
 }
@@ -8840,6 +9001,30 @@ function normalizeAllowedCwds(values) {
     return normalized === "" ? [] : [normalized];
   })));
 }
+function configuredAllowedCwds(values) {
+  const allowedCwds = [];
+  const missingAllowedCwds = [];
+  for (const value of normalizeAllowedCwds(values)) {
+    const absolutePath = resolve5(expandUserPath(value));
+    try {
+      const realPath = realpathSync4(absolutePath);
+      allowedCwds.push(...realPath === absolutePath ? [realPath] : [realPath, absolutePath]);
+    } catch (error) {
+      if (isMissingAllowedCwdError(error)) {
+        missingAllowedCwds.push(absolutePath);
+        continue;
+      }
+      throw error;
+    }
+  }
+  return {
+    allowedCwds: normalizeAllowedCwds(allowedCwds),
+    missingAllowedCwds: normalizeAllowedCwds(missingAllowedCwds)
+  };
+}
+function isMissingAllowedCwdError(error) {
+  return typeof error === "object" && error !== null && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR" || error.code === "EACCES" || error.code === "ELOOP" || error.code === "EIO");
+}
 function allowedCwdSuggestions(cwd, allowedCwds) {
   return normalizeAllowedCwds([cwd, ...allowedCwds]);
 }
@@ -8988,14 +9173,14 @@ import {
   existsSync as existsSync5,
   mkdirSync as mkdirSync6,
   readFileSync as readFileSync4,
-  realpathSync as realpathSync4,
+  realpathSync as realpathSync5,
   writeFileSync as writeFileSync5
 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { dirname as dirname5, resolve as resolve5 } from "node:path";
+import { dirname as dirname5, resolve as resolve6 } from "node:path";
 function localConfigPath(env = process.env) {
   const override = env.LINZUMI_CONFIG_FILE;
-  return override !== undefined && override.trim() !== "" ? resolve5(expandUserPath(override)) : resolve5(homedir6(), ".linzumi", "config.json");
+  return override !== undefined && override.trim() !== "" ? resolve6(expandUserPath(override)) : resolve6(homedir6(), ".linzumi", "config.json");
 }
 function readLocalConfig(path = localConfigPath()) {
   if (!existsSync5(path)) {
@@ -9010,32 +9195,36 @@ function readLocalConfig(path = localConfigPath()) {
     allowedCwds: uniqueStrings(parsed.allowedCwds)
   };
 }
-function readConfiguredAllowedCwdState(path = localConfigPath()) {
+function readConfiguredAllowedCwdDetails(path = localConfigPath()) {
   const allowedCwds = [];
-  const missingCwds = [];
+  const missingAllowedCwds = [];
   for (const cwd of readLocalConfig(path).allowedCwds) {
+    const absolutePath = resolve6(expandUserPath(cwd));
     try {
-      const absolutePath = resolve5(expandUserPath(cwd));
-      const realPath = realpathSync4(absolutePath);
+      const realPath = realpathSync5(absolutePath);
       allowedCwds.push(...realPath === absolutePath ? [realPath] : [realPath, absolutePath]);
-    } catch (_error) {
-      missingCwds.push(cwd);
+    } catch (error) {
+      if (isMissingPathError(error)) {
+        missingAllowedCwds.push(absolutePath);
+        continue;
+      }
+      throw error;
     }
   }
   return {
     allowedCwds: uniqueStrings(allowedCwds),
-    missingCwds: uniqueStrings(missingCwds)
+    missingAllowedCwds: uniqueStrings(missingAllowedCwds)
   };
 }
 function addAllowedCwd(pathValue, path = localConfigPath()) {
-  const normalizedPath = realpathSync4(resolve5(expandUserPath(pathValue)));
+  const normalizedPath = realpathSync5(resolve6(expandUserPath(pathValue)));
   const config = readLocalConfig(path);
   const allowedCwds = uniqueStrings([...config.allowedCwds, normalizedPath]);
   writeLocalConfig({ version: 1, allowedCwds }, path);
   return allowedCwds;
 }
 function removeAllowedCwd(pathValue, path = localConfigPath()) {
-  const requestedPath = resolve5(expandUserPath(pathValue));
+  const requestedPath = resolve6(expandUserPath(pathValue));
   const normalizedRequest = realpathOrResolved(requestedPath);
   const config = readLocalConfig(path);
   const allowedCwds = config.allowedCwds.filter((cwd) => {
@@ -9058,11 +9247,14 @@ function uniqueStrings(values) {
     ...new Set(values.map((value) => value.trim()).filter((value) => value !== ""))
   ];
 }
+function isMissingPathError(error) {
+  return typeof error === "object" && error !== null && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR" || error.code === "EACCES" || error.code === "ELOOP" || error.code === "EIO");
+}
 function realpathOrResolved(pathValue) {
   try {
-    return realpathSync4(resolve5(expandUserPath(pathValue)));
+    return realpathSync5(resolve6(expandUserPath(pathValue)));
   } catch (_error) {
-    return resolve5(expandUserPath(pathValue));
+    return resolve6(expandUserPath(pathValue));
   }
 }
 
@@ -9460,7 +9652,7 @@ async function runClaim(command, deps) {
     workspaceName: stringValue(response.workspace_name),
     channelId: stringValue(response.channel_id),
     ownerUsername: stringValue(response.owner_username),
-    channelUrl: requiredString(response, "channel_url"),
+    channelUrl: stringValue(response.channel_url),
     loginUrl: requiredString(response, "login_url"),
     supportChannelId: requiredString(response, "support_channel_id"),
     supportChannelUrl: requiredString(response, "support_channel_url"),
@@ -9479,8 +9671,10 @@ async function runClaim(command, deps) {
   deps.stdout.write(`login_url: ${tokenFile.loginUrl}
 `);
   writeHumanLoginUrlWarning(deps);
-  deps.stdout.write(`channel_url: ${tokenFile.channelUrl}
+  if (tokenFile.channelUrl !== undefined) {
+    deps.stdout.write(`channel_url: ${tokenFile.channelUrl}
 `);
+  }
   deps.stdout.write(`support_channel_id: ${tokenFile.supportChannelId}
 `);
   deps.stdout.write(`support_channel_url: ${tokenFile.supportChannelUrl}
@@ -9749,7 +9943,7 @@ function readStoredAgentTokenFile(path, readTextFile = readOptionalTextFile) {
     workspaceName: stringValue(parsed.workspaceName),
     channelId: stringValue(parsed.channelId),
     ownerUsername: stringValue(parsed.ownerUsername),
-    channelUrl: requiredString(parsed, "channelUrl"),
+    channelUrl: stringValue(parsed.channelUrl),
     loginUrl: requiredString(parsed, "loginUrl"),
     supportChannelId: requiredString(parsed, "supportChannelId"),
     supportChannelUrl: stringValue(parsed.supportChannelUrl),
@@ -9803,7 +9997,7 @@ Launch target:
 
 // src/helloLinzumiProject.ts
 import { existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync7, rmSync as rmSync2, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname7, join as join9, resolve as resolve6 } from "node:path";
+import { dirname as dirname7, join as join9, resolve as resolve7 } from "node:path";
 import { fileURLToPath } from "node:url";
 var defaultHelloLinzumiProjectDir = "/tmp/hello_linzumi";
 var defaultHelloLinzumiProjectName = "hello_linzumi";
@@ -9837,10 +10031,10 @@ function resolveHelloProjectRoot(options) {
     throw new Error("linzumi init-hello-linzumi-demo-app accepts either --dir or --parent-dir/--name, not both");
   }
   if (options.rootPath !== undefined) {
-    return resolve6(options.rootPath);
+    return resolve7(options.rootPath);
   }
   const name = normalizeProjectName(options.name ?? defaultHelloLinzumiProjectName);
-  return resolve6(options.parentDir ?? defaultHelloLinzumiParentDir, name);
+  return resolve7(options.parentDir ?? defaultHelloLinzumiParentDir, name);
 }
 function normalizeProjectName(value) {
   const name = value.trim();
@@ -10375,7 +10569,7 @@ import {
   writeFileSync as writeFileSync8
 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { dirname as dirname8, join as join10, resolve as resolve7 } from "node:path";
+import { dirname as dirname8, join as join10, resolve as resolve8 } from "node:path";
 import { execFileSync, spawn as spawn7 } from "node:child_process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var connectedMarker = "Runner connected:";
@@ -10391,7 +10585,7 @@ function defaultCommanderLogFile(runnerId, statusDir = commanderStatusDir()) {
 function startCommanderDaemon(options) {
   const statusDir = options.statusDir ?? commanderStatusDir();
   const statusFile = commanderStatusFile(options.runnerId, statusDir);
-  const logFile = resolve7(options.logFile ?? defaultCommanderLogFile(options.runnerId, statusDir));
+  const logFile = resolve8(options.logFile ?? defaultCommanderLogFile(options.runnerId, statusDir));
   const entrypoint = options.entrypoint ?? currentEntrypoint();
   const nodeBin = options.nodeBin ?? process.execPath;
   const command = [
@@ -10588,7 +10782,7 @@ function safeRunnerId(runnerId) {
 }
 async function waitForFileChangeOrTimeout(path, deadline, now, ready2 = () => false) {
   const remaining = Math.max(0, deadline - now());
-  await new Promise((resolve8) => {
+  await new Promise((resolve9) => {
     let resolved = false;
     let watcher;
     const finish = () => {
@@ -10598,7 +10792,7 @@ async function waitForFileChangeOrTimeout(path, deadline, now, ready2 = () => fa
       resolved = true;
       watcher?.close();
       clearTimeout(timer);
-      resolve8();
+      resolve9();
     };
     const timer = setTimeout(finish, remaining);
     try {
@@ -10678,7 +10872,7 @@ function isMainModule() {
   if (scriptPath === undefined) {
     return false;
   }
-  return fileURLToPath3(import.meta.url) === resolve8(scriptPath);
+  return fileURLToPath3(import.meta.url) === resolve9(scriptPath);
 }
 async function main(args) {
   const parsed = parseCommand(args);
@@ -10687,7 +10881,7 @@ async function main(args) {
       process.stdout.write(connectGuideText());
       return;
     case "version":
-      process.stdout.write(`linzumi 0.0.39-beta
+      process.stdout.write(`linzumi 0.0.40-beta
 `);
       return;
     case "auth":
@@ -10840,7 +11034,7 @@ function runPathsCommand(args) {
       if (pathValue === undefined || pathValue.trim() === "") {
         throw new Error("missing path for linzumi paths add");
       }
-      const trustedPath = realpathSync5(resolve8(expandUserPath(pathValue)));
+      const trustedPath = realpathSync6(resolve9(expandUserPath(pathValue)));
       addAllowedCwd(pathValue);
       process.stdout.write(`Trusted ${trustedPath}
 `);
@@ -11030,6 +11224,7 @@ async function parseStartRunnerArgs(args, deps = {
     kandanUrl,
     token: targetToken,
     runnerId: stringValue3(values, "runner-id") ?? `runner-${randomUUID3()}`,
+    workspaceSlug: target.workspaceSlug,
     cwd,
     codexBin,
     codexUrl: stringValue3(values, "codex-url"),
@@ -11042,6 +11237,7 @@ async function parseStartRunnerArgs(args, deps = {
     editorRuntime: editorRuntime.runtime,
     socketFactory: trustedWebSocketFactory(kandanTlsTrustFromEnv()),
     dependencyStatus,
+    runtimeDefaults: runnerRuntimeDefaultsFromValues(values),
     channelSession: {
       workspaceSlug: target.workspaceSlug,
       channelSlug: target.channelSlug,
@@ -11073,12 +11269,23 @@ async function parseAgentRunnerArgs(args, deps = {
   const tokenFilePath = stringValue3(values, "agent-token-file") ?? defaultAgentTokenFilePath();
   const tokenFile = readStoredAgentTokenFile(tokenFilePath, deps.readTextFile);
   const channelSlug = tokenFile.channelId;
-  const listenUser = channelSlug === undefined ? undefined : stringValue3(values, "listen-user") ?? requiredStoredOwnerUsername(tokenFile.ownerUsername);
+  rejectWorkspaceCommanderThreadFlags(values, channelSlug);
+  const channelSession = channelSlug === undefined ? undefined : {
+    workspaceSlug: tokenFile.workspaceId,
+    channelSlug,
+    kandanThreadId: stringValue3(values, "linzumi-thread-id"),
+    listenUser: stringValue3(values, "listen-user") ?? requiredStoredOwnerUsername(tokenFile.ownerUsername),
+    model: stringValue3(values, "model"),
+    reasoningEffort: stringValue3(values, "reasoning-effort"),
+    sandbox: stringValue3(values, "sandbox"),
+    approvalPolicy: stringValue3(values, "approval-policy"),
+    streamFlushMs: positiveIntegerValue(values, "stream-flush-ms")
+  };
   const kandanUrl = stringValue3(values, "linzumi-url") ?? agentApiUrlToKandanUrl(tokenFile.apiUrl);
   const requestedCwdValue = cwdArg ?? stringValue3(values, "cwd");
   const requestedCwd = resolveUserPath(requestedCwdValue ?? process.cwd());
-  const configuredAllowedCwdState = values.has("allowed-cwd") || requestedCwdValue !== undefined ? { allowedCwds: [], missingCwds: [] } : readConfiguredAllowedCwdState();
-  const allowedCwds = values.has("allowed-cwd") ? assertConfiguredAllowedCwds(parseAllowedCwdList(stringValue3(values, "allowed-cwd"))) : requestedCwdValue === undefined ? configuredAllowedCwdState.allowedCwds : assertConfiguredAllowedCwds([requestedCwd]);
+  const configuredAllowedCwds2 = requestedCwdValue === undefined && !values.has("allowed-cwd") ? readConfiguredAllowedCwdDetails() : { allowedCwds: [], missingAllowedCwds: [] };
+  const allowedCwds = values.has("allowed-cwd") ? assertConfiguredAllowedCwds(parseAllowedCwdList(stringValue3(values, "allowed-cwd"))) : requestedCwdValue === undefined ? configuredAllowedCwds2.allowedCwds.length > 0 ? [...configuredAllowedCwds2.allowedCwds] : assertConfiguredAllowedCwds([requestedCwd]) : assertConfiguredAllowedCwds([requestedCwd]);
   const cwd = allowedCwds[0] ?? requestedCwd;
   const codexBin = stringValue3(values, "codex-bin") ?? "codex";
   const customCodeServerBin = stringValue3(values, "code-server-bin");
@@ -11105,6 +11312,7 @@ async function parseAgentRunnerArgs(args, deps = {
     kandanUrl,
     token: tokenFile.commanderToken,
     runnerId: stringValue3(values, "runner-id") ?? `agent-runner-${randomUUID3()}`,
+    workspaceSlug: tokenFile.workspaceId,
     cwd,
     codexBin,
     codexUrl: stringValue3(values, "codex-url"),
@@ -11112,24 +11320,14 @@ async function parseAgentRunnerArgs(args, deps = {
     fast: values.get("fast") === true,
     logFile: stringValue3(values, "log-file"),
     allowedCwds,
-    missingConfiguredAllowedCwds: configuredAllowedCwdState.missingCwds,
+    missingAllowedCwds: configuredAllowedCwds2.missingAllowedCwds,
     allowedForwardPorts: parseAllowedPortList(stringValue3(values, "forward-port")),
     codeServerBin: editorRuntime.codeServerBin,
     editorRuntime: editorRuntime.runtime,
     socketFactory: trustedWebSocketFactory(kandanTlsTrustFromEnv()),
     dependencyStatus,
-    workspaceSlug: tokenFile.workspaceId,
-    channelSession: channelSlug === undefined || listenUser === undefined ? undefined : {
-      workspaceSlug: tokenFile.workspaceId,
-      channelSlug,
-      kandanThreadId: stringValue3(values, "linzumi-thread-id"),
-      listenUser,
-      model: stringValue3(values, "model"),
-      reasoningEffort: stringValue3(values, "reasoning-effort"),
-      sandbox: stringValue3(values, "sandbox"),
-      approvalPolicy: stringValue3(values, "approval-policy"),
-      streamFlushMs: positiveIntegerValue(values, "stream-flush-ms")
-    }
+    runtimeDefaults: runnerRuntimeDefaultsFromValues(values),
+    channelSession
   };
 }
 function readAgentTokenTextFile(path) {
@@ -11147,6 +11345,12 @@ function rejectAgentRunnerTargetingFlags(values) {
     throw new Error(`linzumi commander uses the claimed human Commander token scope; remove ${unsupportedFlags.map((flag) => `--${flag}`).join(", ")}.`);
   }
 }
+function rejectWorkspaceCommanderThreadFlags(values, channelSlug) {
+  if (channelSlug !== undefined || !values.has("linzumi-thread-id")) {
+    return;
+  }
+  throw new Error("linzumi commander cannot bind --linzumi-thread-id because the agent token file has no channelId");
+}
 function requiredStoredOwnerUsername(ownerUsername) {
   if (ownerUsername !== undefined) {
     return ownerUsername;
@@ -11203,7 +11407,7 @@ async function parseRunnerArgs(args, deps = {
     process.exit(0);
   }
   if (values.get("version") === true) {
-    process.stdout.write(`linzumi 0.0.39-beta
+    process.stdout.write(`linzumi 0.0.40-beta
 `);
     process.exit(0);
   }
@@ -11211,10 +11415,8 @@ async function parseRunnerArgs(args, deps = {
   const kandanUrl = required(values, "linzumi-url");
   const cwd = stringValue3(values, "cwd") ?? process.cwd();
   const cwdAllowedCwds = assertConfiguredAllowedCwds([cwd]);
-  const configuredAllowedCwdState = values.has("allowed-cwd") ? {
-    allowedCwds: assertConfiguredAllowedCwds(parseAllowedCwdList(stringValue3(values, "allowed-cwd"))),
-    missingCwds: []
-  } : readConfiguredAllowedCwdState();
+  const localConfiguredAllowedCwds = values.has("allowed-cwd") ? { allowedCwds: [], missingAllowedCwds: [] } : readConfiguredAllowedCwdDetails();
+  const configuredAllowedCwds2 = values.has("allowed-cwd") ? assertConfiguredAllowedCwds(parseAllowedCwdList(stringValue3(values, "allowed-cwd"))) : [...localConfiguredAllowedCwds.allowedCwds];
   const codexBin = stringValue3(values, "codex-bin") ?? "codex";
   const customCodeServerBin = stringValue3(values, "code-server-bin");
   const explicitToken = stringValue3(values, "token");
@@ -11254,17 +11456,26 @@ async function parseRunnerArgs(args, deps = {
     launchTui: values.get("launch-tui") === true,
     fast: values.get("fast") === true,
     logFile: stringValue3(values, "log-file"),
-    allowedCwds: Array.from(new Set([...cwdAllowedCwds, ...configuredAllowedCwdState.allowedCwds])),
-    missingConfiguredAllowedCwds: configuredAllowedCwdState.missingCwds,
+    allowedCwds: Array.from(new Set([...cwdAllowedCwds, ...configuredAllowedCwds2])),
+    missingAllowedCwds: localConfiguredAllowedCwds.missingAllowedCwds,
     allowedForwardPorts: parseAllowedPortList(stringValue3(values, "forward-port")),
     codeServerBin: editorRuntime.codeServerBin,
     editorRuntime: editorRuntime.runtime,
     socketFactory: trustedWebSocketFactory(kandanTlsTrustFromEnv()),
     dependencyStatus,
     workspaceSlug: channelSession?.workspaceSlug ?? singleWorkspaceScopeFromAccessToken(token),
+    runtimeDefaults: runnerRuntimeDefaultsFromValues(values),
     channelSession
   };
 }
+function runnerRuntimeDefaultsFromValues(values) {
+  return {
+    model: stringValue3(values, "model"),
+    reasoningEffort: stringValue3(values, "reasoning-effort"),
+    approvalPolicy: stringValue3(values, "approval-policy"),
+    sandbox: stringValue3(values, "sandbox")
+  };
+}
 function strictFlagValues(args, definitions = flagDefinitions) {
   const values = new Map;
   for (let index = 0;index < args.length; index += 1) {
@@ -11359,9 +11570,9 @@ function resolveUserPath(pathValue) {
     return homedir9();
   }
   if (pathValue.startsWith("~/")) {
-    return resolve8(homedir9(), pathValue.slice(2));
+    return resolve9(homedir9(), pathValue.slice(2));
   }
-  return resolve8(pathValue);
+  return resolve9(pathValue);
 }
 function parseChannelSession(values, token, target) {
   if (target === undefined) {
@@ -11645,10 +11856,10 @@ Usage:
 
 What it does:
   Starts this computer as the claimed human's scoped Linzumi Commander. The command
-  reads ~/.linzumi/agent-token.json, uses its workspace/channel scope, reads
-  trusted folders from ~/.linzumi/config.json when no folder is passed, and
-  listens only to the owning human recorded during claim unless --listen-user is
-  passed.
+  reads ~/.linzumi/agent-token.json, connects to its workspace even when no
+  channel is assigned, reads trusted folders from ~/.linzumi/config.json when no
+  folder is passed, and uses the token's channel scope for channel-bound startup
+  when one is present.
 
 Options:
   --agent-token-file <path>   Agent token cache, default ~/.linzumi/agent-token.json

package/package.json

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