@linzumi/cli 0.0.55-beta → 0.0.56-beta

package/README.md

@@ -62,7 +62,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.55-beta --version
+npx -y @linzumi/cli@0.0.56-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -18203,8 +18203,8 @@ function pathLooksAbsolute(pathValue) {
 }
 
 // src/localForwarding.ts
+import { connect as connectTcp } from "node:net";
 import { gzipSync } from "node:zlib";
-import NodeWebSocket from "ws";
 var maxForwardBodyBytes = 64 * 1024 * 1024;
 var gzipForwardThresholdBytes = 32 * 1024;
 async function handleForwardHttpRequest(control, allowedPorts) {
@@ -18261,21 +18261,21 @@ async function handleForwardHttpRequest(control, allowedPorts) {
 function isForwardHttpRequestControl(control) {
   return control.type === "forward_http_request";
 }
-function isForwardWebSocketControl(control) {
-  return control.type === "forward_websocket_open" || control.type === "forward_websocket_send" || control.type === "forward_websocket_close";
+function isForwardTcpControl(control) {
+  return control.type === "forward_tcp_open" || control.type === "forward_tcp_send" || control.type === "forward_tcp_close";
 }
-function createForwardWebSocketManager(kandan, topic, allowedPorts, socketFactory = defaultForwardWebSocketFactory) {
+function createForwardTcpManager(kandan, topic, allowedPorts, socketFactory = defaultForwardTcpFactory) {
   const sockets = /* @__PURE__ */ new Map();
-  const pushEvent = (payload) => kandan.push(topic, "forward:websocket_event", payload).catch(() => void 0);
+  const pushEvent = (payload) => kandan.push(topic, "forward:tcp_event", payload).catch(() => void 0);
   const closeSocket = (socketId) => {
     const stream = sockets.get(socketId);
     sockets.delete(socketId);
-    stream?.socket.close();
+    stream?.socket.end();
   };
   return {
     handle: (control) => {
       switch (control.type) {
-        case "forward_websocket_open": {
+        case "forward_tcp_open": {
           if (!allowedPorts().includes(control.port)) {
             void pushEvent({
               socketId: control.socketId,
@@ -18284,32 +18284,70 @@ function createForwardWebSocketManager(kandan, topic, allowedPorts, socketFactor
             });
             return;
           }
-          openLocalWebSocket(control, sockets, pushEvent, socketFactory, "ws");
+          const previous = sockets.get(control.socketId);
+          previous?.socket.destroy();
+          const socket = socketFactory(control.port);
+          sockets.set(control.socketId, { socket });
+          socket.on("connect", () => {
+            if (!currentTcpSocket(sockets, control.socketId, socket)) {
+              return;
+            }
+            void pushEvent({ socketId: control.socketId, type: "open" });
+          });
+          socket.on("data", (data) => {
+            if (!currentTcpSocket(sockets, control.socketId, socket) || !(data instanceof Uint8Array)) {
+              return;
+            }
+            void pushEvent({
+              socketId: control.socketId,
+              type: "data",
+              bodyBase64: Buffer.from(data).toString("base64")
+            });
+          });
+          socket.on("close", () => {
+            if (!currentTcpSocket(sockets, control.socketId, socket)) {
+              return;
+            }
+            sockets.delete(control.socketId);
+            void pushEvent({ socketId: control.socketId, type: "close" });
+          });
+          socket.on("error", () => {
+            if (!currentTcpSocket(sockets, control.socketId, socket)) {
+              return;
+            }
+            sockets.delete(control.socketId);
+            void pushEvent({
+              socketId: control.socketId,
+              type: "error",
+              error: "forward_target_unavailable"
+            });
+            socket.destroy();
+          });
           return;
         }
-        case "forward_websocket_send": {
+        case "forward_tcp_send": {
           const stream = sockets.get(control.socketId);
-          if (stream === void 0 || stream.socket.readyState !== WebSocket.OPEN) {
+          const body = decodeBase64Body(control.bodyBase64);
+          if (body === void 0) {
             void pushEvent({
               socketId: control.socketId,
               type: "error",
-              error: "websocket_not_open"
+              error: "invalid_forward_request"
             });
             return;
           }
-          const body = Buffer.from(control.bodyBase64, "base64");
-          switch (control.opcode) {
-            case "text":
-              stream.socket.send(body.toString());
-              return;
-            case "binary":
-            case "ping":
-            case "pong":
-              stream.socket.send(body);
-              return;
+          if (stream === void 0 || stream.socket.destroyed === true || stream.socket.writable === false) {
+            void pushEvent({
+              socketId: control.socketId,
+              type: "error",
+              error: "tcp_socket_not_open"
+            });
+            return;
           }
+          stream.socket.write(body);
+          return;
         }
-        case "forward_websocket_close":
+        case "forward_tcp_close":
           closeSocket(control.socketId);
           return;
       }
@@ -18321,105 +18359,11 @@ function createForwardWebSocketManager(kandan, topic, allowedPorts, socketFactor
     }
   };
 }
-function openLocalWebSocket(control, sockets, pushEvent, socketFactory, scheme) {
-  let opened = false;
-  const url = localForwardWebSocketUrl(
-    scheme,
-    control.port,
-    control.path,
-    control.queryString
-  );
-  const protocols = webSocketProtocols(control.headers);
-  const headers = webSocketHeaders(control.headers);
-  const websocket = socketFactory(url, protocols, headers);
-  websocket.binaryType = "arraybuffer";
-  const previousStream = sockets.get(control.socketId);
-  previousStream?.socket.close();
-  sockets.set(control.socketId, { socket: websocket });
-  websocket.addEventListener("open", () => {
-    if (!currentWebSocket(sockets, control.socketId, websocket)) {
-      return;
-    }
-    opened = true;
-    void pushEvent({ socketId: control.socketId, type: "open" });
-  });
-  websocket.addEventListener("message", (event) => {
-    if (!currentWebSocket(sockets, control.socketId, websocket)) {
-      return;
-    }
-    const body = typeof event.data === "string" ? Buffer.from(event.data) : Buffer.from(event.data);
-    void pushEvent({
-      socketId: control.socketId,
-      type: "message",
-      opcode: typeof event.data === "string" ? "text" : "binary",
-      bodyBase64: body.toString("base64")
-    });
-  });
-  websocket.addEventListener("close", (event) => {
-    if (!currentWebSocket(sockets, control.socketId, websocket)) {
-      return;
-    }
-    sockets.delete(control.socketId);
-    void pushEvent({
-      socketId: control.socketId,
-      type: "close",
-      code: event.code,
-      reason: event.reason
-    });
-  });
-  websocket.addEventListener("error", () => {
-    if (!currentWebSocket(sockets, control.socketId, websocket)) {
-      return;
-    }
-    sockets.delete(control.socketId);
-    if (!opened && scheme === "ws") {
-      openLocalWebSocket(control, sockets, pushEvent, socketFactory, "wss");
-      return;
-    }
-    void pushEvent({
-      socketId: control.socketId,
-      type: "error",
-      error: "websocket_error",
-      attemptedScheme: scheme
-    });
-  });
-}
-function defaultForwardWebSocketFactory(url, protocols, headers) {
-  if (headers === void 0) {
-    return protocols === void 0 ? new WebSocket(url) : new WebSocket(url, protocols);
-  }
-  const options = { headers };
-  return protocols === void 0 ? new NodeWebSocket(url, options) : new NodeWebSocket(url, protocols, options);
-}
-function currentWebSocket(sockets, socketId, socket) {
+function currentTcpSocket(sockets, socketId, socket) {
   return sockets.get(socketId)?.socket === socket;
 }
-function webSocketProtocols(headers) {
-  if (!Array.isArray(headers)) {
-    return void 0;
-  }
-  const protocols = headers.flatMap((header) => {
-    if (!isWireHeader(header) || header.name.toLowerCase() !== "sec-websocket-protocol") {
-      return [];
-    }
-    return header.value.split(",").map((protocol) => protocol.trim()).filter((protocol) => protocol !== "");
-  });
-  return protocols.length === 0 ? void 0 : protocols;
-}
-function webSocketHeaders(headers) {
-  if (!Array.isArray(headers)) {
-    return void 0;
-  }
-  const forwarded = headers.reduce((acc, header) => {
-    if (isOctWebSocketHeader(header)) {
-      acc[header.name] = header.value;
-    }
-    return acc;
-  }, {});
-  return Object.keys(forwarded).length === 0 ? void 0 : forwarded;
-}
-function isOctWebSocketHeader(value) {
-  return isHeader(value) && value.name.toLowerCase().startsWith("x-oct-");
+function defaultForwardTcpFactory(port) {
+  return connectTcp({ host: "127.0.0.1", port });
 }
 function localForwardUrl(scheme, port, path2, queryString) {
   const normalizedPath = path2.startsWith("/") ? path2 : `/${path2}`;
@@ -18429,12 +18373,6 @@ function localForwardUrl(scheme, port, path2, queryString) {
   }
   return url.toString();
 }
-function localForwardWebSocketUrl(scheme, port, path2, queryString) {
-  const httpScheme = scheme === "ws" ? "http" : "https";
-  const url = new URL(localForwardUrl(httpScheme, port, path2, queryString));
-  url.protocol = `${scheme}:`;
-  return url.toString();
-}
 async function fetchWithHttpsFallback(port, path2, queryString, request) {
   try {
     return await fetch(
@@ -21159,7 +21097,7 @@ function realpathOrResolved(pathValue) {
 }
 
 // src/version.ts
-var linzumiCliVersion = "0.0.55-beta";
+var linzumiCliVersion = "0.0.56-beta";
 var linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
 
 // src/runnerLock.ts
@@ -21665,6 +21603,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       allowedCwds.value
     ),
     portForwarding: liveForwardPorts.size > 0,
+    tcpForwarding: true,
     allowedPorts: Array.from(liveForwardPorts).sort(
       (left, right) => left - right
     ),
@@ -22013,64 +21952,6 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   cleanup.actions.push(() => codex.close());
   const seq = { value: 0 };
   const discoveredCodexThreads = { value: [] };
-  const lastReportedDiscoveryFailure = { value: void 0 };
-  const reportClientError = async (args) => {
-    await kandan.push(topic, "client_error_report", {
-      id: `client-error-${randomUUID3()}`,
-      severity: args.severity ?? "error",
-      code: args.code,
-      operation: args.operation,
-      message: args.message,
-      occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
-      instanceId,
-      clientId,
-      runnerId: options.runnerId,
-      hostname: runnerHost,
-      cwd: options.cwd,
-      codexUrl,
-      workspace: runnerWorkspaceSlug(options) ?? null,
-      channel: options.channelSession?.channelSlug ?? null,
-      cliVersion: linzumiCliVersion,
-      details: args.details ?? {}
-    }).catch((error) => {
-      log("kandan.client_error_report_push_failed", {
-        code: args.code,
-        operation: args.operation,
-        message: error instanceof Error ? error.message : String(error)
-      });
-    });
-  };
-  const loadDiscoveredCodexThreads = async (phase) => {
-    try {
-      const threads = await discoverCodexThreads(codex, options.cwd);
-      lastReportedDiscoveryFailure.value = void 0;
-      return threads;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      const signature = `codex_thread_discovery_failed:${message}`;
-      log("codex.thread_discovery_failed", {
-        phase,
-        message
-      });
-      if (lastReportedDiscoveryFailure.value !== signature) {
-        lastReportedDiscoveryFailure.value = signature;
-        await reportClientError({
-          code: "codex_thread_discovery_failed",
-          operation: "codex_thread_discovery",
-          message,
-          details: {
-            phase,
-            codexUrl,
-            cwd: options.cwd
-          }
-        });
-      }
-      return discoveredCodexThreads.value;
-    }
-  };
-  if (options.channelSession === void 0) {
-    discoveredCodexThreads.value = await loadDiscoveredCodexThreads("initial");
-  }
   const runtimeDefaults = runnerRuntimeDefaults(options);
   const instancePayload = {
     instanceId,
@@ -22229,24 +22110,18 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       message: error instanceof Error ? error.message : String(error)
     });
   });
-  const refreshDiscoveredCodexThreads = async (phase) => {
-    discoveredCodexThreads.value = await loadDiscoveredCodexThreads(phase);
-    await pushHeartbeat();
-  };
   const heartbeatInterval = setInterval(() => {
-    void (channelSession === void 0 ? refreshDiscoveredCodexThreads("heartbeat") : pushHeartbeat());
+    void pushHeartbeat();
   }, 15e3);
   cleanup.actions.push(() => clearInterval(heartbeatInterval));
-  kandan.onReconnect(
-    () => channelSession === void 0 ? refreshDiscoveredCodexThreads("reconnect").then(() => void 0) : pushHeartbeat().then(() => void 0)
-  );
+  kandan.onReconnect(() => pushHeartbeat().then(() => void 0));
   void pushHeartbeat();
-  const forwardWebSockets = createForwardWebSocketManager(
+  const forwardTcp = createForwardTcpManager(
     kandan,
     topic,
     () => Array.from(liveForwardPorts)
   );
-  cleanup.actions.push(() => forwardWebSockets.close());
+  cleanup.actions.push(() => forwardTcp.close());
   const channelCodexThreadId = channelSession?.currentCodexThreadId();
   if (options.launchTui && channelCodexThreadId !== void 0) {
     await prepareCodexThreadForTuiResume(codex, channelCodexThreadId);
@@ -22282,9 +22157,6 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
         });
       });
     }
-    if (channelSession === void 0 && notification.method === "thread/started") {
-      void refreshDiscoveredCodexThreads("thread_started");
-    }
     log("codex.notification", {
       method: notification.method,
       metadata
@@ -22343,8 +22215,8 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       });
       return;
     }
-    if (isForwardWebSocketControl(control)) {
-      forwardWebSockets.handle(control);
+    if (isForwardTcpControl(control)) {
+      forwardTcp.handle(control);
       return;
     }
     if (isStartLocalEditorControl(control)) {
@@ -22548,99 +22420,6 @@ async function closeCleanupStack(cleanup) {
   })();
   return cleanup.closePromise;
 }
-async function discoverCodexThreads(codex, _cwd) {
-  const response = await codex.request("thread/list", {
-    limit: CODEX_THREAD_DISCOVERY_LIMIT,
-    sortKey: "updated_at",
-    sortDirection: "desc",
-    archived: false,
-    useStateDbOnly: true
-  });
-  if ("error" in response) {
-    throw new Error(`thread/list failed: ${response.error.message}`);
-  }
-  const result = objectValue(response.result);
-  const data = arrayValue(result?.data)?.filter(isJsonObject) ?? [];
-  const rowsById = /* @__PURE__ */ new Map();
-  for (const thread of data.slice(0, CODEX_THREAD_DISCOVERY_LIMIT)) {
-    const row = codexThreadHistoryRow(thread, false);
-    const id = stringValue(objectValue(row)?.id);
-    if (id !== void 0 && id !== "" && !rowsById.has(id)) {
-      rowsById.set(id, row);
-    }
-  }
-  return Array.from(rowsById.values()).sort(compareCodexThreadHistoryRows);
-}
-var CODEX_THREAD_DISCOVERY_LIMIT = 50;
-var CODEX_THREAD_TITLE_FIELD_LIMIT = 500;
-var CODEX_THREAD_TEXT_FIELD_LIMIT = 2e3;
-var CODEX_THREAD_PATH_FIELD_LIMIT = 1e3;
-function codexThreadHistoryRow(thread, archived) {
-  const gitInfo = objectValue(thread.gitInfo);
-  const preview = codexThreadText(thread.preview, CODEX_THREAD_TEXT_FIELD_LIMIT).replace(/\s+/g, " ").trim();
-  const name = codexThreadText(thread.name, CODEX_THREAD_TITLE_FIELD_LIMIT);
-  const directTitle = codexThreadText(
-    thread.title,
-    CODEX_THREAD_TITLE_FIELD_LIMIT
-  );
-  const title = directTitle === "" ? name === "" ? preview : name : directTitle;
-  const description = codexThreadText(thread.description, CODEX_THREAD_TEXT_FIELD_LIMIT) || codexThreadText(thread.summary, CODEX_THREAD_TEXT_FIELD_LIMIT) || preview;
-  return {
-    id: codexThreadText(thread.id, CODEX_THREAD_PATH_FIELD_LIMIT),
-    title: title ?? "",
-    description: description ?? "",
-    preview,
-    cwd: codexThreadText(thread.cwd, CODEX_THREAD_PATH_FIELD_LIMIT),
-    source: codexThreadText(thread.source, CODEX_THREAD_TITLE_FIELD_LIMIT),
-    createdAt: codexTimestamp(thread.createdAt),
-    updatedAt: codexTimestamp(thread.updatedAt),
-    archived,
-    modelProvider: codexThreadText(
-      thread.modelProvider,
-      CODEX_THREAD_TITLE_FIELD_LIMIT
-    ),
-    cliVersion: codexThreadText(
-      thread.cliVersion,
-      CODEX_THREAD_TITLE_FIELD_LIMIT
-    ),
-    gitBranch: codexThreadText(
-      gitInfo?.branch,
-      CODEX_THREAD_TITLE_FIELD_LIMIT
-    ),
-    gitOriginUrl: codexThreadText(
-      gitInfo?.originUrl,
-      CODEX_THREAD_PATH_FIELD_LIMIT
-    ),
-    path: codexThreadText(thread.path, CODEX_THREAD_PATH_FIELD_LIMIT)
-  };
-}
-function codexThreadText(value, maxLength) {
-  const text2 = stringValue(value) ?? "";
-  if (text2.length <= maxLength) {
-    return text2;
-  }
-  return `${text2.slice(0, Math.max(0, maxLength - 3))}...`;
-}
-function codexTimestamp(value) {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return new Date(value * 1e3).toISOString();
-  }
-  return stringValue(value) ?? "";
-}
-function compareCodexThreadHistoryRows(left, right) {
-  const leftRow = objectValue(left);
-  const rightRow = objectValue(right);
-  const leftTime = Date.parse(
-    stringValue(leftRow?.createdAt) ?? stringValue(leftRow?.updatedAt) ?? ""
-  );
-  const rightTime = Date.parse(
-    stringValue(rightRow?.createdAt) ?? stringValue(rightRow?.updatedAt) ?? ""
-  );
-  return safeComparableTime(leftTime) - safeComparableTime(rightTime);
-}
-function safeComparableTime(value) {
-  return Number.isFinite(value) ? value : Number.MAX_SAFE_INTEGER;
-}
 function extractStartedThreadId(response) {
   if ("error" in response) {
     throw new Error(`thread/start failed: ${response.error.message}`);
@@ -23023,9 +22802,9 @@ async function applyControl(codex, kandan, topic, instanceId, options, allowedCw
     case "update_session_settings":
     case "set_port_forward_enabled":
     case "forward_http_request":
-    case "forward_websocket_open":
-    case "forward_websocket_send":
-    case "forward_websocket_close":
+    case "forward_tcp_open":
+    case "forward_tcp_send":
+    case "forward_tcp_close":
     case "start_local_editor":
     case "update_runner_config":
       return { instanceId, controlType: control.type, skipped: true };
@@ -27278,6 +27057,16 @@ import { stdin as defaultStdin, stdout as defaultStdout } from "node:process";
 import { emitKeypressEvents } from "node:readline";
 
 // src/signupServerClient.ts
+var SignupServerError = class extends Error {
+  status;
+  code;
+  constructor(args) {
+    super(args.message);
+    this.name = "SignupServerError";
+    this.status = args.status;
+    this.code = args.code;
+  }
+};
 function createSignupServerClient(args) {
   const serviceUrl = args.serviceUrl ?? defaultLinzumiHttpUrl;
   const fetchImpl = args.fetchImpl ?? fetch;
@@ -27368,9 +27157,7 @@ async function signupJsonRequest(args) {
   });
   const responseText = await response.text();
   if (!response.ok) {
-    throw new Error(
-      `Linzumi signup request failed with HTTP ${response.status}${errorResponseDetail(responseText)}`
-    );
+    throw signupResponseError(response.status, responseText);
   }
   const body = parseJsonResponse(responseText, "Linzumi signup response");
   return args.render(body);
@@ -27389,6 +27176,38 @@ function errorResponseDetail(text2) {
   }
   return `: ${trimmed.slice(0, 240)}`;
 }
+function signupResponseError(status, text2) {
+  const code = signupErrorCodeFromResponseText(text2);
+  if (code !== void 0) {
+    return new SignupServerError({
+      status,
+      code,
+      message: code
+    });
+  }
+  return new Error(
+    `Linzumi signup request failed with HTTP ${status}${errorResponseDetail(text2)}`
+  );
+}
+function signupErrorCodeFromResponseText(text2) {
+  const trimmed = text2.trim();
+  if (trimmed === "") {
+    return void 0;
+  }
+  try {
+    const value = JSON.parse(trimmed);
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      return void 0;
+    }
+    const error = value.error;
+    if (typeof error === "string" && error.trim() !== "") {
+      return error;
+    }
+    return void 0;
+  } catch (_error) {
+    return void 0;
+  }
+}
 function renderEmailCodeStart(value) {
   const body = objectRecord(value, "signup email-code start response");
   return {
@@ -27576,6 +27395,7 @@ function booleanValue(record, key) {
 }
 
 // src/signupFlow.ts
+var maxSignupVerificationCodeAttempts = 3;
 var blue = (value) => `\x1B[38;5;75m${value}\x1B[0m`;
 var green = (value) => `\x1B[38;5;114m${value}\x1B[0m`;
 var red = (value) => `\x1B[38;5;203m${value}\x1B[0m`;
@@ -28108,22 +27928,19 @@ async function runSignupFlow(deps = {}) {
       writeDebugLaunchPayload(output, state, debugLaunchPayload);
       return;
     }
-    writeVerificationPrompt(output, codeRequest.request.email);
-    const code = await prompts.input({
-      message: "Enter your Linzumi verification code",
-      defaultValue: signupServerClient === void 0 ? "482931" : ""
-    });
-    const verifyResult = signupServerClient === void 0 ? void 0 : await verifyEmailCodeForSignup(signupServerClient, {
+    const verificationResult = await promptForVerifiedEmailCode({
+      prompts,
+      output,
+      signupServerClient,
       pendingId: codeRequest.request.pendingId,
-      code
+      email: codeRequest.request.email
     });
-    if (verifyResult?.type === "failed") {
+    if (verificationResult.type === "failed") {
       state = updateSignupState(state, {
         currentStep: "launch",
-        verificationCode: code,
-        launchFailure: verifyResult.message
+        verificationCode: verificationResult.code,
+        launchFailure: verificationResult.message
       });
-      writeCodeEntry(output, code);
       writeSignupScreen(output, state);
       writePreflightSummary(output, state);
       writeSelectedProjectsSummary(output, state);
@@ -28132,14 +27949,13 @@ async function runSignupFlow(deps = {}) {
       writeDebugLaunchPayload(output, state, debugLaunchPayload);
       return;
     }
-    verifiedAuth = verifyResult?.auth;
+    verifiedAuth = verificationResult.verifiedAuth;
     const storedSignupAuth = verifiedAuth === void 0 ? writeSignupAuth({ email }) : signupAuthFromVerification(verifiedAuth, serviceUrl);
     state = updateSignupState(state, {
       currentStep: "launch",
       storedSignupAuth,
-      verificationCode: code
+      verificationCode: verificationResult.code
     });
-    writeCodeEntry(output, code);
   }
   if (signupServerClient !== void 0 && verifiedAuth !== void 0) {
     const defaultWorkspaceName = verifiedAuth.privateWorkspaceDefault.name || defaultWorkspaceNameForEmail(
@@ -28335,7 +28151,8 @@ async function verifyEmailCodeForSignup(signupServerClient, args) {
       message: signupServerFailureMessage(
         "We couldn't verify your Linzumi email code",
         error
-      )
+      ),
+      code: signupServerFailureCode(error)
     };
   }
 }
@@ -28343,6 +28160,43 @@ function signupServerFailureMessage(prefix, error) {
   const message = error instanceof Error ? error.message : String(error);
   return `${prefix}: ${message}`;
 }
+function signupServerFailureCode(error) {
+  if (error instanceof SignupServerError) {
+    return error.code;
+  }
+  if (error instanceof Error && error.message === "invalid_signup_code") {
+    return "invalid_signup_code";
+  }
+  return void 0;
+}
+async function promptForVerifiedEmailCode(args) {
+  writeVerificationPrompt(args.output, args.email);
+  return verifyPromptAttempt(args, 1);
+}
+async function verifyPromptAttempt(args, attempt) {
+  const code = await args.prompts.input({
+    message: "Enter your Linzumi verification code",
+    defaultValue: args.signupServerClient === void 0 ? "482931" : ""
+  });
+  const verifyResult = args.signupServerClient === void 0 ? void 0 : await verifyEmailCodeForSignup(args.signupServerClient, {
+    pendingId: args.pendingId,
+    code
+  });
+  writeCodeEntry(args.output, code);
+  if (verifyResult?.type === "failed") {
+    if (verifyResult.code === "invalid_signup_code" && attempt < maxSignupVerificationCodeAttempts) {
+      writeBoundedLine(
+        args.output,
+        muted(
+          "   That code was not valid. Enter the newest 6-digit code from your email."
+        )
+      );
+      return verifyPromptAttempt(args, attempt + 1);
+    }
+    return { type: "failed", message: verifyResult.message, code };
+  }
+  return verifyResult === void 0 ? { type: "completed", code } : { type: "completed", code, verifiedAuth: verifyResult.auth };
+}
 async function refreshExistingSignupAuth(prompts, output, auth, writeSignupAuth, signupServerClient, serviceUrl) {
   output.write(
     `${green("\u2713")} You're already logged in!
@@ -28361,25 +28215,29 @@ ${muted(
   if (codeRequest.type === "failed") {
     return codeRequest;
   }
-  writeVerificationPrompt(output, codeRequest.request.email);
-  const code = await prompts.input({
-    message: "Enter your Linzumi verification code",
-    defaultValue: signupServerClient === void 0 ? "482931" : ""
-  });
-  const verifyResult = signupServerClient === void 0 ? void 0 : await verifyEmailCodeForSignup(signupServerClient, {
+  const verificationResult = await promptForVerifiedEmailCode({
+    prompts,
+    output,
+    signupServerClient,
     pendingId: codeRequest.request.pendingId,
-    code
+    email: codeRequest.request.email
   });
-  if (verifyResult?.type === "failed") {
-    writeCodeEntry(output, code);
+  if (verificationResult.type === "failed") {
     output.write("\n");
-    return verifyResult;
+    return {
+      type: "failed",
+      message: verificationResult.message
+    };
   }
-  const verifiedAuth = verifyResult?.auth;
+  const verifiedAuth = verificationResult.verifiedAuth;
   const refreshedAuth = verifiedAuth === void 0 ? writeSignupAuth({ email: auth.email }) : signupAuthFromVerification(verifiedAuth, serviceUrl);
-  writeCodeEntry(output, code);
   output.write("\n");
-  return { type: "completed", auth: refreshedAuth, code, verifiedAuth };
+  return {
+    type: "completed",
+    auth: refreshedAuth,
+    code: verificationResult.code,
+    verifiedAuth
+  };
 }
 async function validateExistingSignupAuth(signupServerClient, auth, retryPolicy) {
   if (signupServerClient === void 0 || auth.accessToken === void 0) {
@@ -30251,7 +30109,7 @@ function runProcessCapture(args) {
     child.on("error", () => {
       finish("");
     });
-    child.on("exit", (code) => {
+    child.on("close", (code) => {
       finish(code === 0 ? stdout : "");
     });
   });

package/package.json

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