@runuai/host 0.8.11 → 0.8.13

package/lib/engines.ts

@@ -17,9 +17,16 @@
  * PATH so `#!/usr/bin/env node` shebangs resolve too.
  *
  * Three auth modes:
- *   - token-command  (Claude): `claude setup-token` prints a token to stdout;
- *                    we capture it (an `sk-ant-oat…` value) and persist it as
+ *   - token-command  (Claude): `claude setup-token` shows a token; we run the
+ *                    CLI under a PTY (script(1)), capture the `sk-ant-oat…`
+ *                    value live from the terminal stream and persist it as
  *                    CLAUDE_CODE_OAUTH_TOKEN. A pasted token is accepted too.
+ *                    The PTY is load-bearing: the CLI's Ink UI buffers ALL
+ *                    output until unmount when stdout isn't a TTY and its
+ *                    final screens wait for a keypress — under plain pipes it
+ *                    emits nothing and never exits (the eternal "Connecting…"
+ *                    of 0.8.11). We resolve as soon as the token appears and
+ *                    kill the CLI rather than wait for it to end on its own.
  *   - login-command  (Codex/Kimi/Grok): `<cli> login` runs a browser OAuth and
  *                    writes a config file; success = that file appearing.
  *   - api-key        (Cursor): no command — persist a pasted CURSOR_API_KEY.
@@ -147,7 +154,7 @@ export type EngineSpawn = (
 ) => ChildProcess;
 
 export interface EngineSeams {
-  /** Spawn a CLI, piping stdout/stderr. */
+  /** Spawn a CLI, piping stdin/stdout/stderr. */
   spawn: EngineSpawn;
   /** Absolute path to the `.env.local` the running host reads (UAI_HOME). */
   envLocalPath: () => string;
@@ -159,13 +166,35 @@ export interface EngineSeams {
   loginShellPath: () => Promise<string | null>;
   /** System-wide bin dirs probed for engine CLIs (tests pin to []). */
   systemBinDirs: string[];
+  /**
+   * Wrap a CLI invocation so the child gets a real PTY (script(1)), or null
+   * to spawn directly. Tests pin null; token-command needs the wrap (see
+   * defaultPtyWrap for why).
+   */
+  ptyWrap: ((bin: string, args: string[]) => PtyCommand | null) | null;
+}
+
+/** A wrapped invocation: what to actually spawn to run a CLI under a PTY. */
+export interface PtyCommand {
+  command: string;
+  args: string[];
 }
 
 function defaultSeams(): EngineSeams {
   return {
     spawn: (command, args, spawnEnv) =>
       nodeSpawn(command, args, {
-        stdio: ["ignore", "pipe", "pipe"],
+        // macOS: stdin MUST be /dev/null ("ignore"), never a node pipe. Node's
+        // child pipes are SOCKETPAIRS, and Apple's BSD script(1) hard-exits on
+        // a socket stdin ("tcgetattr/ioctl: Operation not supported on
+        // socket") while tolerating /dev/null (ENOTTY → notty mode). The
+        // "Press Enter" auto-ack is therefore Linux-only; the real token flow
+        // needs no input before the token renders (verified empirically).
+        stdio: [
+          process.platform === "darwin" ? "ignore" : "pipe",
+          "pipe",
+          "pipe",
+        ],
         env: spawnEnv,
       }),
     envLocalPath: () => join(env.uaiHome, ".env.local"),
@@ -173,9 +202,43 @@ function defaultSeams(): EngineSeams {
     procEnv: process.env,
     loginShellPath: probeLoginShellPath,
     systemBinDirs: ["/opt/homebrew/bin", "/usr/local/bin"],
+    ptyWrap: defaultPtyWrap,
   };
 }
 
+/**
+ * Lend a CLI a real PTY via script(1) — no native deps, ships with macOS
+ * (BSD) and Linux (util-linux; argument conventions differ, hence the
+ * branch). Ink-based CLIs (claude) render nothing under plain pipes: Ink
+ * detects a non-TTY stdout and buffers every frame until unmount, and the
+ * interactive screens can't complete without a terminal — so the child sat
+ * silent forever. The inner `stty cols 400` matters too: at the default 80
+ * columns the token line WRAPS and a wrapped token extracts truncated.
+ */
+function defaultPtyWrap(bin: string, args: string[]): PtyCommand | null {
+  if (!existsSync("/usr/bin/script")) return null;
+  const stty = "stty cols 400 rows 100 2>/dev/null";
+  if (process.platform === "darwin") {
+    // BSD script: `script -q /dev/null command [args…]` — command is exec'd
+    // as an argv (no shell), so route through sh only to set the width.
+    return {
+      command: "/usr/bin/script",
+      args: ["-q", "/dev/null", "/bin/sh", "-c", `${stty}; exec "$0" "$@"`, bin, ...args],
+    };
+  }
+  if (process.platform === "linux") {
+    // util-linux script: the command is a single shell string (-c).
+    const quoted = [bin, ...args]
+      .map((a) => `'${a.replace(/'/g, `'\\''`)}'`)
+      .join(" ");
+    return {
+      command: "/usr/bin/script",
+      args: ["-qec", `${stty}; exec ${quoted}`, "/dev/null"],
+    };
+  }
+  return null;
+}
+
 /**
  * The PATH the owner's login shell exports. Runs `/usr/bin/env` (not
  * `echo $PATH`) so the value is the real colon-joined exported PATH under any
@@ -412,7 +475,32 @@ export function disconnectEngine(
 }
 
 /**
- * Extract a Claude OAuth token from `claude setup-token` stdout. The CLI prints
+ * Flatten a PTY byte stream into plain text lines. Strips OSC sequences
+ * (incl. OSC-8 hyperlink wrappers, keeping their visible text), CSI
+ * sequences (cursor-column moves become a space — Ink positions words with
+ * `ESC[<n>G` instead of writing spaces), stray ESC singles, and normalizes
+ * `\r` to `\n`. Identity on already-plain text apart from whitespace runs.
+ */
+export function sanitizeTerminalOutput(raw: string): string {
+  return raw
+    .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "") // OSC …BEL / …ST
+    .replace(/\x1b\[[0-9;:?<=>]*[!-/]*[@-~]/g, " ") // CSI
+    .replace(/\x1b[()][0-9A-B]/g, "") // charset selects
+    .replace(/\x1b[78=>DEHM]/g, "") // save/restore cursor etc.
+    .replace(/\r\n?/g, "\n")
+    .replace(/[^\S\n]+/g, " ");
+}
+
+/** Lines worth showing a human: non-blank, not spinner or logo-art glyphs. */
+function significantLines(text: string): string[] {
+  return text
+    .split("\n")
+    .map((l) => l.trim())
+    .filter((l) => l.length > 1 && !/^[·✢✳✶✻✽*+.…|/\\\-░▒▓█▄▀\s]+$/u.test(l));
+}
+
+/**
+ * Extract a Claude OAuth token from `claude setup-token` output. The CLI shows
  * the token (an `sk-ant-oat…` value) on its own line near the end; scan from the
  * bottom for it, falling back to a lone long token-charset line.
  */
@@ -550,16 +638,29 @@ function prependPath(prepend: string[], current: string): string {
     .join(":");
 }
 
-/** Resolve the CLI and spawn it with the augmented PATH. */
+/** Resolve the CLI and spawn it (optionally under a PTY) with the augmented PATH. */
 async function spawnEngineCli(
   kind: EngineKind,
   args: string[],
   s: EngineSeams,
+  pty = false,
 ): Promise<ChildProcess> {
   const { bin, path } = await resolveEngineBin(kind, s);
-  return s.spawn(bin, args, { ...s.procEnv, PATH: path });
+  const wrapped = pty && s.ptyWrap ? s.ptyWrap(bin, args) : null;
+  const spawnEnv: NodeJS.ProcessEnv = { ...s.procEnv, PATH: path };
+  // A GUI-supervised host has no TERM; give the PTY child a sane one.
+  if (wrapped && !spawnEnv.TERM) spawnEnv.TERM = "xterm-256color";
+  return wrapped
+    ? s.spawn(wrapped.command, wrapped.args, spawnEnv)
+    : s.spawn(bin, args, spawnEnv);
 }
 
+/** Browser authorization is human-paced — give it real time before bailing. */
+const TOKEN_FLOW_TIMEOUT_MS = 10 * 60_000;
+
+const TOKEN_FLOW_FALLBACK =
+  "Try again, or run `claude setup-token` in your terminal and paste the token here.";
+
 async function runTokenCommand(
   kind: EngineKind,
   label: string,
@@ -568,25 +669,68 @@ async function runTokenCommand(
 ): Promise<ConnectResult> {
   let child: ChildProcess;
   try {
-    child = await spawnEngineCli(kind, ["setup-token"], s);
+    child = await spawnEngineCli(kind, ["setup-token"], s, true);
   } catch (err) {
     return { ok: false, message: err instanceof Error ? err.message : String(err) };
   }
   return new Promise((resolve) => {
     let settled = false;
-    const done = (r: ConnectResult): void => {
-      if (!settled) {
-        settled = true;
-        resolve(r);
+    let timer: NodeJS.Timeout | undefined;
+    const done = (r: ConnectResult, kill = false): void => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (kill) {
+        try {
+          child.kill();
+        } catch {
+          /* already gone */
+        }
       }
+      resolve(r);
     };
-    let stdout = "";
-    child.stdout?.on("data", (b: Buffer) => {
-      const text = b.toString("utf8");
-      stdout += text;
-      relay(text, onLog);
-    });
-    child.stderr?.on("data", (b: Buffer) => relay(b.toString("utf8"), onLog));
+    let raw = "";
+    const forwarded = new Set<string>();
+    const acked = new Set<string>();
+    const saveToken = (token: string): void => {
+      upsertEnvLocal("CLAUDE_CODE_OAUTH_TOKEN", token, s);
+      done({ ok: true, message: `${label} connected.` }, true);
+    };
+    const onChunk = (b: Buffer): void => {
+      raw += b.toString("utf8");
+      // A pending spinner redraws for minutes — keep only the tail (the token
+      // and final screens are at the end) so re-sanitizing stays cheap.
+      if (raw.length > 262_144) raw = raw.slice(-131_072);
+      const text = sanitizeTerminalOutput(raw);
+      // Act only on COMPLETE lines: a trailing partial may still be missing
+      // the rest of an escape sequence — or the rest of the TOKEN, and the
+      // extractor would happily return a truncated prefix.
+      const complete = text.slice(0, text.lastIndexOf("\n") + 1);
+      for (const line of significantLines(complete)) {
+        // Each distinct line once — Ink redraws the same screen constantly
+        // and would flood the UI log.
+        if (!forwarded.has(line)) {
+          forwarded.add(line);
+          onLog(line);
+        }
+        // Auto-acknowledge keypress gates (once per distinct screen text) —
+        // with a PTY the CLI accepts input, and nobody is at its keyboard.
+        if (/press enter/i.test(line) && !acked.has(line)) {
+          acked.add(line);
+          try {
+            child.stdin?.write("\r");
+          } catch {
+            /* best effort */
+          }
+        }
+      }
+      // The whole point: capture the token the moment it renders. The CLI's
+      // final screen lingers for a keypress; we don't wait for exit.
+      const token = extractClaudeToken(complete);
+      if (token) saveToken(token);
+    };
+    child.stdout?.on("data", onChunk);
+    child.stderr?.on("data", onChunk);
     child.on("error", (err: NodeJS.ErrnoException) =>
       done({
         ok: false,
@@ -597,18 +741,27 @@ async function runTokenCommand(
       }),
     );
     child.on("exit", () => {
-      const token = extractClaudeToken(stdout);
+      const token = extractClaudeToken(sanitizeTerminalOutput(raw));
       if (!token) {
         done({
           ok: false,
-          message:
-            "Couldn't read a token from the CLI output. Try again, or paste the token manually.",
+          message: `The sign-in didn't finish. ${TOKEN_FLOW_FALLBACK}`,
         });
         return;
       }
-      upsertEnvLocal("CLAUDE_CODE_OAUTH_TOKEN", token, s);
-      done({ ok: true, message: `${label} connected.` });
+      saveToken(token);
     });
+    timer = setTimeout(
+      () =>
+        done(
+          {
+            ok: false,
+            message: `Timed out waiting for the browser authorization. ${TOKEN_FLOW_FALLBACK}`,
+          },
+          true,
+        ),
+      TOKEN_FLOW_TIMEOUT_MS,
+    );
   });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.8.11",
+  "version": "0.8.13",
   "description": "Uai host — runs ephemeral AI coding tasks in Docker on a machine you control.",
   "license": "MIT",
   "author": "Diogo Perillo <diogo.perillo@gmail.com>",