@runuai/host 0.8.10 → 0.8.12

package/lib/agents/grok.ts

@@ -148,6 +148,11 @@ export class GrokSession implements AgentSession {
 
   private buildArgs(prompt: string): string[] {
     const args = ["exec", "-i", "-u", "node"];
+    // Host-resident API key (pasted in the engines panel, ADR-015): forward
+    // name-only — docker takes the value from the client env, keeping the
+    // secret out of argv. Subscription logins need nothing here (task-up
+    // copies ~/.grok into the container instead).
+    if (process.env.XAI_API_KEY) args.push("-e", "XAI_API_KEY");
     for (const [k, v] of Object.entries(this.agentEnv)) {
       args.push("-e", `${k}=${v}`);
     }
@@ -249,7 +254,8 @@ register({
   supportedModels: () => [...GROK_MODELS],
   defaultModel: GROK_DEFAULT_MODEL,
   supportedEfforts: () => [...GROK_EFFORTS],
-  available: () => existsSync(grokAuthPath()),
+  available: () =>
+    existsSync(grokAuthPath()) || Boolean(process.env.XAI_API_KEY),
   create: async ({ taskId, agent, containerName, systemPreamble, agentEnv }) =>
     new GrokSession({ taskId, agent, containerName, systemPreamble, agentEnv }),
 });

package/lib/engines.ts

@@ -3,20 +3,49 @@
  *
  * A single descriptor table for the AI coding engines the host can run
  * (Claude, Codex, Kimi, Grok, Cursor) plus the connect/disconnect/status logic
- * the local UI drives. This is the host-side twin of the desktop's
- * `apps/host-desktop/src/llm.ts`, but it writes the `.env.local` the RUNNING
- * launchd/npm host reads (UAI_HOME) and sets `process.env` so a connect takes
- * effect WITHOUT a host restart — the adapters' `available()` and task-up's env
- * injection both read `process.env`.
+ * the local UI drives (the desktop app renders that same UI). It writes the
+ * `.env.local` the RUNNING launchd/npm host reads (UAI_HOME) and sets
+ * `process.env` so a connect takes effect WITHOUT a host restart — the
+ * adapters' `available()` and task-up's env injection both read `process.env`.
+ *
+ * CLI resolution: a host supervised by the desktop app (or launchd) inherits a
+ * minimal GUI PATH that lacks wherever the engine CLIs live (~/.local/bin,
+ * npm/nvm/asdf prefixes, Homebrew), so spawning a bare `claude`/`codex` would
+ * ENOENT even though the CLI is installed. We resolve binaries the way the
+ * owner's terminal would — well-known install dirs first, then the login
+ * shell's PATH (same trick as the desktop's docker.ts) — and spawn with that
+ * 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.
  *
+ * Besides its primary mode, an engine can accept a pasted API key as an
+ * alternative (`apiKeyHint`/`apiKeyUrl` in the catalog drive the UI):
+ *   - claude → ANTHROPIC_API_KEY (the adapter already forwards it; a pasted
+ *     `sk-ant-oat…` still lands in CLAUDE_CODE_OAUTH_TOKEN — classified by
+ *     prefix, so either credential works in either paste box).
+ *   - codex  → ~/.codex/auth.json `{"OPENAI_API_KEY": …}`, the same plaintext
+ *     file `codex login --with-api-key` writes. Written directly (not via the
+ *     CLI): task-up docker-cp's that FILE into containers, so a keychain-backed
+ *     CLI login would break task auth, and this works with no host CLI at all.
+ *   - grok   → XAI_API_KEY (documented pay-as-you-go fallback of the grok CLI;
+ *     the adapter forwards it into task containers).
+ *   - kimi   → none: Kimi Code reads keys only from its config.toml via the
+ *     interactive `/login`, never from the environment — so we don't offer a
+ *     paste box we can't honor.
+ *
  * Detection mirrors each adapter's `available()`: env/`.env.local` for
  * claude/cursor, a config file under the owner home for codex/kimi/grok.
  *
@@ -25,7 +54,11 @@
  * the real filesystem or spawning anything.
  */
 
-import { spawn as nodeSpawn, type ChildProcess } from "node:child_process";
+import {
+  execFile as nodeExecFile,
+  spawn as nodeSpawn,
+  type ChildProcess,
+} from "node:child_process";
 import {
   chmodSync,
   existsSync,
@@ -51,6 +84,10 @@ export interface EngineCatalogEntry {
   notes: string | null;
   /** Where to mint an API key (api-key mode only). */
   getKeyUrl: string | null;
+  /** Placeholder for the pasted-API-key alternative; null = not supported. */
+  apiKeyHint: string | null;
+  /** Where to mint a key for the pasted-API-key alternative. */
+  apiKeyUrl: string | null;
 }
 
 interface EngineDescriptor {
@@ -58,6 +95,9 @@ interface EngineDescriptor {
   authMode: EngineAuthMode;
   notes: string;
   getKeyUrl?: string;
+  /** Pasted-API-key alternative (absent = login/token only, e.g. kimi). */
+  apiKeyHint?: string;
+  apiKeyUrl?: string;
 }
 
 /** Static descriptor table — the single source of truth for engine metadata. */
@@ -67,11 +107,15 @@ const DESCRIPTORS: Record<EngineKind, EngineDescriptor> = {
     authMode: "token-command",
     notes:
       "Opens your browser to authorize Claude, then captures the token automatically.",
+    apiKeyHint: "sk-ant-…",
+    apiKeyUrl: "https://console.anthropic.com/settings/keys",
   },
   codex: {
     label: "Codex",
     authMode: "login-command",
     notes: "Opens your browser to sign in to your OpenAI Codex account.",
+    apiKeyHint: "sk-…",
+    apiKeyUrl: "https://platform.openai.com/api-keys",
   },
   kimi: {
     label: "Kimi Code",
@@ -84,6 +128,8 @@ const DESCRIPTORS: Record<EngineKind, EngineDescriptor> = {
     authMode: "login-command",
     notes:
       "Sign in with your xAI Grok subscription. Activates after the next image rebuild.",
+    apiKeyHint: "xai-…",
+    apiKeyUrl: "https://console.x.ai",
   },
   cursor: {
     label: "Cursor",
@@ -101,10 +147,14 @@ const ORDER: EngineKind[] = ["claude", "codex", "kimi", "grok", "cursor"];
 // ---------------------------------------------------------------------------
 
 /** How a login/token command is spawned. Tests provide a fake. */
-export type EngineSpawn = (command: string, args: string[]) => ChildProcess;
+export type EngineSpawn = (
+  command: string,
+  args: string[],
+  env: NodeJS.ProcessEnv,
+) => 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;
@@ -112,18 +162,100 @@ export interface EngineSeams {
   ownerHome: () => string;
   /** The live process env (adapters + task-up read creds from here). */
   procEnv: NodeJS.ProcessEnv;
+  /** PATH as the owner's login shell sees it (null when unprobeable). */
+  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) =>
-      nodeSpawn(command, args, { stdio: ["ignore", "pipe", "pipe"] }),
+    spawn: (command, args, spawnEnv) =>
+      nodeSpawn(command, args, {
+        // stdin stays open (pipe): the token flow answers "Press Enter" gates.
+        stdio: ["pipe", "pipe", "pipe"],
+        env: spawnEnv,
+      }),
     envLocalPath: () => join(env.uaiHome, ".env.local"),
     ownerHome: () => process.env.UAI_OWNER_HOME?.trim() || homedir(),
     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
+ * shell — fish's `$PATH` is a list and would echo space-joined — and takes the
+ * LAST `PATH=` line so profile echo noise can't spoof it. Null on any failure;
+ * callers fall back to the inherited PATH.
+ */
+function probeLoginShellPath(): Promise<string | null> {
+  return new Promise((resolve) => {
+    const shell = process.env.SHELL?.trim() || "/bin/zsh";
+    nodeExecFile(
+      shell,
+      ["-lc", "/usr/bin/env"],
+      { timeout: 8_000 },
+      (err, stdout) => {
+        if (err) return resolve(null);
+        const lines = String(stdout)
+          .split(/\r?\n/)
+          .filter((l) => l.startsWith("PATH="));
+        const last = lines[lines.length - 1];
+        resolve(last ? last.slice("PATH=".length).trim() || null : null);
+      },
+    );
+  });
+}
+
 function withDefaults(seams: Partial<EngineSeams>): EngineSeams {
   return { ...defaultSeams(), ...seams };
 }
@@ -132,7 +264,7 @@ function withDefaults(seams: Partial<EngineSeams>): EngineSeams {
 // Public catalog / status.
 // ---------------------------------------------------------------------------
 
-/** The static engine catalog (kind, label, authMode, notes, getKeyUrl). */
+/** The static engine catalog (kind, label, authMode, notes, key URLs). */
 export function engineCatalog(): EngineCatalogEntry[] {
   return ORDER.map((kind) => {
     const d = DESCRIPTORS[kind];
@@ -142,6 +274,8 @@ export function engineCatalog(): EngineCatalogEntry[] {
       authMode: d.authMode,
       notes: d.notes,
       getKeyUrl: d.getKeyUrl ?? null,
+      apiKeyHint: d.apiKeyHint ?? null,
+      apiKeyUrl: d.apiKeyUrl ?? null,
     };
   });
 }
@@ -183,9 +317,9 @@ export function isEngineKind(value: unknown): value is EngineKind {
 // ---------------------------------------------------------------------------
 
 export interface ConnectOptions {
-  /** api-key mode: the pasted key (Cursor). */
+  /** A pasted API key — primary for Cursor, alternative for claude/codex/grok. */
   apiKey?: string;
-  /** token-command manual fallback: a pasted token (Claude). */
+  /** token-command manual fallback: a pasted token or API key (Claude). */
   pastedToken?: string;
 }
 
@@ -207,21 +341,14 @@ export async function connectEngine(
   const s = withDefaults(seams);
   const d = DESCRIPTORS[kind];
 
-  if (d.authMode === "api-key") {
-    const key = (opts.apiKey ?? "").trim();
-    if (!key) return { ok: false, message: `Paste your ${d.label} API key.` };
-    if (/\s/.test(key) || key.length < 8) {
-      return {
-        ok: false,
-        message: "That doesn't look like an API key. Paste just the value.",
-      };
-    }
-    upsertEnvLocal("CURSOR_API_KEY", key, s);
-    return { ok: true, message: `${d.label} connected.` };
+  // A pasted API key connects without spawning anything — the only flow for
+  // api-key engines (Cursor), an alternative for the others.
+  if (d.authMode === "api-key" || opts.apiKey !== undefined) {
+    return saveApiKey(kind, d, opts.apiKey ?? "", s);
   }
 
   if (d.authMode === "token-command") {
-    // Manual paste fallback — accept a token without spawning the CLI.
+    // Manual paste fallback — accept a token (or API key) without spawning.
     if (opts.pastedToken !== undefined) {
       const token = opts.pastedToken.trim();
       if (!token) return { ok: false, message: "Paste a token." };
@@ -231,7 +358,15 @@ export async function connectEngine(
           message: "That doesn't look like a token. Paste just the value.",
         };
       }
-      upsertEnvLocal("CLAUDE_CODE_OAUTH_TOKEN", token, s);
+      // One paste box serves both credential kinds — classify by prefix so an
+      // `sk-ant-api…` platform key doesn't get stored as an OAuth token.
+      upsertEnvLocal(
+        token.startsWith("sk-ant-api")
+          ? "ANTHROPIC_API_KEY"
+          : "CLAUDE_CODE_OAUTH_TOKEN",
+        token,
+        s,
+      );
       return { ok: true, message: `${d.label} connected.` };
     }
     return runTokenCommand(kind, d.label, onLog, s);
@@ -240,6 +375,70 @@ export async function connectEngine(
   return runLoginCommand(kind, d.label, onLog, s);
 }
 
+/** Persist a pasted API key where the engine's adapter actually reads it. */
+function saveApiKey(
+  kind: EngineKind,
+  d: EngineDescriptor,
+  raw: string,
+  s: EngineSeams,
+): ConnectResult {
+  const key = raw.trim();
+  if (!key) return { ok: false, message: `Paste your ${d.label} API key.` };
+  if (/\s/.test(key) || key.length < 8) {
+    return {
+      ok: false,
+      message: "That doesn't look like an API key. Paste just the value.",
+    };
+  }
+  switch (kind) {
+    case "cursor":
+      upsertEnvLocal("CURSOR_API_KEY", key, s);
+      break;
+    case "claude":
+      // Accept either credential kind here too (see the paste fallback above).
+      upsertEnvLocal(
+        key.startsWith("sk-ant-oat") ? "CLAUDE_CODE_OAUTH_TOKEN" : "ANTHROPIC_API_KEY",
+        key,
+        s,
+      );
+      break;
+    case "grok":
+      // The grok CLI's documented pay-as-you-go fallback; the adapter forwards
+      // it into task containers.
+      upsertEnvLocal("XAI_API_KEY", key, s);
+      break;
+    case "codex":
+      writeCodexAuthJson(key, s);
+      break;
+    case "kimi":
+      return {
+        ok: false,
+        message:
+          "Kimi Code authenticates via subscription sign-in — it doesn't read API keys from the environment.",
+      };
+  }
+  return { ok: true, message: `${d.label} connected.` };
+}
+
+/**
+ * Write `~/.codex/auth.json` the way `codex login --with-api-key` does. We
+ * write the plaintext file directly (not via the CLI) because task-up
+ * docker-cp's this exact FILE into containers — a keychain-backed CLI login
+ * would leave nothing to copy — and it must work without a host codex CLI.
+ */
+function writeCodexAuthJson(key: string, s: EngineSeams): void {
+  const file = join(s.ownerHome(), ".codex", "auth.json");
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, `${JSON.stringify({ OPENAI_API_KEY: key }, null, 2)}\n`, {
+    mode: 0o600,
+  });
+  try {
+    chmodSync(file, 0o600);
+  } catch {
+    /* best effort */
+  }
+}
+
 /** Disconnect an engine: forget its credential (env line and/or config file). */
 export function disconnectEngine(
   kind: EngineKind,
@@ -256,6 +455,8 @@ export function disconnectEngine(
     removeEnvLocal("ANTHROPIC_AUTH_TOKEN", s);
     return;
   }
+  // grok can be connected via login (auth.json) OR a pasted key — drop both.
+  if (kind === "grok") removeEnvLocal("XAI_API_KEY", s);
   // login-command engines: remove the config file the adapter detects.
   try {
     rmSync(configPath(kind, s), { force: true });
@@ -265,7 +466,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.
  */
@@ -299,9 +525,10 @@ function detect(kind: EngineKind, s: EngineSeams): boolean {
       );
     case "cursor":
       return envOrFileHas("CURSOR_API_KEY", s);
+    case "grok":
+      return existsSync(configPath(kind, s)) || envOrFileHas("XAI_API_KEY", s);
     case "codex":
     case "kimi":
-    case "grok":
       return existsSync(configPath(kind, s));
   }
 }
@@ -327,48 +554,174 @@ function configPath(kind: EngineKind, s: EngineSeams): string {
   return join(home, ".grok", "auth.json");
 }
 
-/** Resolve the login/token CLI binary — absolute for kimi/grok, else on PATH. */
-function resolveBin(kind: EngineKind, s: EngineSeams): string {
-  if (kind === "kimi") {
-    const local = join(s.ownerHome(), ".kimi-code", "bin", "kimi");
-    return existsSync(local) ? local : "kimi";
+/**
+ * Well-known install locations for an engine CLI — the dirs a GUI-launched
+ * host's minimal PATH misses. Home-relative entries resolve against the OWNER
+ * home (seam-injectable). The binary name equals the engine kind for all four
+ * CLI engines.
+ */
+function candidateBins(kind: EngineKind, s: EngineSeams): string[] {
+  const home = s.ownerHome();
+  const common = [join(home, ".local", "bin"), ...s.systemBinDirs];
+  switch (kind) {
+    case "claude":
+      // Native installer symlinks ~/.local/bin/claude (preferred); the older
+      // "local install" migration keeps a wrapper at ~/.claude/local/claude.
+      return [join(home, ".local", "bin"), join(home, ".claude", "local"), ...s.systemBinDirs].map(
+        (d) => join(d, "claude"),
+      );
+    case "codex":
+      return common.map((d) => join(d, "codex"));
+    case "kimi":
+      return [join(home, ".kimi-code", "bin"), ...common].map((d) =>
+        join(d, "kimi"),
+      );
+    case "grok":
+      return [join(home, ".grok", "bin"), ...common].map((d) => join(d, "grok"));
+    case "cursor":
+      return []; // api-key mode — never spawned
   }
-  if (kind === "grok") {
-    const local = join(s.ownerHome(), ".grok", "bin", "grok");
-    return existsSync(local) ? local : "grok";
+}
+
+interface ResolvedBin {
+  /** Command to spawn — absolute when found, else the bare name. */
+  bin: string;
+  /** PATH for the child, augmented so nested lookups (node, git) resolve. */
+  path: string;
+}
+
+/**
+ * Find the engine CLI the way the owner's terminal would: well-known install
+ * dirs first (fast, no subprocess), then the login shell's PATH (sources the
+ * owner's profile — covers nvm/asdf/npm prefixes), else the bare name against
+ * the inherited PATH so a genuinely missing CLI still surfaces the friendly
+ * ENOENT "install it first" message.
+ */
+async function resolveEngineBin(
+  kind: EngineKind,
+  s: EngineSeams,
+): Promise<ResolvedBin> {
+  const inherited = s.procEnv.PATH ?? "";
+  for (const file of candidateBins(kind, s)) {
+    if (existsSync(file)) {
+      return { bin: file, path: prependPath([dirname(file)], inherited) };
+    }
   }
-  // claude / codex are on PATH.
-  return kind;
+  const login = await s.loginShellPath();
+  if (login) {
+    const dirs = login.split(":").filter(Boolean);
+    const dir = dirs.find((d) => existsSync(join(d, kind)));
+    // Found or not, hand the login PATH to the child — it is the environment
+    // where the CLI (and whatever it shells out to) is known to work.
+    return {
+      bin: dir ? join(dir, kind) : kind,
+      path: prependPath(dirs, inherited),
+    };
+  }
+  return { bin: kind, path: inherited };
+}
+
+/** Prepend dirs to a colon-joined PATH, deduped, order-preserving. */
+function prependPath(prepend: string[], current: string): string {
+  const seen = new Set<string>();
+  return [...prepend, ...current.split(":")]
+    .filter((p) => p.length > 0 && !seen.has(p) && (seen.add(p), true))
+    .join(":");
 }
 
-function runTokenCommand(
+/** 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);
+  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,
   onLog: (line: string) => void,
   s: EngineSeams,
 ): Promise<ConnectResult> {
+  let child: ChildProcess;
+  try {
+    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 child: ChildProcess;
-    try {
-      child = s.spawn(resolveBin(kind, s), ["setup-token"]);
-    } catch (err) {
-      done({ ok: false, message: err instanceof Error ? err.message : String(err) });
-      return;
-    }
-    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,
@@ -379,27 +732,42 @@ 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,
+    );
   });
 }
 
-function runLoginCommand(
+async function runLoginCommand(
   kind: EngineKind,
   label: string,
   onLog: (line: string) => void,
   s: EngineSeams,
 ): Promise<ConnectResult> {
+  let child: ChildProcess;
+  try {
+    child = await spawnEngineCli(kind, ["login"], s);
+  } 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 => {
@@ -408,13 +776,6 @@ function runLoginCommand(
         resolve(r);
       }
     };
-    let child: ChildProcess;
-    try {
-      child = s.spawn(resolveBin(kind, s), ["login"]);
-    } catch (err) {
-      done({ ok: false, message: err instanceof Error ? err.message : String(err) });
-      return;
-    }
     child.stdout?.on("data", (b: Buffer) => relay(b.toString("utf8"), onLog));
     child.stderr?.on("data", (b: Buffer) => relay(b.toString("utf8"), onLog));
     child.on("error", (err: NodeJS.ErrnoException) =>

package/lib/standard-image.ts

@@ -18,12 +18,12 @@
 
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
-import { existsSync } from "node:fs";
 import { readdir, readFile } from "node:fs/promises";
-import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
+import { detectEngine } from "./engines";
+
 /** Pinned, host-wide constants (must match task-up.sh and the compose gen). */
 export const STANDARD_IMAGE_TAG = "uai-standard:dev";
 export const ASDF_DATA_VOLUME = "uai-asdf-data";
@@ -71,23 +71,21 @@ const CONTEXT_HASH_LABEL = "com.runuai.context-hash";
  */
 /**
  * Which OPTIONAL agent CLIs the operator has actually configured — so the
- * image installs only those, not every engine on every host. Keyed on the
- * same credential each adapter's `available()` checks (kimi/grok are copied
- * into containers at task-up; claude/codex are always baked). Folded into the
- * build hash below, so logging into a new engine triggers a rebuild.
+ * image installs only those, not every engine on every host. Delegates to
+ * engines.ts detection so every connect flavor counts: kimi's copied cred
+ * file, grok's login file OR a pasted XAI_API_KEY, cursor's CURSOR_API_KEY
+ * (claude/codex are always baked). Folded into the build hash below, so
+ * connecting a new engine triggers a rebuild.
  */
 export function configuredOptionalEngines(): {
   kimi: boolean;
   grok: boolean;
   cursor: boolean;
 } {
-  const home = process.env.UAI_OWNER_HOME?.trim() || homedir();
   return {
-    kimi: existsSync(join(home, ".kimi-code", "credentials", "kimi-code.json")),
-    grok: existsSync(join(home, ".grok", "auth.json")),
-    // Cursor auths via CURSOR_API_KEY (env, loaded from .env.local), not a
-    // config file — install it when the key is present.
-    cursor: Boolean(process.env.CURSOR_API_KEY),
+    kimi: detectEngine("kimi"),
+    grok: detectEngine("grok"),
+    cursor: detectEngine("cursor"),
   };
 }
 

package/package.json

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

package/scripts/agent/task-up.sh

@@ -365,6 +365,11 @@ fi
   # claude and the code-server terminal's interactive claude authenticate.
   printf '      %s: "${%s:-}"\n' \
     "CLAUDE_CODE_OAUTH_TOKEN" "CLAUDE_CODE_OAUTH_TOKEN"
+  # Pasted engine API keys (ADR-070) ride the same at-up interpolation, so the
+  # terminal CLIs authenticate like the adapters' exec-time env forwarding.
+  printf '      %s: "${%s:-}"\n' "ANTHROPIC_API_KEY" "ANTHROPIC_API_KEY"
+  printf '      %s: "${%s:-}"\n' "ANTHROPIC_AUTH_TOKEN" "ANTHROPIC_AUTH_TOKEN"
+  printf '      %s: "${%s:-}"\n' "XAI_API_KEY" "XAI_API_KEY"
   # ADR-053: point Playwright at the shared browser cache volume.
   printf '      PLAYWRIGHT_BROWSERS_PATH: "/opt/pw-browsers"\n'
   # No GH_TOKEN/GITHUB_TOKEN in the container env (ADR-027). `gh` prefers such

package/src/ui/types.ts

@@ -81,6 +81,9 @@ export const EngineCatalogEntry = z.object({
   authMode: z.enum(["token-command", "login-command", "api-key"]),
   notes: z.string().nullable(),
   getKeyUrl: z.string().nullable(),
+  // Pasted-API-key alternative to the login/token flow (null = not offered).
+  apiKeyHint: z.string().nullable(),
+  apiKeyUrl: z.string().nullable(),
 });
 export type EngineCatalogEntry = z.infer<typeof EngineCatalogEntry>;
 

package/ui/app.js

@@ -516,19 +516,25 @@ function commandForm(e) {
   actions.append(connect);
   form.append(actions, status, log);
 
-  // Claude: a manual paste fallback for when the browser flow isn't possible.
-  if (e.authMode === "token-command") {
+  // Manual paste fallback for when the browser flow isn't possible: Claude
+  // takes a token or API key (one box, classified server-side); login-command
+  // engines with an apiKeyHint (Codex, Grok) take an API key.
+  const isToken = e.authMode === "token-command";
+  if (isToken || e.apiKeyHint) {
+    const saveLabel = isToken ? "Save token" : "Save key";
     const pasteToggle = document.createElement("button");
     pasteToggle.className = "link-btn";
     pasteToggle.type = "button";
-    pasteToggle.textContent = "Paste a token instead";
+    pasteToggle.textContent = isToken
+      ? "Paste a token or API key instead"
+      : "Use an API key instead";
     const pasteWrap = document.createElement("div");
     pasteWrap.className = "engine-setup";
     pasteWrap.hidden = true;
     const pInput = document.createElement("input");
     pInput.type = "password";
     pInput.className = "text-input";
-    pInput.placeholder = "sk-ant-oat…";
+    pInput.placeholder = e.apiKeyHint || "sk-ant-…";
     pInput.autocomplete = "off";
     pInput.spellcheck = false;
     const pField = document.createElement("div");
@@ -539,30 +545,42 @@ function commandForm(e) {
     const pSave = document.createElement("button");
     pSave.className = "btn";
     pSave.type = "button";
-    pSave.textContent = "Save token";
+    pSave.textContent = saveLabel;
     pSave.addEventListener("click", async () => {
-      const pastedToken = pInput.value.trim();
-      if (!pastedToken) {
+      const value = pInput.value.trim();
+      if (!value) {
         pStatus.className = "setup-status err";
-        pStatus.textContent = "Paste a token first.";
+        pStatus.textContent = isToken ? "Paste a token first." : "Paste a key first.";
         return;
       }
       pSave.disabled = true;
       pSave.textContent = "Saving…";
-      const result = await runConnect({ kind: e.kind, pastedToken });
+      const body = isToken
+        ? { kind: e.kind, pastedToken: value }
+        : { kind: e.kind, apiKey: value };
+      const result = await runConnect(body);
       if (result.ok) {
         await poll();
         closeModal();
       } else {
         pSave.disabled = false;
-        pSave.textContent = "Save token";
+        pSave.textContent = saveLabel;
         pStatus.className = "setup-status err";
-        pStatus.textContent = result.message || "Couldn't save the token.";
+        pStatus.textContent = result.message || "Couldn't save it.";
       }
     });
     const pActions = document.createElement("div");
     pActions.className = "setup-actions";
     pActions.append(pSave);
+    if (e.apiKeyUrl) {
+      const link = document.createElement("a");
+      link.className = "link-btn";
+      link.href = e.apiKeyUrl;
+      link.target = "_blank";
+      link.rel = "noreferrer";
+      link.textContent = "Get a key";
+      pActions.append(link);
+    }
     pasteWrap.append(pField, pActions, pStatus);
     pasteToggle.addEventListener("click", () => {
       pasteWrap.hidden = !pasteWrap.hidden;