@runuai/host 0.9.57 → 0.9.59

package/lib/engine-login.ts

@@ -66,6 +66,8 @@ const LOGIN_MOUNT = "/run/uai-engine-login";
 const LOGIN_HOME = `${LOGIN_MOUNT}/home`;
 const CODEX_HOME = `${LOGIN_MOUNT}/codex`;
 const MAX_OUTPUT_TAIL_BYTES = 64 * 1_024;
+/** script(1) transcripts of a login run a few KB; 1MB is a hostile-file cap. */
+const MAX_TRANSCRIPT_BYTES = 1_024 * 1_024;
 const MAX_CODEX_AUTH_BYTES = 1024 * 1024;
 const DOCKER_CONTROL_TIMEOUT_MS = 15_000;
 const DOCKER_CLEANUP_TIMEOUT_MS = 5_000;
@@ -132,6 +134,14 @@ export interface EngineLoginSeams {
     callbackUrl: string,
   ): Promise<void>;
   reconcileStaleContainers(): Promise<void>;
+  /**
+   * Read the script(1) PTY transcript from the login leaf (null when absent
+   * or unreadable). The transcript is written INSIDE the container, so it is
+   * the pure PTY byte stream — structurally free of the container runtime's
+   * own stdio chatter, which on the Apple CLI painted XPC noise over the
+   * very cells the TUI's diff renderer skipped (live 2026-08-21).
+   */
+  readTranscript(tempDir: string): Promise<string | null>;
   persistClaudeToken(token: string): Promise<void>;
   persistCodexAuth(sourceFile: string): Promise<void>;
   /** ADR-116: labeled extra-account captures (never the default slots). */
@@ -272,6 +282,17 @@ function defaultSeams(options: EngineLoginManagerOptions): EngineLoginSeams {
     replayCodexCallback,
     reconcileStaleContainers: () =>
       reconcileStaleEngineLoginResources({ tempRoot }),
+    readTranscript: async (tempDir) => {
+      try {
+        const body = await readBoundedRegularFile(
+          join(tempDir, "typescript"),
+          MAX_TRANSCRIPT_BYTES,
+        );
+        return body.toString("utf8");
+      } catch {
+        return null;
+      }
+    },
     persistClaudeToken: (token) => persistClaudeTokenAtomic(token),
     persistCodexAuth: (sourceFile) => persistCodexAuthAtomic(sourceFile),
     addClaudeAccount: (label, token) =>
@@ -780,6 +801,12 @@ export class EngineLoginManager {
     if (operation.stage === "starting") {
       const authorization = findCodexAuthorization(operation.outputTail);
       if (authorization) {
+        // Symmetric with the claude branch: this breadcrumb's ABSENCE was
+        // unreadable during the 2026-08-21 hunt — silence meant either "no
+        // output arrived" or "detection fired, codex just never says so".
+        console.log(
+          `[engine-login] codex authorize URL found for ${operation.opId}; awaiting the callback URL`,
+        );
         operation.callbackTarget = authorization.target;
         operation.stage = "awaiting_callback";
         safeEmit(
@@ -807,6 +834,37 @@ export class EngineLoginManager {
       if (operation.finishPromise) await operation.finishPromise;
       return;
     }
+    if (
+      operation.engine === "claude" &&
+      result.code === 0 &&
+      operation.inputUsed &&
+      operation.tempDir
+    ) {
+      // A clean exit after the code went in means the CLI almost certainly
+      // minted and printed the token — a stream capture that saw nothing is
+      // the capture's failure, not the login's. The relayed stream can be
+      // polluted by the container runtime's own chatter (the Apple CLI's XPC
+      // noise painted characters over the cells the TUI's diff renderer
+      // skipped, corrupting the reconstructed screen — live 2026-08-21 on
+      // the Air, straight after the Linux fix). The PTY transcript is
+      // written inside the container and cannot contain that noise, so it
+      // gets the authoritative re-read before this operation is failed.
+      const transcript = await this.seams.readTranscript(operation.tempDir);
+      if (!this.isCurrent(operation) || operation.finishing) return;
+      const token = transcript
+        ? extractClaudeOAuthToken(renderTerminalScreenText(transcript))
+        : null;
+      if (token) {
+        console.log(
+          `[engine-login] token recovered from the PTY transcript for ${operation.opId}; persisting`,
+        );
+        operation.outputTail = "";
+        operation.stdoutTail = "";
+        this.beginClaudeFinish(operation, token);
+        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` +
@@ -1561,10 +1619,121 @@ function callbackReplayUrl(
   return callback.toString();
 }
 
-async function startLoginContainer(
+const LOGS_FOLLOW_ATTEMPTS = 20;
+const LOGS_FOLLOW_RETRY_MS = 200;
+const LOGS_FOLLOW_ATTACH_PROBE_MS = 500;
+
+function delayMs(ms: number): Promise<void> {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    unrefTimer(timer);
+  });
+}
+
+/**
+ * Stream a login container's output via `docker logs --follow`, which
+ * replays from byte zero — immune to the run/attach race that loses the
+ * container's first burst (see startLoginContainer). The container may not
+ * exist yet when the first attempt fires, and the client's own
+ * "No such container" stderr must never leak into the operation's output
+ * tail, so each attempt buffers until it is provably attached: container
+ * stdout, or survival past a probe window, count as proof; a quick exit
+ * with the not-found error is a retry.
+ */
+async function followLoginContainerLogs(
+  containerName: string,
+  runChild: { once(event: "close", listener: () => void): unknown },
+  onOutput: (chunk: string, stream?: "stdout" | "stderr") => void,
+): Promise<void> {
+  let runClosed = false;
+  runChild.once("close", () => {
+    runClosed = true;
+  });
+  for (let attempt = 0; attempt < LOGS_FOLLOW_ATTEMPTS; attempt += 1) {
+    const outcome = await followLoginContainerLogsOnce(
+      containerName,
+      onOutput,
+    );
+    if (outcome === "done") return;
+    // The container is absent. Before it ever starts that means "retry";
+    // after the run child closed it means the container already exited and
+    // was removed — nothing will ever appear.
+    if (runClosed) return;
+    await delayMs(LOGS_FOLLOW_RETRY_MS);
+  }
+}
+
+function followLoginContainerLogsOnce(
+  containerName: string,
+  onOutput: (chunk: string, stream?: "stdout" | "stderr") => void,
+): Promise<"done" | "absent"> {
+  return new Promise((resolve) => {
+    const follower = spawn(
+      engineLoginBackend().command,
+      ["logs", "--follow", containerName],
+      { shell: false, stdio: ["ignore", "pipe", "pipe"] },
+    );
+    follower.stdout.setEncoding("utf8");
+    follower.stderr.setEncoding("utf8");
+    const buffered: Array<{ chunk: string; stream: "stdout" | "stderr" }> = [];
+    let stderrTail = "";
+    let attached = false;
+    const flush = (): void => {
+      attached = true;
+      for (const entry of buffered) onOutput(entry.chunk, entry.stream);
+      buffered.length = 0;
+    };
+    const deliver = (chunk: string, stream: "stdout" | "stderr"): void => {
+      if (attached) {
+        onOutput(chunk, stream);
+        return;
+      }
+      buffered.push({ chunk, stream });
+      if (buffered.length > 256) buffered.shift();
+    };
+    follower.stdout.on("data", (chunk: string) => {
+      // Container stdout is proof of attachment — the docker client itself
+      // never writes to stdout here.
+      if (!attached) flush();
+      onOutput(chunk, "stdout");
+    });
+    follower.stderr.on("data", (chunk: string) => {
+      stderrTail = appendUtf8Tail(stderrTail, chunk, 4_096);
+      deliver(chunk, "stderr");
+    });
+    const probe = setTimeout(() => {
+      // Still running after the probe window: the client accepted the
+      // container and is following; anything buffered is container stderr.
+      if (follower.exitCode === null) flush();
+    }, LOGS_FOLLOW_ATTACH_PROBE_MS);
+    unrefTimer(probe);
+    follower.once("error", () => {
+      clearTimeout(probe);
+      resolve("absent");
+    });
+    follower.once("close", () => {
+      clearTimeout(probe);
+      if (
+        !attached &&
+        /no such container|dead or marked for removal/i.test(stderrTail)
+      ) {
+        resolve("absent");
+        return;
+      }
+      // A real follow that ended (container exited): deliver whatever was
+      // buffered — a fast-crashing container's stderr arrives exactly here.
+      if (!attached) flush();
+      resolve("done");
+    });
+  });
+}
+
+/** Exported for the follower-path tests and live harnesses. */
+export async function startLoginContainer(
   request: EngineLoginContainerRequest,
   onOutput: (chunk: string, stream?: "stdout" | "stderr") => void,
 ): Promise<EngineLoginProcess> {
+  const apple = engineLoginBackend().apple;
   const args = engineLoginContainerArgs(request);
   const child = spawn(engineLoginBackend().command, args, {
     shell: false,
@@ -1572,8 +1741,41 @@ async function startLoginContainer(
   });
   child.stdout.setEncoding("utf8");
   child.stderr.setEncoding("utf8");
-  child.stdout.on("data", (chunk: string) => onOutput(chunk, "stdout"));
-  child.stderr.on("data", (chunk: string) => onOutput(chunk, "stderr"));
+  if (apple) {
+    // The Apple CLI keeps the attach-stdio path: its behavior differs from
+    // Docker's and the claude flow's continuous TUI repaint has proven it
+    // live; the transcript fallback covers its noise-corruption cases.
+    child.stdout.on("data", (chunk: string) => onOutput(chunk, "stdout"));
+    child.stderr.on("data", (chunk: string) => onOutput(chunk, "stderr"));
+  } else {
+    // Docker: the attached stream can MISS the container's first output
+    // burst — `docker run` starts the container and the attach stream races
+    // its earliest writes. codex login prints its authorize URL within
+    // milliseconds and then goes silent, so a lost burst is a dead login
+    // (live 2026-08-21 on the first Linux hosts: dockerd had the URL,
+    // `docker logs` showed it, the attached client never relayed a byte).
+    // Output truth therefore comes from `docker logs --follow`, which
+    // replays from byte zero; the run child keeps ONLY stdin and lifecycle.
+    // Its stdio still drains so the client can never block on backpressure.
+    child.stdout.on("data", () => {});
+    child.stderr.on("data", () => {});
+    const logsDone = followLoginContainerLogs(
+      request.containerName,
+      child,
+      onOutput,
+    );
+    // Without `--rm`, the exited container outlives the run child so the
+    // follower can finish its replay; remove it once the follower is done
+    // (bounded — a wedged follower must not leak containers).
+    child.once("close", () => {
+      void (async () => {
+        await Promise.race([logsDone, delayMs(2_000)]);
+        await removeEngineLoginContainer(request.containerName).catch(
+          () => undefined,
+        );
+      })();
+    });
+  }
   child.stdin.on("error", () => {});
 
   let stopped = false;
@@ -1748,9 +1950,13 @@ export function engineLoginContainerArgs(
       ...command,
     ];
   }
+  // No `--rm` in the Docker dialect: output truth comes from
+  // `docker logs --follow` (see startLoginContainer), and an auto-removed
+  // fast-exiting container would take its logs with it. The host removes
+  // the container explicitly when the run child closes; the labeled stale
+  // reconcile sweeps anything a crash leaves behind.
   return [
     "run",
-    "--rm",
     "--name",
     request.containerName,
     "--label",

package/package.json

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

package/scripts/agent/_common.sh

@@ -43,12 +43,37 @@ agent_required_bins="sqlite3 jq git"
 if [ "${UAI_TASK_RUNTIME:-docker}" != "apple-container" ]; then
   agent_required_bins="$agent_required_bins docker"
 fi
+# Collect EVERY missing tool before failing: reporting them one at a time
+# cost one full fix-and-Resume round trip per binary on a fresh Amazon
+# Linux box (sqlite3, then jq — live 2026-08-21). Bash 3.2: plain string
+# accumulation, no arrays.
+missing_bins=""
 for bin in $agent_required_bins; do
   if ! command -v "$bin" >/dev/null 2>&1; then
-    printf '{"ok":false,"error":{"code":"MISSING_DEPENDENCY","message":"%s not found on PATH"}}\n' "$bin" >&2
-    exit 127
+    missing_bins="$missing_bins $bin"
   fi
 done
+if [ -n "$missing_bins" ]; then
+  missing_bins="${missing_bins# }"
+  printf '{"ok":false,"error":{"code":"MISSING_DEPENDENCY","message":"missing on PATH: %s — install with your package manager (dnf/apt/brew), then Resume"}}\n' "$missing_bins" >&2
+  exit 127
+fi
+
+
+# The docker BINARY existing does not make `docker compose` work: the v2
+# compose plugin ships separately, and a bare-engine install (Amazon Linux
+# 2023's docker package) answers `docker compose` with the top-level help
+# text — the operator saw exactly that as their task error (live
+# 2026-08-21). Called LAZILY by the task scripts right before their first
+# compose use, never at source time: argument validation must precede any
+# docker invocation (the task-down/task-up tests enforce that ordering).
+uai_require_compose_plugin() {
+  [ "${UAI_TASK_RUNTIME:-docker}" = "apple-container" ] && return 0
+  if ! docker compose version >/dev/null 2>&1; then
+    printf '{"ok":false,"error":{"code":"MISSING_DEPENDENCY","message":"missing on PATH: docker-compose-plugin — install the Docker Compose v2 plugin, then Resume"}}\n' >&2
+    exit 127
+  fi
+}
 
 # ---------------------------------------------------------------------------
 # Logger. All log lines go to stderr so stdout stays reserved for JSON.

package/scripts/agent/task-down.sh

@@ -91,6 +91,7 @@ if [ "$TASK_RUNTIME_MODE" = "apple-container" ]; then
       "container verification after cleanup"
   fi
 else
+  uai_require_compose_plugin
   step "COMPOSE_DOWN_FAILED" "docker compose down -v --rmi local"
   if [ ! -L "$task_dir" ] && [ -f "$task_dir/.uai/docker-compose.yml" ]; then
     docker compose -p "$compose_project" -f "$task_dir/.uai/docker-compose.yml" \

package/scripts/agent/task-up.sh

@@ -519,6 +519,7 @@ if [ "$TASK_RUNTIME_MODE" = "apple-container" ]; then
       "remove prior task containers"
   fi
 else
+  uai_require_compose_plugin
   if [ -f "$task_uai_dir/docker-compose.yml" ]; then
     docker compose -p "$compose_project" -f "$task_uai_dir/docker-compose.yml" \
       down --remove-orphans >/dev/null 2>&1 || true