@runuai/host 0.9.50 → 0.9.52

package/lib/engine-login.ts

@@ -190,6 +190,10 @@ interface LoginOperation {
   /** ADR-116: when set, the captured credential lands in a labeled extra
    * account instead of the default slot. */
   accountLabel: string | null;
+  /** Diagnosis breadcrumb: has ANY output arrived after the one-time code
+   * was written? Distinguishes "stdin never delivered" from "CLI answered
+   * and we ignored it" without reading the PTY transcript. */
+  postInputOutputSeen: boolean;
 }
 
 const defaultTimers: EngineLoginTimers = {
@@ -391,6 +395,7 @@ export class EngineLoginManager {
       pendingInput: null,
       callbackTarget: null,
       accountLabel: label ?? null,
+      postInputOutputSeen: false,
     };
     this.operations.set(opId, operation);
     this.engineOperations.set(engine, operation);
@@ -413,17 +418,35 @@ export class EngineLoginManager {
   /** Consume Claude's one-time code exactly once. */
   input(opId: string, text: string): boolean {
     const operation = this.operations.get(opId);
-    if (
-      !operation ||
-      !this.isCurrent(operation) ||
-      operation.engine !== "claude" ||
-      operation.stage !== "awaiting_input" ||
-      operation.inputUsed ||
-      operation.finishing
-    ) {
+    // Every rejection names itself in the host log: a silently dropped code
+    // reads as "Waiting for the host…" forever on the cloud pane (live
+    // 2026-08-20, the guard chain gave the operator nothing to act on).
+    // Never log `text` — it is one-time OAuth material.
+    if (!operation) {
+      console.warn(`[engine-login] input dropped: unknown opId ${opId}`);
+      return false;
+    }
+    const rejection = !this.isCurrent(operation)
+      ? "operation belongs to a previous bridge generation"
+      : operation.engine !== "claude"
+        ? `engine is ${operation.engine}, not claude`
+        : operation.stage !== "awaiting_input"
+          ? `stage is ${operation.stage}, not awaiting_input`
+          : operation.inputUsed
+            ? "a code was already submitted for this operation"
+            : operation.finishing
+              ? "the operation is already finishing"
+              : null;
+    if (rejection !== null) {
+      console.warn(
+        `[engine-login] input dropped for ${opId}: ${rejection}`,
+      );
       return false;
     }
     if (!isValidOneTimeInput(text)) {
+      console.warn(
+        `[engine-login] input rejected for ${opId}: failed one-time-input validation (length ${text.length})`,
+      );
       void this.fail(
         operation,
         "invalid_input",
@@ -431,6 +454,9 @@ export class EngineLoginManager {
       );
       return false;
     }
+    console.log(
+      `[engine-login] input accepted for ${opId} (${text.length} chars)`,
+    );
     operation.inputUsed = true;
     operation.outputTail = "";
     // CARRIAGE RETURN, not newline: `claude setup-token` is an Ink raw-mode
@@ -441,13 +467,20 @@ export class EngineLoginManager {
     // hung on exactly this.
     const value = `${text}\r`;
     if (!operation.process) {
+      console.log(
+        `[engine-login] input buffered for ${opId} (login process still starting)`,
+      );
       operation.pendingInput = value;
       return true;
     }
     try {
       operation.process.writeInput(value);
+      console.log(`[engine-login] input written to the login process for ${opId}`);
       return true;
     } catch {
+      console.warn(
+        `[engine-login] input write FAILED for ${opId}: the login process rejected stdin`,
+      );
       void this.fail(
         operation,
         "invalid_input",
@@ -636,6 +669,29 @@ export class EngineLoginManager {
     );
 
     if (operation.engine === "claude") {
+      if (operation.inputUsed && !operation.postInputOutputSeen) {
+        operation.postInputOutputSeen = true;
+        console.log(
+          `[engine-login] output resumed after input for ${operation.opId} — the code reached the login TUI`,
+        );
+      }
+      // The TUI answers a bad/expired/mismatched code with an error AND an
+      // open prompt — no exit, no token. Detect it and fail visibly instead
+      // of the silent wait-for-timeout that hid the 2026-08-20 hangs.
+      if (operation.inputUsed && !operation.finishing) {
+        const cliError = detectClaudeCliError(operation.outputTail);
+        if (cliError) {
+          console.warn(
+            `[engine-login] login CLI rejected the code for ${operation.opId}: ${cliError}`,
+          );
+          void this.fail(
+            operation,
+            "invalid_input",
+            `The sign-in CLI rejected the code: ${cliError} Make sure the code comes from THIS attempt's authorization page, then retry.`,
+          );
+          return;
+        }
+      }
       // Before the one-time input is consumed, token-shaped output could only
       // be an authorization URL/detail or hostile terminal content. This also
       // prevents an input echo from becoming the credential boundary.
@@ -643,6 +699,9 @@ export class EngineLoginManager {
         ? extractClaudeOAuthToken(operation.outputTail)
         : null;
       if (token) {
+        console.log(
+          `[engine-login] token detected in CLI output for ${operation.opId}; persisting`,
+        );
         operation.outputTail = "";
         this.beginClaudeFinish(operation, token);
         return;
@@ -650,6 +709,9 @@ export class EngineLoginManager {
       if (operation.stage === "starting") {
         const authorizeUrl = findSafeHttpsUrl(operation.outputTail);
         if (authorizeUrl) {
+          console.log(
+            `[engine-login] authorize URL found for ${operation.opId}; awaiting the one-time code`,
+          );
           operation.stage = "awaiting_input";
           safeEmit(operation.emit, authorizeEvent(operation, authorizeUrl));
           safeEmit(operation.emit, {
@@ -694,12 +756,17 @@ export class EngineLoginManager {
       if (operation.finishPromise) await operation.finishPromise;
       return;
     }
+    const evidence = lastSignificantOutputLine(operation.outputTail);
+    console.warn(
+      `[engine-login] login process for ${operation.opId} ended (exit ${result.code ?? "spawn-failed"}) before completion` +
+        (evidence ? `; last output: ${evidence}` : ""),
+    );
     await this.fail(
       operation,
       result.spawnFailed ? "unavailable" : "start_failed",
       result.spawnFailed
         ? "The login runtime is unavailable."
-        : `${engineLabel(operation.engine)} login did not complete.`,
+        : `${engineLabel(operation.engine)} login did not complete.${evidence ? ` Last output: ${evidence}` : ""}`,
     );
   }
 
@@ -1008,6 +1075,27 @@ export function createEngineLoginManager(
   return new EngineLoginManager(options);
 }
 
+/** Detect the TUI's post-input rejection ("OAuth error: Invalid code…",
+ * expired codes, …) in the sanitized output. ANSI stripping can eat spaces
+ * ("Invalidcode"), so the patterns tolerate missing whitespace. Exported for
+ * tests. */
+export function detectClaudeCliError(tail: string): string | null {
+  const lines = tail
+    .replace(/\u001b\[[0-9;?]*[ -\/]*[@-~]/g, "")
+    .replace(/[\u0000-\u0009\u000b-\u001f\u007f]/g, "")
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean);
+  const match = lines.find((line) =>
+    /oauth\s*error|invalid\s*cod|code\s*.{0,12}expired|authentication\s*failed/i.test(
+      line,
+    ),
+  );
+  if (!match) return null;
+  if (/sk-ant-|Bearer |[A-Za-z0-9_-]{40,}/.test(match)) return null;
+  return match.slice(0, 200);
+}
+
 /** The last visible, sanitized line of the login CLI's output — bounded and
  * secret-checked so it can ride a terminal event message (ADR-116). Anything
  * token-shaped disqualifies the whole line rather than risking a partial. */
@@ -1401,7 +1489,12 @@ export function engineLoginContainerArgs(
           // a client id (live 2026-08-18). stty targets the PTY `script`
           // just allocated.
           "stty cols 500 rows 50 2>/dev/null; exec claude setup-token",
-          "/dev/null",
+          // The PTY transcript lands in the op's private bind leaf (same
+          // trust class as the codex auth.json captured there; the leaf is
+          // 0700 and deleted at cleanup). A stuck flow can then be read
+          // VERBATIM from the host — the 2026-08-20 hang was undiagnosable
+          // because the typescript went to /dev/null.
+          `${LOGIN_MOUNT}/typescript`,
         ]
       : ["codex", "login"];
   if (engineLoginBackend().apple) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.9.50",
+  "version": "0.9.52",
   "description": "Uai host — runs ephemeral AI tasks in containers on a machine you control.",
   "license": "MIT",
   "author": "Uai Tech <team@runuai.com>",