@linzumi/cli 0.0.110-beta → 0.0.111-beta

package/README.md

@@ -58,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.110-beta --version
+npx -y @linzumi/cli@0.0.111-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -5863,6 +5863,9 @@ function handleEvent(state, event, deps, effects) {
   }
   handleCodexNotification(state, event, deps, effects);
 }
+function modelInteractionMethod(method) {
+  return modelInteractionMethods.has(method);
+}
 function handleCodexNotification(state, event, deps, effects) {
   const method = event.notification.method;
   const params = event.notification.params ?? {};
@@ -5879,9 +5882,7 @@ function handleCodexNotification(state, event, deps, effects) {
   const explicitTurnId = notificationTurnId(params);
   const turnId = explicitTurnId ?? singleActiveTurnId(state);
   if (turnId === void 0) {
-    effects.push(
-      log("pipeline.loop.notification_without_turn", { method })
-    );
+    effects.push(log("pipeline.loop.notification_without_turn", { method }));
     return;
   }
   if (state.terminalTurnIds.has(turnId)) {
@@ -5902,6 +5903,10 @@ function handleCodexNotification(state, event, deps, effects) {
     }
     turn = createTurn(state, turnId, sourceSeq);
   }
+  turn.notificationCount += 1;
+  if (modelInteractionMethod(method)) {
+    turn.modelInteractionSeen = true;
+  }
   if (method === "turn/started") {
     return;
   }
@@ -5915,6 +5920,7 @@ function handleCodexNotification(state, event, deps, effects) {
     return;
   }
   if (method === "error") {
+    turn.errorNotificationCount += 1;
     const upstreamReason = upstreamErrorReason(params);
     if (upstreamReason !== void 0) {
       turn.lastUpstreamErrorReason = upstreamReason;
@@ -5924,6 +5930,17 @@ function handleCodexNotification(state, event, deps, effects) {
           reason: upstreamReason
         })
       );
+    } else {
+      const diagnosticText = errorDiagnosticText(params);
+      if (diagnosticText !== void 0) {
+        turn.lastErrorDiagnosticText = diagnosticText;
+        effects.push(
+          log("codex.error_without_http_status_captured", {
+            turn_id: turn.turnId,
+            diagnostic_text: diagnosticText
+          })
+        );
+      }
     }
     return;
   }
@@ -5978,6 +5995,10 @@ function createTurn(state, turnId, sourceSeq) {
     phase: "active",
     protocolFailureReason: void 0,
     lastUpstreamErrorReason: void 0,
+    lastErrorDiagnosticText: void 0,
+    errorNotificationCount: 0,
+    notificationCount: 0,
+    modelInteractionSeen: false,
     items: []
   };
   state.turns.set(turnId, turn);
@@ -6144,7 +6165,11 @@ function handleItemCompleted(turn, params, deps, effects) {
   );
 }
 function emitRowUpdate(turn, item, deltaIndex, streamState, deps, effects) {
-  const rendered = renderPipelineItem(item.wireItemKey, item.content, streamState);
+  const rendered = renderPipelineItem(
+    item.wireItemKey,
+    item.content,
+    streamState
+  );
   if (!item.posted) {
     if (rendered.body.trim() === "") {
       return;
@@ -6238,9 +6263,7 @@ function createItem(turn, streamKind, itemId, deps) {
 }
 function handleSnapshot(state, turnId, snapshot, deps, effects) {
   if (state.terminalTurnIds.has(turnId)) {
-    effects.push(
-      log("pipeline.loop.duplicate_snapshot", { turn_id: turnId })
-    );
+    effects.push(log("pipeline.loop.duplicate_snapshot", { turn_id: turnId }));
     return;
   }
   const turn = state.turns.get(turnId);
@@ -6363,7 +6386,9 @@ function handleSnapshot(state, turnId, snapshot, deps, effects) {
   const assistantResponseSeen = turn.items.some(
     (item) => item.identity.streamKind === "assistant" && item.posted
   ) || projected.some((proj) => proj.streamKind === "assistant");
-  const terminalFailureReason = turn.protocolFailureReason ?? (assistantResponseSeen ? void 0 : turn.lastUpstreamErrorReason ?? completedWithoutAssistantOutputReason);
+  const emptyTurnDiagnostic = !assistantResponseSeen && turn.protocolFailureReason === void 0 && turn.lastUpstreamErrorReason === void 0 ? classifyEmptyTurn(turn, projected.length) : void 0;
+  const baseNoOutputReason = turn.lastUpstreamErrorReason ?? (emptyTurnDiagnostic === void 0 ? completedWithoutAssistantOutputReason : `${completedWithoutAssistantOutputReason} [${emptyTurnDiagnostic.cause}]`);
+  const terminalFailureReason = turn.protocolFailureReason ?? (assistantResponseSeen ? void 0 : baseNoOutputReason);
   if (turn.protocolFailureReason !== void 0) {
     effects.push(
       log("codex.turn_completed_with_protocol_failure", {
@@ -6381,7 +6406,19 @@ function handleSnapshot(state, turnId, snapshot, deps, effects) {
         turn_id: turn.turnId,
         source_seq: turn.sourceSeq,
         streamed_item_count: turn.items.length,
-        snapshot_item_count: projected.length
+        snapshot_item_count: projected.length,
+        // LAUNCH-LIVE self-diagnosing fields: tell apart "codex never called the
+        // model" from "model returned empty" from "error without HTTP status".
+        notification_count: turn.notificationCount,
+        error_notification_count: turn.errorNotificationCount,
+        model_interaction_seen: turn.modelInteractionSeen,
+        last_error_diagnostic_text: turn.lastErrorDiagnosticText ?? null,
+        last_upstream_error_reason: turn.lastUpstreamErrorReason ?? null,
+        empty_turn_cause: emptyTurnDiagnostic?.cause ?? null,
+        // True iff the surfaced failure is the safe, retryable empty/no-response
+        // terminal (no output produced, no real upstream error) - the signal
+        // the client uses to offer a one-click retry (PART B, loud affordance).
+        retryable_empty_turn: emptyTurnDiagnostic !== void 0
       })
     );
   }
@@ -6394,7 +6431,13 @@ function handleSnapshot(state, turnId, snapshot, deps, effects) {
       seq: turn.sourceSeq,
       ...terminalFailureReason === void 0 ? { status: "processed" } : {
         status: "failed",
-        reason: terminalFailureReason
+        reason: terminalFailureReason,
+        // PART B (loud retry affordance): mark the safe empty/no-response
+        // terminal as retryable so the client can offer a one-click retry.
+        // Additive optional field; older servers ignore it. Only the empty
+        // terminal is retryable - real upstream errors (402/429/gateway,
+        // protocol failures) carry their own handling and are NOT flagged.
+        ...emptyTurnDiagnostic !== void 0 ? { retryable: true } : {}
       }
     },
     resolution: "must_ack"
@@ -6483,7 +6526,9 @@ function failureReason(params) {
   return stringValue(params.reason) ?? stringValue(params.message) ?? stringValue(objectValue(params.error)?.message) ?? stringValue(params.error) ?? "codex_turn_aborted";
 }
 function upstreamErrorReason(params) {
-  const summaryRaw = stringValue(params.diagnostic_summary) ?? stringValue(objectValue(objectValue(params.diagnostic_payload)?.error)?.message);
+  const summaryRaw = stringValue(params.diagnostic_summary) ?? stringValue(
+    objectValue(objectValue(params.diagnostic_payload)?.error)?.message
+  );
   if (summaryRaw === void 0) {
     return void 0;
   }
@@ -6501,10 +6546,33 @@ function upstreamErrorHttpStatus(params) {
   const code = disconnected?.httpStatusCode;
   return typeof code === "number" ? code : void 0;
 }
+function errorDiagnosticText(params) {
+  const raw = stringValue(params.message) ?? stringValue(params.reason) ?? stringValue(objectValue(params.error)?.message) ?? stringValue(params.error) ?? stringValue(params.diagnostic);
+  if (raw === void 0) {
+    return void 0;
+  }
+  const cleaned = raw.replace(/<[^>]*>/g, " ").replace(/data:[^"' )]+/g, "").replace(/\s+/g, " ").trim().slice(0, 180);
+  return cleaned.length === 0 ? void 0 : cleaned;
+}
+function classifyEmptyTurn(turn, snapshotItemCount) {
+  if (turn.lastErrorDiagnosticText !== void 0) {
+    return {
+      cause: `codex error without HTTP status: ${turn.lastErrorDiagnosticText}`
+    };
+  }
+  if (!turn.modelInteractionSeen) {
+    return {
+      cause: `codex never called the model: 0 model interactions, ${turn.notificationCount} notifications, ${turn.errorNotificationCount} errors`
+    };
+  }
+  return {
+    cause: `model returned no assistant output: ${turn.items.length} streamed items, ${snapshotItemCount} snapshot items`
+  };
+}
 function log(event, fields) {
   return { type: "log", event, fields };
 }
-var terminalRowStreamStates, turnMappingReadyMethod, turnMappingFailedMethod, maxTerminalTurnIds, completedWithoutAssistantOutputReason, unsupportedCodexToolCallReasonPrefix, turnTerminalFailureMethods, handledNotificationMethods;
+var terminalRowStreamStates, turnMappingReadyMethod, turnMappingFailedMethod, maxTerminalTurnIds, completedWithoutAssistantOutputReason, unsupportedCodexToolCallReasonPrefix, turnTerminalFailureMethods, handledNotificationMethods, modelInteractionMethods;
 var init_transition = __esm({
   "src/pipeline/transition.ts"() {
     "use strict";
@@ -6545,6 +6613,17 @@ var init_transition = __esm({
       "item/completed",
       "response_item"
     ]);
+    modelInteractionMethods = /* @__PURE__ */ new Set([
+      "item/agentMessage/delta",
+      "item/reasoning/textDelta",
+      "item/commandExecution/outputDelta",
+      "command/exec/outputDelta",
+      "item/fileChange/outputDelta",
+      "item/commandExecution/terminalInteraction",
+      "item/started",
+      "item/completed",
+      "response_item"
+    ]);
   }
 });
 
@@ -20078,7 +20157,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.110-beta";
+    linzumiCliVersion = "0.0.111-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -23176,6 +23255,172 @@ var init_threadCodexWorkerIpc = __esm({
   }
 });
 
+// src/signupTaskSuggestionsProgress.ts
+function basenameOf(rawPath) {
+  const trimmed = rawPath.trim();
+  if (trimmed === "") {
+    return void 0;
+  }
+  const withoutTrailing = trimmed.replace(/[/\\]+$/, "");
+  const segments = withoutTrailing.split(/[/\\]+/);
+  const last = segments[segments.length - 1];
+  if (last === void 0 || last === "" || last === "." || last === "..") {
+    return void 0;
+  }
+  if (last.length > MAX_BASENAME_LENGTH) {
+    return `${last.slice(0, MAX_BASENAME_LENGTH - 1)}\u2026`;
+  }
+  return last;
+}
+function lookingAtFileLabel(rawPath) {
+  if (typeof rawPath !== "string") {
+    return void 0;
+  }
+  const basename10 = basenameOf(rawPath);
+  return basename10 === void 0 ? void 0 : `Looking at ${basename10}...`;
+}
+function commandLabel2(command) {
+  let head;
+  let target;
+  if (Array.isArray(command)) {
+    const parts = command.filter((part) => typeof part === "string");
+    const meaningful = parts.filter(
+      (part) => part !== "bash" && part !== "sh" && part !== "-lc" && part !== "-c"
+    );
+    head = meaningful[0];
+    target = meaningful.slice(1).find((part) => !part.startsWith("-"));
+  } else if (typeof command === "string") {
+    const tokens = command.trim().split(/\s+/);
+    head = tokens[0];
+    target = tokens.slice(1).find((part) => !part.startsWith("-"));
+  } else {
+    return void 0;
+  }
+  if (head === void 0) {
+    return void 0;
+  }
+  const baseCommand = basenameOf(head) ?? head;
+  if (!READ_COMMAND_PREFIXES.includes(baseCommand)) {
+    return READING_REPO;
+  }
+  const fileLabel = target === void 0 ? void 0 : lookingAtFileLabel(target);
+  return fileLabel ?? READING_REPO;
+}
+function progressLabelForCodexEvent(event) {
+  if (typeof event !== "object" || event === null || Array.isArray(event)) {
+    return void 0;
+  }
+  const record = event;
+  const item = record["item"];
+  if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+    const itemRecord = item;
+    const itemType = itemRecord["item_type"] ?? itemRecord["type"];
+    switch (itemType) {
+      case "reasoning":
+        return READING_REPO;
+      case "command_execution":
+      case "local_shell_call":
+        return commandLabel2(itemRecord["command"] ?? itemRecord["argv"]) ?? READING_REPO;
+      case "file_change":
+      case "file_read":
+        return lookingAtFileLabel(itemRecord["path"]) ?? READING_REPO;
+      case "agent_message":
+      case "assistant_message":
+        return DRAFTING_TASKS;
+      default:
+        return void 0;
+    }
+  }
+  const msg = record["msg"];
+  const msgRecord = typeof msg === "object" && msg !== null && !Array.isArray(msg) ? msg : record;
+  const msgType = msgRecord["type"] ?? record["type"];
+  switch (msgType) {
+    case "task_started":
+    case "agent_reasoning":
+    case "agent_reasoning_delta":
+    case "agent_reasoning_section_break":
+      return READING_REPO;
+    case "exec_command_begin":
+    case "exec_command_end":
+      return commandLabel2(msgRecord["command"]) ?? READING_REPO;
+    case "agent_message":
+    case "agent_message_delta":
+      return DRAFTING_TASKS;
+    default:
+      return void 0;
+  }
+}
+function createTaskSuggestionProgressParser(onLabel) {
+  let buffer = "";
+  let lastLabel;
+  const emit = (label) => {
+    if (label === void 0 || label === lastLabel) {
+      return;
+    }
+    lastLabel = label;
+    try {
+      onLabel(label);
+    } catch {
+    }
+  };
+  const consumeLine = (line) => {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed[0] !== "{") {
+      return;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+    emit(progressLabelForCodexEvent(parsed));
+  };
+  return {
+    push: (chunk) => {
+      buffer += chunk;
+      let newlineIndex = buffer.indexOf("\n");
+      while (newlineIndex !== -1) {
+        const line = buffer.slice(0, newlineIndex);
+        buffer = buffer.slice(newlineIndex + 1);
+        consumeLine(line);
+        newlineIndex = buffer.indexOf("\n");
+      }
+    },
+    flush: () => {
+      if (buffer.trim() !== "") {
+        consumeLine(buffer);
+        buffer = "";
+      }
+    }
+  };
+}
+var READING_REPO, DRAFTING_TASKS, MAX_BASENAME_LENGTH, READ_COMMAND_PREFIXES;
+var init_signupTaskSuggestionsProgress = __esm({
+  "src/signupTaskSuggestionsProgress.ts"() {
+    "use strict";
+    READING_REPO = "Reading your repository...";
+    DRAFTING_TASKS = "Drafting tasks...";
+    MAX_BASENAME_LENGTH = 60;
+    READ_COMMAND_PREFIXES = [
+      "ls",
+      "cat",
+      "head",
+      "tail",
+      "find",
+      "rg",
+      "grep",
+      "tree",
+      "wc",
+      "sed",
+      "awk",
+      "pwd",
+      "stat",
+      "file"
+    ];
+  }
+});
+
 // src/signupTaskSuggestions.ts
 import { spawn as spawn7 } from "node:child_process";
 import { mkdtempSync as mkdtempSync3, readFileSync as readFileSync16, rmSync as rmSync4, writeFileSync as writeFileSync11 } from "node:fs";
@@ -23200,7 +23445,8 @@ async function suggestSignupTasksWithCodex(args) {
         model,
         modelProvider: args.modelProvider,
         previousResponse,
-        timeoutMs: remaining
+        timeoutMs: remaining,
+        onProgress: args.onProgress
       });
     } catch (error) {
       throw error instanceof Error ? error : new Error(String(error));
@@ -23251,7 +23497,8 @@ async function runCodexTaskSuggestion(args) {
         outputPath,
         prompt,
         timeoutMs: args.timeoutMs
-      })
+      }),
+      args.onProgress
     );
     return readFileSync16(outputPath, "utf8");
   } finally {
@@ -23288,6 +23535,14 @@ function codexTaskSuggestionProcess(args) {
       args.schemaPath,
       "--output-last-message",
       args.outputPath,
+      // LIVE PROGRESS: stream the agentic turn as JSONL events on stdout so we
+      // can parse privacy-safe step labels ("Reading your repository...",
+      // "Looking at <file>...", "Drafting tasks...") and relay them to the
+      // onboarding wizard while the (up to ~150s) turn runs. The final task
+      // JSON still comes from --output-last-message, so this is purely additive
+      // - if a codex build ignores or changes --json, we simply get no progress
+      // and the suggestion result is unaffected.
+      "--json",
       "--color",
       "never",
       "-"
@@ -23381,15 +23636,28 @@ function parseTaskSuggestionResponse(response) {
     return void 0;
   }
 }
-function runProcess2(args) {
+function runProcess2(args, onProgress) {
   return new Promise((resolveProcess, rejectProcess) => {
     const child = spawn7(args.command, [...args.args], {
       cwd: args.cwd,
       // Inherit the runner env (codex auth, PATH, etc.) and layer the wafer
       // proxy credential (LINZUMI_LLM_PROXY_TOKEN) on top when wafer-routed.
       ...args.env === void 0 ? {} : { env: { ...process.env, ...args.env } },
-      stdio: ["pipe", "ignore", "pipe"]
+      // LIVE PROGRESS: capture stdout (the `--json` JSONL event stream) only
+      // when a progress callback is supplied; otherwise discard it as before.
+      // We never depend on stdout for the result (that's --output-last-message),
+      // so stdout parsing is purely a best-effort enhancement.
+      stdio: ["pipe", onProgress === void 0 ? "ignore" : "pipe", "pipe"]
     });
+    const progress = onProgress === void 0 ? void 0 : createTaskSuggestionProgressParser(onProgress);
+    if (progress !== void 0) {
+      child.stdout?.on("data", (chunk) => {
+        try {
+          progress.push(String(chunk));
+        } catch {
+        }
+      });
+    }
     let stderr = "";
     let settled = false;
     const timeout = setTimeout(() => {
@@ -23402,6 +23670,10 @@ function runProcess2(args) {
       }
       settled = true;
       clearTimeout(timeout);
+      try {
+        progress?.flush();
+      } catch {
+      }
       if (error === void 0) {
         resolveProcess();
         return;
@@ -23433,6 +23705,7 @@ var init_signupTaskSuggestions = __esm({
   "src/signupTaskSuggestions.ts"() {
     "use strict";
     init_codexAppServer();
+    init_signupTaskSuggestionsProgress();
     DEFAULT_CODEX_AUTH_SUGGESTION_MODEL = "gpt-5.4-mini";
     DEFAULT_WAFER_SUGGESTION_MODEL = "GLM-5.2";
     SUGGESTION_TIMEOUT_MS = 15e4;
@@ -29596,7 +29869,10 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
       return createRunnerProject(control, options, allowedCwds);
     }
     case "suggest_tasks": {
-      return suggestRunnerTasks(control, options, allowedCwds.value);
+      return suggestRunnerTasks(control, options, allowedCwds.value, {
+        kandan,
+        topic
+      });
     }
     case "remote_codex_exec": {
       return await applyRemoteCodexExecControl(
@@ -33553,7 +33829,7 @@ function resolveSuggestTasksModelProvider(control) {
     env: codexModelProviderAppServerEnv(runtime)
   };
 }
-async function suggestRunnerTasks(control, options, allowedCwds) {
+async function suggestRunnerTasks(control, options, allowedCwds, progressSink) {
   const requestId = stringValue(control.requestId) ?? null;
   const cwd = resolveAllowedCwd(control.cwd, allowedCwds);
   if (!cwd.ok) {
@@ -33567,12 +33843,23 @@ async function suggestRunnerTasks(control, options, allowedCwds) {
   }
   const modelProvider = resolveSuggestTasksModelProvider(control);
   const model = stringValue(control.model)?.trim();
+  const workspaceSlug = stringValue(control.workspace)?.trim();
+  const onProgress = progressSink === void 0 || requestId === null ? void 0 : (label) => {
+    void progressSink.kandan.pushIfConnected(progressSink.topic, "suggest_tasks_progress", {
+      instanceId: options.runnerId,
+      controlType: control.type,
+      requestId,
+      ...workspaceSlug === void 0 || workspaceSlug === "" ? {} : { workspace: workspaceSlug },
+      label
+    }).catch(() => void 0);
+  };
   try {
     const tasks = await suggestSignupTasksWithCodex({
       projectPath: cwd.cwd,
       codexBin: options.codexBin,
       ...model === void 0 || model === "" ? {} : { model },
-      ...modelProvider === void 0 ? {} : { modelProvider }
+      ...modelProvider === void 0 ? {} : { modelProvider },
+      ...onProgress === void 0 ? {} : { onProgress }
     });
     return {
       instanceId: options.runnerId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "0.0.110-beta",
+  "version": "0.0.111-beta",
   "description": "Linzumi CLI \u2014 point a Codex agent at the real code on your laptop, with your team watching and steering from shared threads.",
   "type": "module",
   "bin": {