@runuai/host 0.9.107 → 0.9.109

package/lib/browser-testing.ts

@@ -236,9 +236,32 @@ const SERVER_COMMAND = "sh";
 /** Exported for the test that locks the pin/browser invariants. */
 export const SERVER_ARGS: [string, string] = ["-lc", SERVER_LAUNCHER];
 
-/** The `browser` server definition both engines get. */
+/** The `browser` server definition every engine gets. */
 const SERVER_DEF = { command: SERVER_COMMAND, args: SERVER_ARGS };
 
+/** Cursor reads stdio servers from ~/.cursor/mcp.json (the adapter passes
+ * `--approve-mcps`); same JSON shape as Claude's project file. */
+const CURSOR_MCP_PATH = "/home/node/.cursor/mcp.json";
+
+/** Grok: `grok mcp add` (add-or-update) in USER scope, once per GROK_HOME a
+ * task may run under (the default ~/.grok and each ~/.grok-acct-<id>) —
+ * `GROK_HOME` redirects the user config. PROJECT scope looked simpler but
+ * grok refuses repo-local servers in an untrusted folder, and /workspace is
+ * not a git repo so nothing ever trusts it (live 2026-09-08: "folder
+ * untrusted … re-run with --trust", no such flag headless). The launcher has
+ * no single quotes by construction (see SERVER_LAUNCHER). */
+const GROK_BIN = "/home/node/.grok/bin/grok";
+export const DEFAULT_GROK_HOME = "/home/node/.grok";
+export function grokBrowserAddCommand(home: string): string {
+  if (!/^\/home\/node\/\.grok(-acct-[A-Za-z0-9_-]+)?$/.test(home)) {
+    throw new Error("invalid Grok home");
+  }
+  return (
+    `GROK_HOME=${home} ${GROK_BIN} mcp add browser -s user -t stdio ` +
+    `${SERVER_COMMAND} -- ${SERVER_ARGS.map((arg) => `'${arg}'`).join(" ")}`
+  );
+}
+
 const CLAUDE_SETTINGS_JSON = JSON.stringify(
   { enableAllProjectMcpServers: true },
   null,
@@ -562,6 +585,45 @@ function ensureClaudeBrowser() {
   return { configured: true, changed: true };
 }
 
+function ensureCursorBrowser() {
+  const file = process.env.UAI_CURSOR_MCP_PATH;
+  if (!file) return { configured: true, changed: false };
+  const exists = fs.existsSync(file);
+  let original = null;
+  let document;
+  try {
+    original = exists ? fs.readFileSync(file, "utf8") : null;
+    document = exists ? JSON.parse(original) : { mcpServers: {} };
+  } catch {
+    notes.push("cursor mcp.json is unparseable - left alone");
+    return { configured: false, changed: false };
+  }
+  if (!plainObject(document)) {
+    notes.push("cursor mcp.json root is not an object - left alone");
+    return { configured: false, changed: false };
+  }
+  if (document.mcpServers === undefined) document.mcpServers = {};
+  if (!plainObject(document.mcpServers)) {
+    notes.push("cursor mcp.json mcpServers is not an object - left alone");
+    return { configured: false, changed: false };
+  }
+  const current = document.mcpServers.browser;
+  if (current !== undefined && equal(current, def)) {
+    return { configured: true, changed: false };
+  }
+  if (current !== undefined && !isManaged(current)) {
+    notes.push("cursor mcp.json browser entry is not uai-managed - left alone");
+    return { configured: true, changed: false };
+  }
+  document.mcpServers.browser = def;
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  if (!atomicWrite(file, JSON.stringify(document, null, 2) + "\n", original)) {
+    notes.push("cursor mcp.json changed concurrently - retrying later");
+    return { configured: false, changed: false };
+  }
+  return { configured: true, changed: true };
+}
+
 function ensureClaudeSettings() {
   const file = process.env.UAI_CLAUDE_SETTINGS_PATH;
   if (!file || fs.existsSync(file)) return { configured: true, changed: false };
@@ -913,6 +975,9 @@ function safeOutcome(label, ensure) {
 for (const outcome of [
   safeOutcome("Claude browser config", ensureClaudeBrowser),
   safeOutcome("Claude settings", ensureClaudeSettings),
+  ...(process.env.UAI_CURSOR_MCP_PATH
+    ? [safeOutcome("Cursor browser config", ensureCursorBrowser)]
+    : []),
   ...codexHomes.map(function (home) {
     return safeOutcome(home, function () { return ensureCodexBrowser(home); });
   }),
@@ -1022,7 +1087,18 @@ export async function setupBrowserTesting(
   codexHomes: readonly string[] = hasCodex ? [DEFAULT_CODEX_HOME] : [],
   environment?: Pick<TaskEnvironmentHandle, "exec" | "launchDetachedSession"> &
     Partial<Pick<TaskEnvironmentHandle, "descriptor">>,
+  /** The roster's agent kinds: cursor and grok get the browser server too
+   * (2026-09-08 — until then only Claude/Codex were wired and both answered
+   * "no browser MCP in this session" on the Studio). */
+  engineKinds: readonly string[] = [],
+  /** Every GROK_HOME the task may run under (default + account homes). */
+  grokHomes: readonly string[] = [DEFAULT_GROK_HOME],
 ): Promise<BrowserSetup> {
+  const hasCursor = engineKinds.includes("cursor");
+  const hasGrok = engineKinds.includes("grok");
+  const selectedGrokHomes = hasGrok
+    ? [...new Set(grokHomes.length > 0 ? grokHomes : [DEFAULT_GROK_HOME])]
+    : [];
   // Machine sessions run under MACHINE_RUNTIME_AUTHORITY_ENV, so every setup
   // exec here must too — the prewarm in particular. Warming npx under the
   // CONTAINER authority (private NPM_CONFIG_CACHE) leaves the session-default
@@ -1201,6 +1277,7 @@ export async function setupBrowserTesting(
       ...(selectedCodexHomes.length > 0
         ? { UAI_CODEX_HOMES: JSON.stringify(selectedCodexHomes) }
         : {}),
+      ...(hasCursor ? { UAI_CURSOR_MCP_PATH: CURSOR_MCP_PATH } : {}),
     };
     const writeArgv = [
       "flock",
@@ -1238,6 +1315,7 @@ export async function setupBrowserTesting(
             ...(selectedCodexHomes.length > 0
               ? ["-e", `UAI_CODEX_HOMES=${JSON.stringify(selectedCodexHomes)}`]
               : []),
+            ...(hasCursor ? ["-e", `UAI_CURSOR_MCP_PATH=${CURSOR_MCP_PATH}`] : []),
             ...runtimeAuthorityDockerExecArgs(),
             container,
             ...writeArgv,
@@ -1292,6 +1370,44 @@ export async function setupBrowserTesting(
       }
     }
 
+    // Grok registers its servers through its own CLI (project scope, see
+    // GROK_BROWSER_ADD_CMD) rather than a file we own; a failure here leaves
+    // the task configured-false so the next ensure retries.
+    if (hasGrok) {
+      const grokArgv = [
+        "sh",
+        "-lc",
+        selectedGrokHomes.map(grokBrowserAddCommand).join(" && "),
+      ] as [string, ...string[]];
+      const registered = environment
+        ? await environment.exec({
+            argv: grokArgv,
+            cwd: "/workspace",
+            env: authorityEnv,
+            timeoutMs: 30_000,
+            maxOutputBytes: 64 * 1024,
+          })
+        : await taskContainerCli(
+            [
+              "exec",
+              "-w",
+              "/workspace",
+              ...runtimeAuthorityDockerExecArgs(),
+              container,
+              ...grokArgv,
+            ],
+            { timeoutMs: 30_000 },
+          );
+      const grokStatus =
+        "exitCode" in registered ? registered.exitCode : registered.status;
+      if (grokStatus !== 0) {
+        configured = false;
+        console.warn(
+          `[browser] task ${taskId}: grok browser MCP registration failed (exit ${String(grokStatus)})`,
+        );
+      }
+    }
+
     // Chromium apt libs + the viewer stack packages, then start the stack.
     // The lock is a container-local flock acquired BEFORE detach. The worker
     // inherits its open file description, so failures and even SIGKILL release

package/lib/mcp-gateway.ts

@@ -1042,6 +1042,8 @@ function shellQuote(value: string): string {
 // client does not kill its in-container child. The full writer (including its
 // 10s lock wait and every engine-specific command) gets 25s before TERM and
 // 5s more before KILL, below the 40s host backstop.
+/** The grok CLI inside task containers/machines (x.ai installer path). */
+const GROK_BIN = "/home/node/.grok/bin/grok";
 const MCP_CONFIG_WRITE_TIMEOUT_S = 25;
 const MCP_CONFIG_WRITE_KILL_AFTER_S = 5;
 const MCP_CONFIG_HOST_TIMEOUT_MS = 40_000;
@@ -1054,7 +1056,8 @@ const MCP_CONFIG_HOST_TIMEOUT_MS = 40_000;
  *   - Codex — mcp-remote shims appended once per slug to config.toml.
  *   - Cursor — ~/.cursor/mcp.json ({ url } form; the adapter passes
  *     `--approve-mcps`).
- *   - Grok — `grok mcp add` writes ~/.grok/config.toml (idempotent per slug).
+ *   - Grok — `grok mcp add -s user` into every GROK_HOME the task may use
+ *     (idempotent per slug; project scope is refused in an untrusted folder).
  *   - OpenCode — ~/.config/opencode/opencode.json `mcp` block (type:"remote",
  *     oauth:false so it treats the gateway URL as a plain server; the path
  *     token is the auth). Written only when the task has connections.
@@ -1068,6 +1071,8 @@ export async function setupMcpTaskConfig(
   codexHomes: readonly string[] = ["/home/node/.codex"],
   environment?: Pick<TaskEnvironmentHandle, "exec"> &
     Partial<Pick<TaskEnvironmentHandle, "descriptor">>,
+  /** Every GROK_HOME the task may run under (default + account homes). */
+  grokHomes: readonly string[] = ["/home/node/.grok"],
 ): Promise<boolean> {
   // No early return on empty: the claude adapter passes
   // `--mcp-config /workspace/.mcp.json` unconditionally (ADR-057), so the
@@ -1150,14 +1155,22 @@ export async function setupMcpTaskConfig(
             )}`,
           ]
         : []),
-      // Grok: `grok mcp add` writes ~/.grok/config.toml. Idempotent + tolerant.
+      // Grok: USER-scope `grok mcp add` once per GROK_HOME the task may run
+      // under (GROK_HOME redirects the user config). Project scope is refused
+      // for an untrusted folder and /workspace is no git repo (live
+      // 2026-09-08). The binary lives at ~/.grok/bin (x.ai installer); the
+      // old ~/.local/bin path failed silently behind `|| true`.
       ...(has("grok")
-        ? connections.map(
-            (c) =>
-              `/home/node/.local/bin/grok mcp add ${shellQuote(c.slug)} ${shellQuote(
-                urlFor(c.slug),
-              )} -t http -s user >/dev/null 2>&1 || true`,
-          )
+        ? grokHomes
+            .filter((home) => /^\/home\/node\/\.grok(-acct-[A-Za-z0-9_-]+)?$/.test(home))
+            .flatMap((home) =>
+              connections.map(
+                (c) =>
+                  `GROK_HOME=${home} ${GROK_BIN} mcp add ${shellQuote(c.slug)} ${shellQuote(
+                    urlFor(c.slug),
+                  )} -t http -s user >/dev/null 2>&1 || true`,
+              ),
+            )
         : []),
       // OpenCode: global config `mcp` block (auto-discovered regardless of the
       // exec cwd, and independent of any per-account OPENCODE_DATA_DIR).

package/lib/orchestrator.ts

@@ -101,6 +101,7 @@ import {
 } from "./agent-cli";
 import {
   DEFAULT_CODEX_HOME,
+  DEFAULT_GROK_HOME,
   setupBrowserTesting,
   type BrowserSetup,
 } from "./browser-testing";
@@ -814,6 +815,16 @@ export class Orchestrator {
     return [...new Set([DEFAULT_CODEX_HOME, ...homes])];
   }
 
+  /** Every GROK_HOME a task in `scope` may run under: the default plus each
+   *  sign-in account's isolated home (API-key accounts use the default). */
+  private grokHomes(hasGrok: boolean, scope: string): string[] {
+    if (!hasGrok) return [];
+    const homes = resolveEngineAccounts("grok", {}, scope)
+      .map((account) => account.configDir?.containerDir)
+      .filter((home): home is string => Boolean(home));
+    return [...new Set([DEFAULT_GROK_HOME, ...homes])];
+  }
+
   private noteProvisionMutation(
     channel: Channel,
     waitForBrowserReadiness: boolean,
@@ -1025,12 +1036,17 @@ export class Orchestrator {
               requestedHasCodex,
               requestedHomes,
               channel.agentHandle,
+              requestedKinds,
+              this.grokHomes(requestedKinds.includes("grok"), channel.engineAccountScope),
             )
           : await setupBrowserTesting(
               channel.taskId,
               channel.containerName,
               requestedHasCodex,
               requestedHomes,
+              undefined,
+              requestedKinds,
+              this.grokHomes(requestedKinds.includes("grok"), channel.engineAccountScope),
             );
       } catch (err) {
         console.warn(
@@ -1187,10 +1203,15 @@ export class Orchestrator {
     const codexHomes = engineKinds.includes("codex")
       ? this.codexHomes(true, channel.engineAccountScope)
       : [];
+    const grokHomes = this.grokHomes(
+      engineKinds.includes("grok"),
+      channel.engineAccountScope,
+    );
     const fingerprint = JSON.stringify({
       connections,
       engineKinds,
       codexHomes,
+      ...(grokHomes.length > 0 ? { grokHomes } : {}),
     });
     const dirtyEpoch = channel.mcpConfigDirtyEpoch;
     const repairingProvisionedConfig =
@@ -1237,6 +1258,7 @@ export class Orchestrator {
           engineKinds,
           codexHomes,
           providerEnvironment,
+          grokHomes,
         )
       : await setupMcpTaskConfig(
           channel.taskId,
@@ -1244,6 +1266,8 @@ export class Orchestrator {
           connections,
           engineKinds,
           codexHomes,
+          undefined,
+          grokHomes,
         );
     if (!configured || !this.isActiveChannel(channel)) return;
     channel.configGeneration += 1;

package/package.json

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