@runuai/host 0.9.103 → 0.9.105

package/db/migrations/0018_engine_account_position.sql

@@ -0,0 +1,3 @@
+-- Manage-v1 (host 0.9.104): explicit priority order for a kind's extra
+-- accounts within a scope. Existing rows keep 0 and fall back to created_at.
+ALTER TABLE `host_engine_accounts` ADD `position` integer NOT NULL DEFAULT 0;

package/db/migrations/meta/_journal.json

@@ -127,6 +127,13 @@
       "when": 1788820000000,
       "tag": "0017_engine_account_scope",
       "breakpoints": true
+    },
+    {
+      "idx": 18,
+      "version": "6",
+      "when": 1788900000000,
+      "tag": "0018_engine_account_position",
+      "breakpoints": true
     }
   ]
 }

package/db/schema.ts

@@ -278,6 +278,9 @@ export const engineAccounts = sqliteTable("host_engine_accounts", {
   // ADR-131 D3: "host" (owner-level, default) or "org:<orgId>" (a workspace's
   // account on a shared host). Resolution is by exact scope.
   scope: text("scope").notNull().default("host"),
+  // Manage-v1: priority within (scope, kind) — tasks pick the first healthy
+  // account in ascending position; ties break on created_at.
+  position: integer("position", { mode: "number" }).notNull().default(0),
   createdAt: integer("created_at", { mode: "number" }).notNull(),
 });
 

package/lib/engine-accounts.ts

@@ -25,6 +25,7 @@
 import {
   HOST_ACCOUNT_SCOPE,
   isEngineAccountScope,
+  isEngineAccountLabel,
 } from "../src/protocol";
 import { chmodSync, existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
@@ -67,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",
@@ -280,7 +291,8 @@ function resolveExtras(
       (r) =>
         r.kind === kind &&
         accountInScope((r as { scope?: string | null }).scope, scope),
-    );
+    )
+    .sort(compareAccountRows);
   const out: ResolvedEngineAccount[] = [];
   for (const row of rows) {
     if (row.authKind === "env") {
@@ -440,8 +452,16 @@ export function selectAccount(
   if (candidates.length === 0) return null;
   const lru = (a: ResolvedEngineAccount): number => state(a.id).lastUsedAt;
   const healthy = candidates.filter((a) => state(a.id).cooldownUntil <= now);
-  const pool = healthy.length > 0 ? healthy : candidates;
-  return pool.reduce((best, a) => (lru(a) < lru(best) ? a : best), pool[0]!);
+  // Manage-v1: the list arrives in PRIORITY order (default slot, then extras
+  // by position) — the first healthy account wins, so the operator's
+  // ordering decides which account a task uses and which are fallbacks.
+  // Only when every account is cooling do we fall back to the least recently
+  // used one (the stalest cooldown is the likeliest to have lifted).
+  if (healthy.length > 0) return healthy[0]!;
+  return candidates.reduce(
+    (best, a) => (lru(a) < lru(best) ? a : best),
+    candidates[0]!,
+  );
 }
 
 /** Pick an account for a kind (default + extras), applying rotation state. */
@@ -663,6 +683,30 @@ export async function provisionEngineAccounts(
   return { copied, failed, mayHaveMutated };
 }
 
+/** Priority order within (scope, kind): position, then age. Rows from before
+ *  manage-v1 all carry 0 and therefore keep their creation order. */
+function compareAccountRows(
+  a: { position?: number | null; createdAt: number; id: string },
+  b: { position?: number | null; createdAt: number; id: string },
+): number {
+  return (
+    (a.position ?? 0) - (b.position ?? 0) ||
+    a.createdAt - b.createdAt ||
+    a.id.localeCompare(b.id)
+  );
+}
+
+/** New accounts join the END of their (scope, kind) order. */
+function nextPosition(kind: string, scope: string): number {
+  let max = -1;
+  for (const row of getDb().select().from(schema.engineAccounts).all()) {
+    if (row.kind !== kind) continue;
+    if (((row as { scope?: string | null }).scope ?? HOST_ACCOUNT_SCOPE) !== scope) continue;
+    max = Math.max(max, (row as { position?: number | null }).position ?? 0);
+  }
+  return max + 1;
+}
+
 // ---------------------------------------------------------------------------
 // Mutations (host UI).
 // ---------------------------------------------------------------------------
@@ -715,6 +759,7 @@ export function addEngineAccount(
         configDir: null,
         createdAt: now,
         scope,
+        position: nextPosition(kind, scope),
       })
       .run();
     return { ok: true, message: `Added Claude account "${trimmedLabel}".`, id };
@@ -733,6 +778,7 @@ export function addEngineAccount(
         configDir: null,
         createdAt: now,
         scope,
+        position: nextPosition(kind, scope),
       })
       .run();
     return {
@@ -778,6 +824,7 @@ export function addEngineAccount(
         configDir: hostDir,
         createdAt: now,
         scope,
+        position: nextPosition(kind, scope),
       })
       .run();
     return { ok: true, message: `Added Codex account "${trimmedLabel}".`, id };
@@ -801,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." };
   }
@@ -813,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,
@@ -845,16 +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(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
@@ -900,3 +970,78 @@ export function removeEngineAccount(
   }
   return { ok: true, message: `Removed "${row.label}".` };
 }
+
+/** Manage-v1: relabel an extra account. Same scope rule as removal. */
+export function renameEngineAccount(
+  id: string,
+  label: string,
+  scope?: string,
+): { ok: boolean; message: string } {
+  if (id.startsWith("default:")) {
+    return { ok: false, message: "The default account cannot be renamed." };
+  }
+  const trimmed = label.trim();
+  if (!isEngineAccountLabel(trimmed)) {
+    return { ok: false, message: "Give the account a label (up to 64 characters)." };
+  }
+  const row = getDb()
+    .select()
+    .from(schema.engineAccounts)
+    .where(eq(schema.engineAccounts.id, id))
+    .get();
+  if (!row) return { ok: false, message: "That account no longer exists." };
+  if (!accountRemovableInScope(row, scope)) {
+    return { ok: false, message: "That account belongs to a different scope." };
+  }
+  getDb()
+    .update(schema.engineAccounts)
+    .set({ label: trimmed })
+    .where(eq(schema.engineAccounts.id, id))
+    .run();
+  return { ok: true, message: `Renamed to "${trimmed}".` };
+}
+
+/**
+ * Manage-v1: set the priority order of `kind`'s extra accounts in `scope`.
+ * `ids` must be exactly the set of that kind's rows in the scope — a stale
+ * list (an account added or removed meanwhile) is refused rather than
+ * silently partially applied.
+ */
+export function reorderEngineAccounts(
+  kind: string,
+  ids: readonly string[],
+  scope: string = HOST_ACCOUNT_SCOPE,
+): { ok: boolean; message: string } {
+  if (!isEngineAccountScope(scope)) {
+    return { ok: false, message: "The account scope is invalid." };
+  }
+  const rows = getDb()
+    .select()
+    .from(schema.engineAccounts)
+    .all()
+    .filter(
+      (r) =>
+        r.kind === kind &&
+        ((r as { scope?: string | null }).scope ?? HOST_ACCOUNT_SCOPE) === scope,
+    );
+  const have = new Set(rows.map((r) => r.id));
+  const want = new Set(ids);
+  if (
+    have.size !== want.size ||
+    ids.length !== want.size ||
+    [...have].some((id) => !want.has(id))
+  ) {
+    return {
+      ok: false,
+      message: "The account list changed — refresh and try again.",
+    };
+  }
+  ids.forEach((id, index) => {
+    getDb()
+      .update(schema.engineAccounts)
+      .set({ position: index })
+      .where(eq(schema.engineAccounts.id, id))
+      .run();
+  });
+  return { ok: true, message: "Order saved." };
+}

package/lib/engine-connect.ts

@@ -166,7 +166,7 @@ export class EngineConnectManager {
         scope ?? HOST_ACCOUNT_SCOPE,
       );
       if (added.ok) this.afterMutation(engine, false);
-      this.finish(operation, added.ok, added.message);
+      this.finish(operation, added.ok, added.message, added.id);
       return;
     }
     // ADR-131 D3: everything below writes the host's DEFAULT slot or re-detects
@@ -207,6 +207,7 @@ export class EngineConnectManager {
     operation: ConnectOperation,
     ok: boolean,
     message: string,
+    accountId?: string,
   ): void {
     if (operation.done) return;
     operation.done = true;
@@ -221,6 +222,7 @@ export class EngineConnectManager {
       phase: "done",
       ok,
       message,
+      ...(ok && accountId !== undefined ? { accountId } : {}),
     });
   }
 }

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;
@@ -151,12 +162,21 @@ export interface EngineLoginSeams {
     label: string,
     token: string,
     scope: string,
-  ): { ok: boolean; message: string };
+  ): { ok: boolean; message: string; id?: string };
   addCodexAccount(
     label: string,
     authJson: string,
     scope: string,
-  ): { ok: boolean; message: 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(
@@ -868,10 +927,12 @@ export class EngineLoginManager {
           opId: operation.opId,
           engine: operation.engine,
           phase: "awaiting_confirmation",
+          code: device.userCode,
           message: `Enter code ${device.userCode} on the verification page. Nothing to paste here — this completes on its own.`,
         });
         return;
       }
+      if (operation.engine !== "codex") return;
       const authorization = findCodexAuthorization(operation.outputTail);
       if (authorization) {
         // Symmetric with the claude branch: this breadcrumb's ABSENCE was
@@ -902,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;
@@ -983,6 +1047,7 @@ export class EngineLoginManager {
             engine: operation.engine,
             phase: "succeeded",
             message: added.message,
+            ...(added.id === undefined ? {} : { accountId: added.id }),
           }
         : failedEvent(
             operation.opId,
@@ -1035,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 };
+      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
@@ -1063,6 +1137,7 @@ export class EngineLoginManager {
             engine: operation.engine,
             phase: "succeeded",
             message: added.message,
+            ...(added.id === undefined ? {} : { accountId: added.id }),
           }
         : failedEvent(
             operation.opId,
@@ -1071,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(
@@ -1316,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(
@@ -1568,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
@@ -2000,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
@@ -2047,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",
@@ -2092,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",
@@ -2423,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/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.103",
+  "version": "0.9.105",
   "description": "Uai host — runs ephemeral AI tasks in containers on a machine you control.",
   "license": "MIT",
   "author": "Uai Tech <team@runuai.com>",

package/src/index.ts

@@ -118,7 +118,11 @@ export type {
   TaskUpResult,
 } from "../lib/agent";
 
-import { removeEngineAccount } from "../lib/engine-accounts";
+import {
+  removeEngineAccount,
+  renameEngineAccount,
+  reorderEngineAccounts,
+} from "../lib/engine-accounts";
 
 export {
   parseMentions,
@@ -1239,6 +1243,34 @@ export const hostCommands: HostCommands = {
     }
   },
 
+  async engineAccountRename(ctx, input) {
+    logCommand(ctx, "engineAccountRename", input.id);
+    try {
+      const result = renameEngineAccount(input.id, input.label, input.scope);
+      return ok(
+        result.ok
+          ? { renamed: true }
+          : { renamed: false, message: result.message },
+      );
+    } catch (err) {
+      return failFromUnknown(err);
+    }
+  },
+
+  async engineAccountReorder(ctx, input) {
+    logCommand(ctx, "engineAccountReorder", input.kind);
+    try {
+      const result = reorderEngineAccounts(input.kind, input.ids, input.scope);
+      return ok(
+        result.ok
+          ? { reordered: true }
+          : { reordered: false, message: result.message },
+      );
+    } catch (err) {
+      return failFromUnknown(err);
+    }
+  },
+
   async channelResolvePermission(ctx, taskId, agentId, requestId, decision) {
     logCommand(ctx, "channelResolvePermission", taskId, agentId, requestId);
     try {

package/src/main.ts

@@ -186,6 +186,7 @@ import {
   HOST_TASK_STOP_PROTOCOL_FEATURE,
   HOST_ENGINE_ACCOUNTS_PROTOCOL_FEATURE,
   HOST_ENGINE_CONNECT_PROTOCOL_FEATURE,
+  HOST_ENGINE_ACCOUNT_MANAGE_PROTOCOL_FEATURE,
   HOST_ENGINE_ACCOUNT_SCOPES_PROTOCOL_FEATURE,
   HOST_ENGINE_LOGIN_PROTOCOL_FEATURE,
   isEngineAccountScope,
@@ -230,6 +231,7 @@ import {
   type TaskLaunchInput,
   type FilesOpInput,
   engineAccountScopeFromWire,
+  isEngineAccountLabel,
 } from "./protocol";
 
 setContainerRuntimeOperationalCheck(() => containerRuntimeProblem() === null);
@@ -460,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({
@@ -609,6 +614,7 @@ function buildCapabilities(): HostCapabilities {
       HOST_ENGINE_ACCOUNTS_PROTOCOL_FEATURE,
       HOST_ENGINE_CONNECT_PROTOCOL_FEATURE,
       HOST_ENGINE_ACCOUNT_SCOPES_PROTOCOL_FEATURE,
+      HOST_ENGINE_ACCOUNT_MANAGE_PROTOCOL_FEATURE,
       // The echo adapter cannot execute the in-task CLI. Advertising typed
       // dispatch in mock mode would let the composer create a Secretary that
       // has no way to wake crew.
@@ -2443,7 +2449,68 @@ async function dispatchCommand(
       if (removal.ok) sendCapabilities();
       return removal;
     }
+    case "engineAccountRename": {
+      const renamed = await hostCommands.engineAccountRename(
+        ctx,
+        expectEngineAccountRenameInput(args, 0),
+      );
+      if (renamed.ok) sendCapabilities();
+      return renamed;
+    }
+    case "engineAccountReorder": {
+      const reordered = await hostCommands.engineAccountReorder(
+        ctx,
+        expectEngineAccountReorderInput(args, 0),
+      );
+      if (reordered.ok) sendCapabilities();
+      return reordered;
+    }
+  }
+}
+
+function expectEngineAccountRenameInput(
+  args: unknown[],
+  index: number,
+): { id: string; label: string; scope?: string } {
+  const base = expectEngineAccountRemoveInput(args, index);
+  const label = (args[index] as { label?: unknown }).label;
+  if (!isEngineAccountLabel(label)) {
+    throw new Error(`invalid command args: bad account label at ${index}`);
+  }
+  return { ...base, label };
+}
+
+function expectEngineAccountReorderInput(
+  args: unknown[],
+  index: number,
+): { kind: string; ids: string[]; scope?: string } {
+  const value = args[index];
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`invalid command args: expected reorder input at ${index}`);
   }
+  const { kind, ids, scope } = value as {
+    kind?: unknown;
+    ids?: unknown;
+    scope?: unknown;
+  };
+  if (typeof kind !== "string" || !/^[a-z][a-z0-9-]{0,31}$/.test(kind)) {
+    throw new Error(`invalid command args: bad account kind at ${index}`);
+  }
+  if (
+    !Array.isArray(ids) ||
+    ids.length > 64 ||
+    ids.some((id) => typeof id !== "string" || id.length === 0 || id.length > 256)
+  ) {
+    throw new Error(`invalid command args: bad account id list at ${index}`);
+  }
+  if (scope !== undefined && !isEngineAccountScope(scope)) {
+    throw new Error(`invalid command args: bad account scope at ${index}`);
+  }
+  return {
+    kind,
+    ids: ids as string[],
+    ...(scope !== undefined ? { scope } : {}),
+  };
 }
 
 function expectEngineAccountRemoveInput(
@@ -2981,6 +3048,8 @@ const HOST_COMMAND_NAMES = {
   appendTranscript: true,
   previewEnsure: true,
   engineAccountRemove: true,
+  engineAccountRename: true,
+  engineAccountReorder: true,
 } satisfies Record<keyof HostCommands, true>;
 
 function isHostCommand(command: string): command is keyof HostCommands {

package/src/protocol.ts

@@ -109,6 +109,12 @@ export const HOST_ENGINE_CONNECT_PROTOCOL_FEATURE = "host-engine-connect-v1";
  * and stamps `scope` on every EngineAccountSummary it advertises. The cloud
  * sends none of those to a host without the feature (the v1 exact-shape
  * guards would reject the frames). */
+/** Account management v1 (host 0.9.104): `engineAccountRename` and
+ * `engineAccountReorder` commands; login `succeeded` events carry the created
+ * `accountId` for labeled captures; codex `awaiting_confirmation` carries the
+ * device `code`. Extras are advertised in priority order (position). */
+export const HOST_ENGINE_ACCOUNT_MANAGE_PROTOCOL_FEATURE =
+  "host-engine-account-manage-v1";
 export const HOST_ENGINE_ACCOUNT_SCOPES_PROTOCOL_FEATURE =
   "host-engine-account-scopes-v1";
 /** The owner-level account scope; every pre-scope account lives here. */
@@ -320,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"
@@ -386,11 +395,15 @@ export type EngineLoginEventFrame =
       phase: "authorize";
       url: string;
       errorCode?: never;
+      code?: never;
+      accountId?: never;
     })
   | (EngineLoginEventBase & {
       phase: "failed" | "timed_out";
       url?: never;
       errorCode?: EngineLoginErrorCode;
+      code?: never;
+      accountId?: never;
     })
   | (EngineLoginEventBase & {
       phase:
@@ -404,6 +417,12 @@ export type EngineLoginEventFrame =
         | "cancelled";
       url?: never;
       errorCode?: never;
+      /** Device-code flow only (`awaiting_confirmation`): the one-time code
+       * the operator enters on the provider's page — shown large in the UI. */
+      code?: string;
+      /** `succeeded` of a LABELED capture: the id of the account it created,
+       * so the client can rename/order it right away. */
+      accountId?: string;
     });
 
 /** Rolling-safe, secret-free engine state. v1 intentionally makes no claim
@@ -482,6 +501,9 @@ export interface EngineConnectEventFrame {
   line?: string;
   ok?: boolean;
   message?: string;
+  /** Manage-v1: `done` of a LABELED connect — the id of the account it
+   * created, so the client can name/order it right away. */
+  accountId?: string;
 }
 
 export function isEngineConnectKind(
@@ -541,7 +563,7 @@ export function isEngineConnectEventFrame(
   const frame = exactWireObject(
     value,
     ["kind", "opId", "engine", "phase"],
-    ["line", "ok", "message"],
+    ["line", "ok", "message", "accountId"],
   );
   if (
     !frame ||
@@ -551,6 +573,16 @@ export function isEngineConnectEventFrame(
   ) {
     return false;
   }
+  if (
+    Object.hasOwn(frame, "accountId") &&
+    (frame.phase !== "done" ||
+      frame.ok !== true ||
+      typeof frame.accountId !== "string" ||
+      frame.accountId.length < 1 ||
+      frame.accountId.length > 256)
+  ) {
+    return false;
+  }
   if (frame.phase === "line") {
     return (
       typeof frame.line === "string" &&
@@ -639,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 {
@@ -773,6 +805,16 @@ export function isEngineLoginStartFrame(
 /** ADR-116 account labels: operator-chosen display names, never secrets.
  * Single-line, bounded, and visibly printable so they render safely in every
  * surface (capability frames, UI chips, log lines). */
+/** A provider device code: short, printable, no whitespace (`AC57-MDV9G`). */
+export function isEngineLoginDeviceCode(value: unknown): value is string {
+  return (
+    typeof value === "string" &&
+    value.length >= 4 &&
+    value.length <= 32 &&
+    /^[A-Za-z0-9-]+$/.test(value)
+  );
+}
+
 export function isEngineAccountLabel(value: unknown): value is string {
   return (
     typeof value === "string" &&
@@ -826,7 +868,7 @@ export function isEngineLoginEventFrame(
   const frame = exactWireObject(
     value,
     ["kind", "opId", "engine", "phase"],
-    ["url", "errorCode", "message"],
+    ["url", "errorCode", "message", "code", "accountId"],
   );
   if (
     !frame ||
@@ -837,6 +879,22 @@ export function isEngineLoginEventFrame(
   ) {
     return false;
   }
+  // Manage-v1 extras ride exactly one phase each.
+  if (
+    Object.hasOwn(frame, "code") &&
+    (frame.phase !== "awaiting_confirmation" || !isEngineLoginDeviceCode(frame.code))
+  ) {
+    return false;
+  }
+  if (
+    Object.hasOwn(frame, "accountId") &&
+    (frame.phase !== "succeeded" ||
+      typeof frame.accountId !== "string" ||
+      frame.accountId.length < 1 ||
+      frame.accountId.length > 256)
+  ) {
+    return false;
+  }
   if (frame.phase === "authorize") {
     return (
       isHttpsUrl(frame.url) &&
@@ -1422,6 +1480,19 @@ export interface HostCommands {
     ctx: CommandContext,
     input: { id: string; scope?: string },
   ): Promise<HostCommandResult<{ removed: boolean; message?: string }>>;
+  /** Manage-v1: relabel an extra account (never `default:*`); a scope may
+   * rename only its own accounts. Re-advertises on success. */
+  engineAccountRename(
+    ctx: CommandContext,
+    input: { id: string; label: string; scope?: string },
+  ): Promise<HostCommandResult<{ renamed: boolean; message?: string }>>;
+  /** Manage-v1: set the priority order of a kind's extra accounts within a
+   * scope — `ids` must be exactly that set. Tasks pick the first healthy
+   * account in this order. Re-advertises on success. */
+  engineAccountReorder(
+    ctx: CommandContext,
+    input: { kind: string; ids: string[]; scope?: string },
+  ): Promise<HostCommandResult<{ reordered: boolean; message?: string }>>;
   cloneRepo(
     ctx: CommandContext,
     input: CloneRepoInput,