@runuai/host 0.9.106 → 0.9.108

package/lib/browser-testing.ts

@@ -236,9 +236,22 @@ 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 PROJECT scope writes
+ * /workspace/.grok/config.toml, honoured by every GROK_HOME and hot-reloaded,
+ * so per-account homes need no per-home write. The launcher has no single
+ * quotes by construction (see SERVER_LAUNCHER), so it survives the quoting. */
+const GROK_BIN = "/home/node/.grok/bin/grok";
+export const GROK_BROWSER_ADD_CMD =
+  `cd /workspace && ${GROK_BIN} mcp add browser -s project -t stdio ` +
+  `${SERVER_COMMAND} -- ${SERVER_ARGS.map((arg) => `'${arg}'`).join(" ")}`;
+
 const CLAUDE_SETTINGS_JSON = JSON.stringify(
   { enableAllProjectMcpServers: true },
   null,
@@ -562,6 +575,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 +965,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 +1077,13 @@ 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[] = [],
 ): Promise<BrowserSetup> {
+  const hasCursor = engineKinds.includes("cursor");
+  const hasGrok = engineKinds.includes("grok");
   // 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 +1262,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 +1300,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 +1355,40 @@ 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", GROK_BROWSER_ADD_CMD] 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 project` writes /workspace/.grok/config.toml
+ *     (idempotent per slug; applies to every GROK_HOME).
  *   - 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.
@@ -1150,13 +1153,17 @@ export async function setupMcpTaskConfig(
             )}`,
           ]
         : []),
-      // Grok: `grok mcp add` writes ~/.grok/config.toml. Idempotent + tolerant.
+      // Grok: PROJECT-scope `grok mcp add` writes /workspace/.grok/config.toml,
+      // which every GROK_HOME (the default or a per-account dir) picks up —
+      // grok hot-reloads repo config. The binary lives at ~/.grok/bin (x.ai
+      // installer); the old ~/.local/bin path failed silently behind `|| true`
+      // and grok never saw a single MCP server (live 2026-09-08).
       ...(has("grok")
         ? connections.map(
             (c) =>
-              `/home/node/.local/bin/grok mcp add ${shellQuote(c.slug)} ${shellQuote(
+              `(cd /workspace && ${GROK_BIN} mcp add ${shellQuote(c.slug)} ${shellQuote(
                 urlFor(c.slug),
-              )} -t http -s user >/dev/null 2>&1 || true`,
+              )} -t http -s project >/dev/null 2>&1) || true`,
           )
         : []),
       // OpenCode: global config `mcp` block (auto-discovered regardless of the

package/lib/orchestrator.ts

@@ -1025,12 +1025,15 @@ export class Orchestrator {
               requestedHasCodex,
               requestedHomes,
               channel.agentHandle,
+              requestedKinds,
             )
           : await setupBrowserTesting(
               channel.taskId,
               channel.containerName,
               requestedHasCodex,
               requestedHomes,
+              undefined,
+              requestedKinds,
             );
       } catch (err) {
         console.warn(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.9.106",
+  "version": "0.9.108",
   "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

@@ -123,6 +123,7 @@ import {
   renameEngineAccount,
   reorderEngineAccounts,
 } from "../lib/engine-accounts";
+import { disconnectEngine } from "../lib/engines";
 
 export {
   parseMentions,
@@ -1271,6 +1272,16 @@ export const hostCommands: HostCommands = {
     }
   },
 
+  async engineDisconnect(ctx, input) {
+    logCommand(ctx, "engineDisconnect", input.engine);
+    try {
+      disconnectEngine(input.engine);
+      return ok({ disconnected: true });
+    } catch (err) {
+      return failFromUnknown(err);
+    }
+  },
+
   async channelResolvePermission(ctx, taskId, agentId, requestId, decision) {
     logCommand(ctx, "channelResolvePermission", taskId, agentId, requestId);
     try {

package/src/main.ts

@@ -188,6 +188,7 @@ import {
   HOST_ENGINE_CONNECT_PROTOCOL_FEATURE,
   HOST_ENGINE_ACCOUNT_MANAGE_PROTOCOL_FEATURE,
   HOST_ENGINE_ACCOUNT_SCOPES_PROTOCOL_FEATURE,
+  HOST_ENGINE_DISCONNECT_PROTOCOL_FEATURE,
   HOST_ENGINE_LOGIN_PROTOCOL_FEATURE,
   isEngineAccountScope,
   HOST_LOGS_PROTOCOL_FEATURE,
@@ -232,6 +233,7 @@ import {
   type FilesOpInput,
   engineAccountScopeFromWire,
   isEngineAccountLabel,
+  isEngineConnectKind,
 } from "./protocol";
 
 setContainerRuntimeOperationalCheck(() => containerRuntimeProblem() === null);
@@ -615,6 +617,7 @@ function buildCapabilities(): HostCapabilities {
       HOST_ENGINE_CONNECT_PROTOCOL_FEATURE,
       HOST_ENGINE_ACCOUNT_SCOPES_PROTOCOL_FEATURE,
       HOST_ENGINE_ACCOUNT_MANAGE_PROTOCOL_FEATURE,
+      HOST_ENGINE_DISCONNECT_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.
@@ -2465,6 +2468,16 @@ async function dispatchCommand(
       if (reordered.ok) sendCapabilities();
       return reordered;
     }
+    case "engineDisconnect": {
+      const value = args[0];
+      const engine = (value as { engine?: unknown } | undefined)?.engine;
+      if (!isEngineConnectKind(engine)) {
+        throw new Error("invalid command args: expected an engine kind at 0");
+      }
+      const result = await hostCommands.engineDisconnect(ctx, { engine });
+      if (result.ok) sendCapabilities();
+      return result;
+    }
   }
 }
 
@@ -3050,6 +3063,7 @@ const HOST_COMMAND_NAMES = {
   engineAccountRemove: true,
   engineAccountRename: true,
   engineAccountReorder: true,
+  engineDisconnect: true,
 } satisfies Record<keyof HostCommands, true>;
 
 function isHostCommand(command: string): command is keyof HostCommands {

package/src/protocol.ts

@@ -113,6 +113,9 @@ export const HOST_ENGINE_CONNECT_PROTOCOL_FEATURE = "host-engine-connect-v1";
  * `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). */
+/** Host 0.9.107: `engineDisconnect` — forget the HOST's own credential for an
+ * engine (the default slot: .env.local key / login file). Owner-only. */
+export const HOST_ENGINE_DISCONNECT_PROTOCOL_FEATURE = "host-engine-disconnect-v1";
 export const HOST_ENGINE_ACCOUNT_MANAGE_PROTOCOL_FEATURE =
   "host-engine-account-manage-v1";
 export const HOST_ENGINE_ACCOUNT_SCOPES_PROTOCOL_FEATURE =
@@ -1493,6 +1496,13 @@ export interface HostCommands {
     ctx: CommandContext,
     input: { kind: string; ids: string[]; scope?: string },
   ): Promise<HostCommandResult<{ reordered: boolean; message?: string }>>;
+  /** Disconnect-v1: forget the host's DEFAULT credential for an engine — the
+   * .env.local key and/or the login file the adapter detects. Extras are
+   * untouched (remove them by id). Re-advertises on success. */
+  engineDisconnect(
+    ctx: CommandContext,
+    input: { engine: EngineConnectKind },
+  ): Promise<HostCommandResult<{ disconnected: boolean; message?: string }>>;
   cloneRepo(
     ctx: CommandContext,
     input: CloneRepoInput,