@runuai/host 0.9.104 → 0.9.106

package/lib/engine-accounts.ts

@@ -68,7 +68,17 @@ const KINDS: Record<string, KindDescriptor> = {
   // API-key engines: an extra account is one env var. The default slot stays
   // the host's own `.env.local` key (the adapters read process.env), so these
   // never synthesize a default — `defaultAvailable` is false for them.
-  grok: { authKind: "env" },
+  // Grok: a subscription sign-in is a config dir (`grok login --device-auth`
+  // writes auth.json; GROK_HOME selects it in-container). Pasted xAI keys
+  // remain `env` rows (XAI_API_KEY) — rows carry their own authKind.
+  grok: {
+    authKind: "config-dir",
+    defaultHostDir: (owner) => join(owner, ".grok"),
+    defaultContainerDir: "/home/node/.grok",
+    selectVar: "GROK_HOME",
+    containerDirPrefix: "/home/node/.grok-acct-",
+    extraHostDir: (owner, id) => join(owner, `.grok-acct-${id}`),
+  },
   cursor: { authKind: "env" },
   codex: {
     authKind: "config-dir",
@@ -838,6 +848,28 @@ export function addCodexAccountFromAuthJson(
   seams: Partial<AccountSeams> = {},
   scope: string = HOST_ACCOUNT_SCOPE,
 ): AddAccountResult {
+  return addConfigDirAccountFromAuthJson("codex", label, authJson, seams, scope);
+}
+
+/** Grok (host 0.9.105): the `auth.json` a `grok login --device-auth` capture
+ *  produced, stored as an isolated `~/.grok-acct-<id>` selected by GROK_HOME. */
+export function addGrokAccountFromAuthJson(
+  label: string,
+  authJson: string,
+  seams: Partial<AccountSeams> = {},
+  scope: string = HOST_ACCOUNT_SCOPE,
+): AddAccountResult {
+  return addConfigDirAccountFromAuthJson("grok", label, authJson, seams, scope);
+}
+
+function addConfigDirAccountFromAuthJson(
+  kind: "codex" | "grok",
+  label: string,
+  authJson: string,
+  seams: Partial<AccountSeams>,
+  scope: string,
+): AddAccountResult {
+  const engineLabel = kind === "codex" ? "Codex" : "Grok";
   if (!isEngineAccountScope(scope)) {
     return { ok: false, message: "The account scope is invalid." };
   }
@@ -850,11 +882,11 @@ export function addCodexAccountFromAuthJson(
       throw new Error("not an object");
     }
   } catch {
-    return { ok: false, message: "The captured Codex credential is not valid." };
+    return { ok: false, message: `The captured ${engineLabel} credential is not valid.` };
   }
 
   const id = newId();
-  const d = KINDS.codex as KindDescriptor;
+  const d = KINDS[kind] as KindDescriptor;
   const hostDir = (d.extraHostDir as (o: string, i: string) => string)(
     s.ownerHome(),
     id,
@@ -882,17 +914,17 @@ export function addCodexAccountFromAuthJson(
     .insert(schema.engineAccounts)
     .values({
       id,
-      kind: "codex",
+      kind,
       label: trimmedLabel,
       authKind: "config-dir",
       secretEnc: null,
       configDir: hostDir,
       createdAt: Date.now(),
       scope,
-      position: nextPosition("codex", scope),
+      position: nextPosition(kind, scope),
     })
     .run();
-  return { ok: true, message: `Added Codex account "${trimmedLabel}".`, id };
+  return { ok: true, message: `Added ${engineLabel} account "${trimmedLabel}".`, id };
 }
 
 /** Remove an EXTRA account (idempotent). The synthesized default can't be

package/lib/engine-login.ts

@@ -42,6 +42,7 @@ import {
 import {
   addCodexAccountFromAuthJson,
   addEngineAccount,
+  addGrokAccountFromAuthJson,
 } from "./engine-accounts";
 import { reinjectCodexRunningTasks } from "./codex-auth";
 import {
@@ -67,6 +68,16 @@ export const MAX_CONCURRENT_ENGINE_LOGINS = 1;
 const LOGIN_MOUNT = "/run/uai-engine-login";
 const LOGIN_HOME = `${LOGIN_MOUNT}/home`;
 const CODEX_HOME = `${LOGIN_MOUNT}/codex`;
+/** grok writes its auth.json under GROK_HOME (host 0.9.105 remote sign-in). */
+const GROK_HOME = `${LOGIN_MOUNT}/grok`;
+/** The login image only carries grok when the host had it configured at its
+ * last image build; a shared host never did. Install into the op's private
+ * HOME on the fly (x.ai's installer, ~seconds) when the image lacks it. */
+const GROK_LOGIN_SHELL =
+  'g="$(command -v grok 2>/dev/null || true)"; ' +
+  '[ -n "$g" ] || { curl -fsSL https://x.ai/cli/install.sh | bash >/dev/null 2>&1; g="$HOME/.grok/bin/grok"; }; ' +
+  '[ -x "$g" ] || { echo "grok CLI is not available in the login image" >&2; exit 127; }; ' +
+  'exec "$g" login --device-auth';
 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;
@@ -157,6 +168,15 @@ export interface EngineLoginSeams {
     authJson: string,
     scope: string,
   ): { ok: boolean; message: string; id?: string };
+  addGrokAccount(
+    label: string,
+    authJson: string,
+    scope: string,
+  ): { ok: boolean; message: string; id?: string };
+  persistGrokAuth(sourceFile: string): Promise<void>;
+  /** Optional engines ride the standard image only when configured; a fresh
+   * account may be the first configuration → rebuild (queue-deduped). */
+  ensureStandardImage(): Promise<void>;
   refreshEngineAccountAgents(engine: "claude"): Promise<void>;
   reinjectCodexRunningTasks(): Promise<void>;
   ownerHome(): string;
@@ -177,6 +197,8 @@ export interface EngineLoginManagerOptions {
   /** Defer Docker inventory until the first start when no runtime is selected. */
   reconcileOnCreate?: boolean;
   seams?: Partial<EngineLoginSeams>;
+  /** Rebuild the standard image after a successful capture (optional engines). */
+  ensureStandardImage?: () => Promise<unknown>;
 }
 
 type OperationStage =
@@ -289,6 +311,26 @@ export async function persistCodexAuthAtomic(
   );
 }
 
+export async function persistGrokAuthAtomic(
+  sourceFile: string,
+  options: { ownerHome?: string } = {},
+): Promise<void> {
+  const body = await readBoundedRegularFile(sourceFile, MAX_CODEX_AUTH_BYTES);
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(body.toString("utf8"));
+  } catch {
+    throw new Error("Grok produced invalid auth data");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Grok produced invalid auth data");
+  }
+  await writeSensitiveFileAtomic(
+    join(options.ownerHome ?? ownerHome(), ".grok", "auth.json"),
+    body,
+  );
+}
+
 function defaultSeams(options: EngineLoginManagerOptions): EngineLoginSeams {
   const tempRoot = options.tempRoot;
   return {
@@ -315,6 +357,12 @@ function defaultSeams(options: EngineLoginManagerOptions): EngineLoginSeams {
       addEngineAccount("claude", label, { token }, {}, scope),
     addCodexAccount: (label, authJson, scope) =>
       addCodexAccountFromAuthJson(label, authJson, {}, scope),
+    addGrokAccount: (label, authJson, scope) =>
+      addGrokAccountFromAuthJson(label, authJson, {}, scope),
+    persistGrokAuth: (sourceFile) => persistGrokAuthAtomic(sourceFile),
+    ensureStandardImage: async () => {
+      await options.ensureStandardImage?.();
+    },
     refreshEngineAccountAgents: options.refreshEngineAccountAgents,
     reinjectCodexRunningTasks: () => reinjectCodexRunningTasks(),
     ownerHome,
@@ -362,6 +410,9 @@ export class EngineLoginManager {
     const codexConfigured = this.seams.fileExists(
       join(this.seams.ownerHome(), ".codex", "auth.json"),
     );
+    const grokConfigured =
+      this.seams.fileExists(join(this.seams.ownerHome(), ".grok", "auth.json")) ||
+      Boolean(this.seams.procEnv.XAI_API_KEY);
     return [
       {
         engine: "claude",
@@ -373,6 +424,11 @@ export class EngineLoginManager {
         status: codexConfigured ? "configured" : "missing",
         loginSupported: true,
       },
+      {
+        engine: "grok",
+        status: grokConfigured ? "configured" : "missing",
+        loginSupported: true,
+      },
     ];
   }
 
@@ -853,10 +909,13 @@ export class EngineLoginManager {
     }
 
     if (operation.stage === "starting") {
-      const device = findCodexDeviceAuthorization(operation.outputTail);
+      const device =
+        operation.engine === "grok"
+          ? findGrokDeviceAuthorization(operation.outputTail)
+          : findCodexDeviceAuthorization(operation.outputTail);
       if (device) {
         console.log(
-          `[engine-login] codex device authorization found for ${operation.opId}; awaiting operator confirmation`,
+          `[engine-login] ${operation.engine} device authorization found for ${operation.opId}; awaiting operator confirmation`,
         );
         operation.stage = "awaiting_confirmation";
         safeEmit(
@@ -873,6 +932,7 @@ export class EngineLoginManager {
         });
         return;
       }
+      if (operation.engine !== "codex") return;
       const authorization = findCodexAuthorization(operation.outputTail);
       if (authorization) {
         // Symmetric with the claude branch: this breadcrumb's ABSENCE was
@@ -903,7 +963,10 @@ export class EngineLoginManager {
     result: EngineLoginProcessResult,
   ): Promise<void> {
     if (!this.isCurrent(operation) || operation.finishing) return;
-    if (operation.engine === "codex" && result.code === 0) {
+    if (
+      (operation.engine === "codex" || operation.engine === "grok") &&
+      result.code === 0
+    ) {
       this.beginCodexFinish(operation);
       if (operation.finishPromise) await operation.finishPromise;
       return;
@@ -1037,25 +1100,34 @@ export class EngineLoginManager {
   private async commitCodex(operation: LoginOperation): Promise<void> {
     const tempDir = operation.tempDir;
     if (!tempDir) return;
+    // codex and grok share the shape: a device-code CLI that exits 0 after
+    // writing auth.json under its HOME var (CODEX_HOME / GROK_HOME), which
+    // the container mounts from the op's private leaf.
+    const grok = operation.engine === "grok";
+    const authFile = join(tempDir, grok ? "grok" : "codex", "auth.json");
+    const label = grok ? "Grok" : "Codex";
     let terminal: EngineLoginEventFrame;
     if (operation.accountLabel !== null) {
       // ADR-116: labeled capture — the auth.json this login produced becomes
       // an isolated extra account instead of overwriting ~/.codex.
       let added: { ok: boolean; message: string; id?: string };
       try {
-        const contents = await readFile(
-          join(tempDir, "codex", "auth.json"),
-          "utf8",
-        );
-        added = this.seams.addCodexAccount(
-          operation.accountLabel,
-          contents,
-          operation.accountScope,
-        );
+        const contents = await readFile(authFile, "utf8");
+        added = grok
+          ? this.seams.addGrokAccount(
+              operation.accountLabel,
+              contents,
+              operation.accountScope,
+            )
+          : this.seams.addCodexAccount(
+              operation.accountLabel,
+              contents,
+              operation.accountScope,
+            );
       } catch {
         added = {
           ok: false,
-          message: "Codex authorized, but its credential could not be read.",
+          message: `${label} authorized, but its credential could not be read.`,
         };
       }
       terminal = added.ok
@@ -1074,31 +1146,32 @@ export class EngineLoginManager {
             added.message,
           );
       await this.finishCommit(operation, terminal);
+      if (added.ok) runBestEffort(() => this.seams.ensureStandardImage());
       return;
     }
     try {
-      await this.seams.persistCodexAuth(
-        join(tempDir, "codex", "auth.json"),
-      );
+      if (grok) await this.seams.persistGrokAuth(authFile);
+      else await this.seams.persistCodexAuth(authFile);
     } catch {
       terminal = failedEvent(
         operation.opId,
         operation.engine,
         "persist_failed",
-        "Codex authorized, but its credential could not be saved.",
+        `${label} authorized, but its credential could not be saved.`,
       );
       await this.finishCommit(operation, terminal);
       return;
     }
-    runBestEffort(() => this.seams.reinjectCodexRunningTasks());
+    if (!grok) runBestEffort(() => this.seams.reinjectCodexRunningTasks());
     terminal = {
       kind: "engine.login.event",
       opId: operation.opId,
       engine: operation.engine,
       phase: "succeeded",
-      message: "Codex connected.",
+      message: `${label} connected.`,
     };
     await this.finishCommit(operation, terminal);
+    runBestEffort(() => this.seams.ensureStandardImage());
   }
 
   private async finishCommit(
@@ -1319,8 +1392,8 @@ function safeEmit(
   }
 }
 
-function engineLabel(engine: EngineLoginKind): "Claude" | "Codex" {
-  return engine === "claude" ? "Claude" : "Codex";
+function engineLabel(engine: EngineLoginKind): "Claude" | "Codex" | "Grok" {
+  return engine === "claude" ? "Claude" : engine === "codex" ? "Codex" : "Grok";
 }
 
 function failedEvent(
@@ -1571,6 +1644,26 @@ export function findCodexDeviceAuthorization(
   return { verificationUrl, userCode: code[1]! };
 }
 
+/**
+ * Grok `login --device-auth` banner (host 0.9.105): "To sign in, open this
+ * URL in your browser: https://accounts.x.ai/oauth2/device?user_code=XXXX-XXXX
+ * … Confirm this code in your browser: XXXX-XXXX". Phrase gate + code shape,
+ * same posture as the codex parser; grok prints to stderr.
+ */
+export function findGrokDeviceAuthorization(
+  value: string,
+): { verificationUrl: string; userCode: string } | null {
+  const plain = stripTerminalControl(value);
+  if (!/confirm this code|open this url/i.test(plain)) return null;
+  const verificationUrl = findSafeHttpsUrl(plain);
+  if (!verificationUrl) return null;
+  const code =
+    /user_code=([A-Z0-9]{4,8}-[A-Z0-9]{4,10})\b/.exec(plain) ??
+    /(?:^|\s)([A-Z0-9]{4,8}-[A-Z0-9]{4,10})(?:\s|$)/m.exec(plain);
+  if (!code) return null;
+  return { verificationUrl, userCode: code[1]! };
+}
+
 export function extractClaudeOAuthToken(value: string): string | null {
   const plain = stripTerminalControl(value);
   // The FULL `sk-ant-oat01-` prefix and a realistic minimum length are both
@@ -2003,7 +2096,9 @@ export function engineLoginContainerArgs(
           // because the typescript went to /dev/null.
           `${LOGIN_MOUNT}/typescript`,
         ]
-      : // Device-code flow: no localhost callback, no paste — the CLI prints
+      : request.engine === "grok"
+        ? ["sh", "-c", GROK_LOGIN_SHELL]
+        : // Device-code flow: no localhost callback, no paste — the CLI prints
         // a verification URL + one-time code, the operator confirms on the
         // provider's page, and the CLI polls to completion (ADR-116 v2,
         // 2026-08-24). The callback machinery below stays as the fallback
@@ -2050,6 +2145,8 @@ export function engineLoginContainerArgs(
       "--env",
       `CODEX_HOME=${CODEX_HOME}`,
       "--env",
+      `GROK_HOME=${GROK_HOME}`,
+      "--env",
       "ASDF_CONFIG_FILE=/dev/null",
       "--env",
       "ASDF_DEFAULT_TOOL_VERSIONS_FILENAME=.tool-versions",
@@ -2095,6 +2192,8 @@ export function engineLoginContainerArgs(
     "--env",
     `CODEX_HOME=${CODEX_HOME}`,
     "--env",
+    `GROK_HOME=${GROK_HOME}`,
+    "--env",
     "ASDF_CONFIG_FILE=/dev/null",
     "--env",
     "ASDF_DEFAULT_TOOL_VERSIONS_FILENAME=.tool-versions",
@@ -2426,6 +2525,7 @@ export async function createEngineLoginTempDir(
     // self-creates its HOME). Create both up front.
     await mkdir(join(path, "home"), { mode: 0o700 });
     await mkdir(join(path, "codex"), { mode: 0o700 });
+    await mkdir(join(path, "grok"), { mode: 0o700 });
     await syncDirectory(path);
     return path;
   } catch (error) {

package/lib/machine-provider-aws.ts

@@ -279,10 +279,19 @@ async function hostEgressIp(): Promise<string> {
   );
 }
 
+/** How long a resolved payload AMI is trusted before the newest published
+ * image is looked up again. Long enough that a burst of launches shares one
+ * describe-images; short enough that a freshly published image reaches every
+ * RUNNING host — shared and BYO — on its next task without a host restart
+ * (before 0.9.106 the answer was kept for the process lifetime). */
+export const PAYLOAD_AMI_TTL_MS = 5 * 60_000;
+
 export function createAwsMachineProvider(
   config: AwsMachineConfig,
   runner: Runner = defaultRunner(config.region),
+  deps: { now?: () => number } = {},
 ): MachineProvider {
+  const now = deps.now ?? (() => Date.now());
   const taskIdOf = (machineId: string): string => {
     if (!machineId.startsWith("uai-machine-")) {
       throw new Error(`not a uai machine id: ${machineId}`);
@@ -332,10 +341,12 @@ export function createAwsMachineProvider(
   // orchestrator can never reach.
   // -------------------------------------------------------------------------
 
-  let resolvedImage: string | null = null;
+  let resolvedImage: { id: string; at: number } | null = null;
   async function resolveImage(specImage: string): Promise<string> {
     if (specImage.startsWith("ami-")) return specImage;
-    if (resolvedImage) return resolvedImage;
+    if (resolvedImage && now() - resolvedImage.at < PAYLOAD_AMI_TTL_MS) {
+      return resolvedImage.id;
+    }
     const res = await runner([
       "ec2",
       "describe-images",
@@ -356,12 +367,24 @@ export function createAwsMachineProvider(
       }
     }
     if (typeof image !== "string" || !image.startsWith("ami-")) {
+      // A stale-but-known image beats a failed launch when the lookup itself
+      // hiccups; only a host that never resolved one has nothing to offer.
+      if (resolvedImage) return resolvedImage.id;
       throw new Error(
         `no uai machine payload AMI is published in ${config.region} — set ` +
           "UAI_MACHINE_IMAGE to an AMI id, or ask Uai to publish this region",
       );
     }
-    resolvedImage = image;
+    if (resolvedImage?.id !== image) {
+      // The journal line that tells an operator which payload a task got —
+      // an exit 127 for a missing CLI is otherwise the only symptom of a
+      // region that never received the latest publish.
+      console.log(
+        `[machine-aws] payload image for ${config.region}: ${image}` +
+          (resolvedImage ? ` (was ${resolvedImage.id})` : ""),
+      );
+    }
+    resolvedImage = { id: image, at: now() };
     return image;
   }
 

package/lib/standard-image.ts

@@ -27,6 +27,7 @@ import {
   recycleAppleRuntimeServices,
 } from "./apple-runtime-recycle";
 import { detectEngine } from "./engines";
+import { hasStoredEngineAccounts } from "./engine-accounts";
 import {
   appleContainerRuntimeBinding,
   claimContainerRuntimeForMaintenance,
@@ -112,11 +113,17 @@ export function configuredOptionalEngines(): {
   cursor: boolean;
   opencode: boolean;
 } {
+  // A stored account (a workspace's, on a shared host; a labeled extra on an
+  // owned one) needs the CLI in the image just like the host's own sign-in
+  // does — without this a grok/cursor account existed but its tasks exited
+  // 127 for a missing binary.
+  const on = (kind: "kimi" | "grok" | "cursor" | "opencode"): boolean =>
+    detectEngine(kind) || hasStoredEngineAccounts(kind);
   return {
-    kimi: detectEngine("kimi"),
-    grok: detectEngine("grok"),
-    cursor: detectEngine("cursor"),
-    opencode: detectEngine("opencode"),
+    kimi: on("kimi"),
+    grok: on("grok"),
+    cursor: on("cursor"),
+    opencode: on("opencode"),
   };
 }
 

package/package.json

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

package/src/main.ts

@@ -462,6 +462,9 @@ const engineLoginManager = createEngineLoginManager({
     getOrchestrator().refreshEngineAccountAgents(engine),
   tempRoot: join(env.uaiHome, "engine-login-bind"),
   reconcileOnCreate: false,
+  // A grok sign-in may be the first grok configuration on this host: the
+  // standard image needs the CLI before its tasks can run (host 0.9.105).
+  ensureStandardImage: () => ensureStandardImage(),
 });
 // ADR-117: one-shot connect (pasted key / OpenCode re-detect) over the bridge.
 const engineConnectManager = createEngineConnectManager({

package/src/protocol.ts

@@ -326,7 +326,10 @@ export type HostLogsEndFrame =
       message: string;
     };
 
-export type EngineLoginKind = "claude" | "codex";
+/** Engines with a REMOTE sign-in (login container driven from the cloud).
+ * grok since host 0.9.105: `grok login --device-auth`, same device-code shape
+ * as codex. Kimi/OpenCode remain host-terminal (or key) for now. */
+export type EngineLoginKind = "claude" | "codex" | "grok";
 export type EngineLoginPhase =
   | "starting"
   | "authorize"
@@ -668,7 +671,7 @@ function isBoundedMessage(value: unknown): value is string {
 }
 
 function isEngineLoginKind(value: unknown): value is EngineLoginKind {
-  return value === "claude" || value === "codex";
+  return value === "claude" || value === "codex" || value === "grok";
 }
 
 function isEngineLoginErrorCode(value: unknown): value is EngineLoginErrorCode {