@runuai/host 0.9.113 → 0.9.115

package/lib/token-lanes/xai-oauth.ts

@@ -0,0 +1,161 @@
+/**
+ * Lane `xai-oauth` — Grok subscription sign-ins (`grok login --device-auth`).
+ *
+ * `auth.json` is keyed by `<issuer>::<client-id>`; each entry carries
+ * `key` (the bearer the CLI sends), `refresh_token`, `expires_at` (ISO),
+ * `oidc_issuer` and `oidc_client_id`. Refresh is a standard OIDC
+ * `grant_type=refresh_token` against `https://auth.x.ai/oauth2/token`
+ * (confirmed from the issuer's discovery document, 2026-09-09; refresh_token
+ * is among its supported grants).
+ *
+ * ASSUMPTION, recorded until observed on a live refresh: `key` is the OIDC
+ * access token, so a refresh replaces it with `access_token`. The lane never
+ * writes on an answer that lacks `access_token`, so a wrong assumption costs
+ * a failed refresh (retried, then the reactive path), never a corrupted
+ * sign-in.
+ */
+
+import {
+  BROKER_REFRESH_PLACEHOLDER,
+  isTerminalOAuthError,
+  parseObjectFile,
+  type CredentialFiles,
+  type CredentialHeader,
+  type LaneHttp,
+  type RefreshOutcome,
+  type TokenLane,
+} from "./types";
+
+export const XAI_ISSUER = "https://auth.x.ai";
+export const XAI_TOKEN_ENDPOINT = `${XAI_ISSUER}/oauth2/token`;
+const HOUR_MS = 60 * 60 * 1000;
+
+interface Entry {
+  key: string;
+  doc: Record<string, unknown>;
+}
+
+function entriesOf(files: CredentialFiles): { doc: Record<string, unknown>; entries: Entry[] } | null {
+  const doc = parseObjectFile(files["auth.json"]);
+  if (!doc) return null;
+  const entries: Entry[] = [];
+  for (const [key, value] of Object.entries(doc)) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      entries.push({ key, doc: value as Record<string, unknown> });
+    }
+  }
+  return { doc, entries };
+}
+
+function expiryOf(entry: Record<string, unknown>): number | null {
+  const raw = entry.expires_at;
+  if (typeof raw !== "string") return null;
+  const ms = Date.parse(raw);
+  return Number.isFinite(ms) ? ms : null;
+}
+
+export const xaiOAuthLane: TokenLane = {
+  id: "xai-oauth",
+  endpoints: [XAI_TOKEN_ENDPOINT],
+  // Observed 2026-09-09: the token lives SIX hours (create_time → expires_at).
+  // Refresh with three hours left — the hourly cycle then renews it at about
+  // four hours of age — and every four hours when expiry cannot be read.
+  schedule: { leadMs: 3 * HOUR_MS, everyMs: 4 * HOUR_MS },
+  reactiveSignals: [/invalid_grant/i, /token (?:has )?expired/i, /log ?in again/i, /unauthorized/i],
+
+  matches(header: CredentialHeader, files: CredentialFiles): boolean {
+    if (header.kind !== "grok" || header.authKind !== "config-dir") return false;
+    const parsed = entriesOf(files);
+    return (
+      parsed !== null && parsed.entries.some((e) => typeof e.doc.refresh_token === "string")
+    );
+  },
+
+  expiresAt(files: CredentialFiles): number | null {
+    const parsed = entriesOf(files);
+    if (!parsed) return null;
+    const known = parsed.entries.map((e) => expiryOf(e.doc)).filter((v): v is number => v !== null);
+    return known.length ? Math.min(...known) : null;
+  },
+
+  brokeredCopy(files: CredentialFiles): CredentialFiles {
+    const parsed = entriesOf(files);
+    if (!parsed) return files;
+    let changed = false;
+    for (const entry of parsed.entries) {
+      if (
+        typeof entry.doc.refresh_token === "string" &&
+        entry.doc.refresh_token !== BROKER_REFRESH_PLACEHOLDER
+      ) {
+        entry.doc.refresh_token = BROKER_REFRESH_PLACEHOLDER;
+        changed = true;
+      }
+    }
+    return changed ? { ...files, "auth.json": `${JSON.stringify(parsed.doc, null, 2)}\n` } : files;
+  },
+
+  async refresh(files: CredentialFiles, http: LaneHttp, now: number): Promise<RefreshOutcome> {
+    const parsed = entriesOf(files);
+    if (!parsed) return { ok: false, terminal: true, reason: "auth.json is not readable" };
+    let refreshed = 0;
+    let expiresAt: number | null = null;
+    for (const entry of parsed.entries) {
+      const current = entry.doc.refresh_token;
+      if (typeof current !== "string" || current === BROKER_REFRESH_PLACEHOLDER) continue;
+      const issuer = typeof entry.doc.oidc_issuer === "string" ? entry.doc.oidc_issuer : XAI_ISSUER;
+      if (issuer.replace(/\/$/, "") !== XAI_ISSUER) {
+        return { ok: false, terminal: true, reason: "unexpected issuer" };
+      }
+      const clientId = entry.doc.oidc_client_id;
+      if (typeof clientId !== "string" || !clientId) {
+        return { ok: false, terminal: true, reason: "entry has no client id" };
+      }
+      let res;
+      try {
+        res = await http.postForm(XAI_TOKEN_ENDPOINT, {
+          grant_type: "refresh_token",
+          refresh_token: current,
+          client_id: clientId,
+        });
+      } catch (err) {
+        return {
+          ok: false,
+          terminal: false,
+          reason: `request failed: ${err instanceof Error ? err.message : String(err)}`,
+        };
+      }
+      if (res.status < 200 || res.status >= 300) {
+        return {
+          ok: false,
+          terminal: isTerminalOAuthError(res.status, res.json),
+          reason: `HTTP ${res.status}`,
+        };
+      }
+      const body =
+        res.json && typeof res.json === "object" && !Array.isArray(res.json)
+          ? (res.json as Record<string, unknown>)
+          : null;
+      const access = body?.access_token;
+      if (typeof access !== "string" || !access) {
+        return { ok: false, terminal: false, reason: "response missing access_token" };
+      }
+      entry.doc.key = access;
+      if (typeof body?.refresh_token === "string" && body.refresh_token) {
+        entry.doc.refresh_token = body.refresh_token;
+      }
+      const expiresIn = body?.expires_in;
+      if (typeof expiresIn === "number" && Number.isFinite(expiresIn)) {
+        const at = now + expiresIn * 1000;
+        entry.doc.expires_at = new Date(at).toISOString();
+        expiresAt = expiresAt === null ? at : Math.min(expiresAt, at);
+      }
+      refreshed += 1;
+    }
+    if (refreshed === 0) return { ok: false, terminal: true, reason: "no refresh token to use" };
+    return {
+      ok: true,
+      files: { ...files, "auth.json": `${JSON.stringify(parsed.doc, null, 2)}\n` },
+      expiresAt,
+    };
+  },
+};

package/lib/user-credentials-store.ts

@@ -41,6 +41,15 @@ import {
   setMcpConnectionStoreRef,
   type StoredMcpConnection,
 } from "./mcp-connections";
+import {
+  deleteProjectEnvLocal,
+  importProjectEnvFromStore,
+  listProjectEnvStoreRows,
+  projectEnvParameterName,
+  projectEnvStoreValue,
+  setProjectEnvStoreRef,
+  type StoredProjectEnv,
+} from "./host-env";
 import {
   deleteKey as deleteSshKeyLocal,
   importSshKeyFromStore,
@@ -308,3 +317,98 @@ export async function reconcileUserCredentialsFromStore(): Promise<ReconcileUser
   }
   return result;
 }
+
+// ---------------------------------------------------------------------------
+// Slice 3: project env values, `<prefix>/projects/<projectId>/env/<KEY>`.
+// Same three moves as above, own listing.
+// ---------------------------------------------------------------------------
+
+export function parseProjectEnvParameterName(
+  name: string,
+  prefix: string = credentialStorePrefix(),
+): { projectId: string; key: string } | null {
+  if (!name.startsWith(`${prefix}/projects/`)) return null;
+  const parts = name.slice(prefix.length + 1).split("/");
+  if (parts.length !== 4 || parts[2] !== "env") return null;
+  if (!parts.every((p) => isParameterPathSegment(p))) return null;
+  const [, projectId, , key] = parts as [string, string, string, string];
+  return { projectId, key };
+}
+
+export function parseStoredProjectEnv(value: string): StoredProjectEnv {
+  const o = obj(value);
+  if (o.kind !== "project-env") throw new Error("not a project env value");
+  return {
+    v: 1,
+    kind: "project-env",
+    projectId: str(o, "projectId"),
+    key: str(o, "key"),
+    value: str(o, "value"),
+    updatedAt: num(o, "updatedAt"),
+  };
+}
+
+export async function reconcileProjectEnvFromStore(): Promise<ReconcileUserCredentialsResult> {
+  const result: ReconcileUserCredentialsResult = {
+    skipped: false,
+    imported: 0,
+    uploaded: 0,
+    removed: 0,
+    errors: 0,
+  };
+  const store = configuredCredentialStore();
+  if (!store) return { ...result, skipped: true };
+  const prefix = credentialStorePrefix();
+  const path = `${prefix}/projects`;
+  const warn = (line: string): void => console.warn(`[project-env] credential store: ${line}`);
+  let listed: Array<{ name: string; value: string }>;
+  try {
+    listed = await store.list(path);
+  } catch (err) {
+    result.errors++;
+    warn(`listing ${path} failed: ${err instanceof Error ? err.message : String(err)}`);
+    return result;
+  }
+  const local = new Map(listProjectEnvStoreRows().map((r) => [`${r.projectId}/${r.key}`, r]));
+  const seen = new Set<string>();
+  for (const param of listed) {
+    const at = parseProjectEnvParameterName(param.name, prefix);
+    if (!at) continue;
+    seen.add(param.name);
+    try {
+      const value = parseStoredProjectEnv(param.value);
+      if (value.projectId !== at.projectId || value.key !== at.key) {
+        throw new Error("payload does not describe the value its path names");
+      }
+      const row = local.get(`${at.projectId}/${at.key}`);
+      if (row) {
+        if (row.storeRef !== param.name) setProjectEnvStoreRef(at.projectId, at.key, param.name);
+      } else if (importProjectEnvFromStore(value, param.name)) {
+        result.imported++;
+      }
+    } catch (err) {
+      result.errors++;
+      warn(`${param.name}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  for (const row of local.values()) {
+    try {
+      if (row.storeRef) {
+        if (row.storeRef.startsWith(`${path}/`) && !seen.has(row.storeRef)) {
+          deleteProjectEnvLocal(row.projectId, row.key);
+          result.removed++;
+        }
+        continue;
+      }
+      const name = projectEnvParameterName(row.projectId, row.key);
+      const value = projectEnvStoreValue(row.projectId, row.key);
+      if (!name || !value) continue;
+      await upload(store, name, value, (ref) => setProjectEnvStoreRef(row.projectId, row.key, ref));
+      result.uploaded++;
+    } catch (err) {
+      result.errors++;
+      warn(`${row.projectId}/${row.key}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.9.113",
+  "version": "0.9.115",
   "description": "Uai host — runs ephemeral AI tasks in containers on a machine you control.",
   "license": "MIT",
   "author": "Uai Tech <team@runuai.com>",
@@ -76,10 +76,12 @@
     "zod": "^3.23.8"
   },
   "devDependencies": {
+    "@aws-sdk/client-ssm": "3.899.0",
     "@types/node": "^22.9.0",
     "@types/ws": "^8.18.1",
     "@typescript-eslint/eslint-plugin": "^8.59.4",
     "@typescript-eslint/parser": "^8.59.4",
+    "esbuild": "0.25.8",
     "eslint": "^9.14.0",
     "typescript": "^5.6.3",
     "vitest": "^2.1.4"

package/scripts/agent/task-up.sh

@@ -2828,6 +2828,22 @@ if crt exec -u root "${managed_exec_env[@]}" "$app_container" \
     /usr/bin/mkdir -p /home/node/.codex >/dev/null; then
   for codex_item in auth.json config.toml AGENTS.md version.json installation_id rules; do
     if [ -e "$UAI_OWNER_HOME/.codex/$codex_item" ]; then
+      # ADR-135: the task's copy must not carry the rotating refresh token —
+      # N copies racing to refresh it revoke the whole family. Replace it with
+      # the broker placeholder (the field must exist; codex refuses a missing
+      # one). The host is the only refresher and re-pushes on refresh.
+      if [ "$codex_item" = auth.json ] && command -v jq >/dev/null 2>&1; then
+        brokered_auth="$(mktemp "${TMPDIR:-/tmp}/uai-codex-auth.XXXXXX")"
+        if jq 'if (.tokens|type) == "object" and (.tokens.refresh_token|type) == "string" then .tokens.refresh_token = "uai-broker-managed-no-refresh" else . end' \
+            "$UAI_OWNER_HOME/.codex/auth.json" > "$brokered_auth" 2>/dev/null && [ -s "$brokered_auth" ]; then
+          crt cp "$brokered_auth" "$app_container":/home/node/.codex/auth.json >/dev/null \
+            || log "ERROR: crt cp of brokered .codex/auth.json failed; Codex in this task may not authenticate"
+          rm -f "$brokered_auth"
+          continue
+        fi
+        rm -f "$brokered_auth"
+        log "warning: could not broker .codex/auth.json; copying it verbatim"
+      fi
       crt cp "$UAI_OWNER_HOME/.codex/$codex_item" \
         "$app_container":/home/node/.codex/ >/dev/null \
         || log "ERROR: crt cp of .codex/$codex_item failed; Codex in this task may not authenticate"
@@ -2865,11 +2881,25 @@ crt exec -u root "${managed_exec_env[@]}" "$app_container" \
 
 # Copy Grok subscription/config into a task-private /home/node/.grok. The Linux
 # `grok` binary is baked into the image; here we copy the arch-independent
-# auth + config (auth.json is an OIDC token the CLI refreshes in-container).
+# auth + config. auth.json is an OIDC token: the task's copy gets the broker
+# placeholder in every entry's refresh_token (ADR-135) so it can never rotate
+# the family; the host is the only refresher.
 crt exec -u root "${managed_exec_env[@]}" "$app_container" \
   /usr/bin/mkdir -p /home/node/.grok >/dev/null 2>&1 || true
 for grok_item in auth.json config.toml models_cache.json agent_id; do
   if [ -e "$UAI_OWNER_HOME/.grok/$grok_item" ]; then
+    if [ "$grok_item" = auth.json ] && command -v jq >/dev/null 2>&1; then
+      brokered_auth="$(mktemp "${TMPDIR:-/tmp}/uai-grok-auth.XXXXXX")"
+      if jq 'with_entries(if (.value|type) == "object" and (.value.refresh_token|type) == "string" then .value.refresh_token = "uai-broker-managed-no-refresh" else . end)' \
+          "$UAI_OWNER_HOME/.grok/auth.json" > "$brokered_auth" 2>/dev/null && [ -s "$brokered_auth" ]; then
+        crt cp "$brokered_auth" "$app_container":/home/node/.grok/auth.json >/dev/null 2>&1 \
+          || log "warning: crt cp of brokered .grok/auth.json failed; grok may need re-login"
+        rm -f "$brokered_auth"
+        continue
+      fi
+      rm -f "$brokered_auth"
+      log "warning: could not broker .grok/auth.json; copying it verbatim"
+    fi
     crt cp "$UAI_OWNER_HOME/.grok/$grok_item" \
       "$app_container":/home/node/.grok/ >/dev/null 2>&1 \
       || log "warning: crt cp of .grok/$grok_item failed; grok may need re-login"

package/src/main.ts

@@ -57,7 +57,13 @@ import {
   deleteUserSshIdentity,
   removeTaskSshIdentityFromContainer,
 } from "../lib/git-identity";
-import { reinjectCodexRunningTasks, watchCodexAuth } from "../lib/codex-auth";
+import {
+  reinjectCodexRunningTasks,
+  reinjectGrokRunningTasks,
+  watchCodexAuth,
+} from "../lib/codex-auth";
+import { startCredentialStorePickup } from "../lib/credential-store-pickup";
+import { configureTokenBroker, startTokenBrokerLoop } from "../lib/token-broker-local";
 import {
   ensureKeyForUser as ensureSshKeyForUser,
   getPublicKey as getSshPublicKey,
@@ -157,7 +163,10 @@ import {
   listEngineAccountsAllScopes,
   reconcileEngineAccountsFromStore,
 } from "../lib/engine-accounts";
-import { reconcileUserCredentialsFromStore } from "../lib/user-credentials-store";
+import {
+  reconcileProjectEnvFromStore,
+  reconcileUserCredentialsFromStore,
+} from "../lib/user-credentials-store";
 import { createEngineConnectManager } from "../lib/engine-connect";
 import { createEngineLoginManager } from "../lib/engine-login";
 import {
@@ -459,6 +468,17 @@ void reconcileEngineAccountsFromStore({ hostId })
       `[engine-accounts] credential store reconcile failed: ${error instanceof Error ? error.message : String(error)}`,
     );
   });
+// ADR-135: one refresher per rotating credential. Owned host → the in-process
+// loop refreshes and re-pushes; Uai-operated host → the broker Lambda
+// refreshes and this host picks up changed parameter versions.
+const repushBrokeredCopies = async (kind: string): Promise<void> => {
+  if (kind === "codex") await reinjectCodexRunningTasks();
+  if (kind === "grok") await reinjectGrokRunningTasks();
+  await getOrchestrator().refreshEngineAccountCopies(kind);
+};
+configureTokenBroker({ repush: repushBrokeredCopies });
+startTokenBrokerLoop();
+startCredentialStorePickup({ repush: repushBrokeredCopies });
 void reconcileUserCredentialsFromStore()
   .then((r) => {
     if (r.skipped) return;
@@ -471,6 +491,18 @@ void reconcileUserCredentialsFromStore()
       `[user-credentials] credential store reconcile failed: ${error instanceof Error ? error.message : String(error)}`,
     );
   });
+void reconcileProjectEnvFromStore()
+  .then((r) => {
+    if (r.skipped) return;
+    console.log(
+      `[project-env] credential store reconciled: ${r.imported} imported, ${r.uploaded} uploaded, ${r.removed} removed, ${r.errors} errors`,
+    );
+  })
+  .catch((error: unknown) => {
+    console.warn(
+      `[project-env] credential store reconcile failed: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  });
 // Reconcile a durable retention-off setting before recovery/connect can make
 // crash-left owner-facing terminal history observable again. Correctness
 // tombstones remain intact inside applyTerminalHistoryRetention.