offrouter-adapter-grok 0.0.0

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "offrouter-adapter-grok",
+  "version": "0.0.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run --root ../.. packages/adapter-grok/src"
+  },
+  "dependencies": {
+    "offrouter-core": "0.0.0",
+    "smol-toml": "0.0.0",
+    "zod": "0.0.0"
+  }
+}

package/package.json.bak

@@ -0,0 +1,17 @@
+{
+  "name": "offrouter-adapter-grok",
+  "version": "0.0.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run --root ../.. packages/adapter-grok/src"
+  },
+  "dependencies": {
+    "offrouter-core": "*",
+    "smol-toml": "^1.7.0",
+    "zod": "^3.23.0"
+  },
+  "private": true
+}

package/src/index.ts

@@ -0,0 +1,36 @@
+/**
+ * offrouter-adapter-grok public surface.
+ * Install / rollback for Grok personal profiles (MCP config entry).
+ */
+
+export const ADAPTER_GROK_PACKAGE = "offrouter-adapter-grok" as const;
+
+export {
+  isGrokHarnessProfile,
+  isSafeProfileId,
+  isWorkLikeProfile,
+  listAllowlistedPersonalGrokProfiles,
+  resolveGrokProfileDir,
+  SAFE_PROFILE_ID_RE,
+} from "./profile.js";
+export type { ResolveGrokProfileDirOptions } from "./profile.js";
+
+export {
+  GROK_CONFIG_REL,
+  GROK_INSTALL_STATE_REL,
+  GrokInstallStateSchema,
+  evaluateInstallProfilePolicy,
+  formatInstallDiffText,
+  installGrokProfile,
+  patchConfigForMcp,
+} from "./install.js";
+export type {
+  GrokInstallOptions,
+  GrokInstallResult,
+  GrokInstallState,
+  InstallChangeKind,
+  InstallFileChange,
+} from "./install.js";
+
+export { rollbackGrokProfile } from "./rollback.js";
+export type { GrokRollbackOptions, GrokRollbackResult } from "./rollback.js";

package/src/install.test.ts

@@ -0,0 +1,584 @@
+import {
+  access,
+  mkdir,
+  mkdtemp,
+  readFile,
+  rm,
+  writeFile,
+} from "node:fs/promises";
+import { constants } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { parse as parseToml } from "smol-toml";
+import { loadConfig } from "offrouter-core";
+import {
+  GROK_CONFIG_REL,
+  GROK_INSTALL_STATE_REL,
+  installGrokProfile,
+  patchConfigForMcp,
+  type GrokInstallOptions,
+  type GrokInstallResult,
+} from "./install.js";
+import {
+  listAllowlistedPersonalGrokProfiles,
+  resolveGrokProfileDir,
+} from "./profile.js";
+import { rollbackGrokProfile } from "./rollback.js";
+
+const tempRoots: string[] = [];
+
+async function makeTempHome(prefix: string): Promise<string> {
+  const root = await mkdtemp(join(tmpdir(), prefix));
+  tempRoots.push(root);
+  return root;
+}
+
+async function exists(path: string): Promise<boolean> {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function writeAllowlist(
+  offrouterHome: string,
+  profiles: string[],
+): Promise<void> {
+  await mkdir(offrouterHome, { recursive: true });
+  const listed = profiles.map((p) => JSON.stringify(p)).join(", ");
+  await writeFile(
+    join(offrouterHome, "config.toml"),
+    `allowlisted_profiles = [${listed}]\n`,
+    "utf8",
+  );
+}
+
+function baseEnv(home: string): NodeJS.ProcessEnv {
+  return {
+    ...process.env,
+    HOME: home,
+    OFFROUTER_HOME: join(home, ".offrouter"),
+    OFFROUTER_GROK_PROFILES_DIR: join(home, "grok-profiles"),
+    // Never inherit real workspace trust / profile for these unit tests
+    OFFROUTER_PROFILE: undefined,
+    OFFROUTER_WORKSPACE_TRUSTED: undefined,
+  };
+}
+
+async function installOpts(
+  home: string,
+  profile: string,
+  overrides: Partial<GrokInstallOptions> = {},
+): Promise<GrokInstallOptions> {
+  const env = baseEnv(home);
+  const config = await loadConfig({
+    env,
+    homedir: () => home,
+  });
+  return {
+    profile,
+    env,
+    homedir: () => home,
+    config,
+    ...overrides,
+  };
+}
+
+function parseMcpServers(raw: string): {
+  mcp_servers: Record<string, { command: string; args: string[] }>;
+} {
+  return parseToml(raw) as {
+    mcp_servers: Record<string, { command: string; args: string[] }>;
+  };
+}
+
+afterEach(async () => {
+  while (tempRoots.length > 0) {
+    const root = tempRoots.pop();
+    if (root) {
+      await rm(root, { recursive: true, force: true });
+    }
+  }
+});
+
+describe("resolveGrokProfileDir", () => {
+  it("uses OFFROUTER_GROK_PROFILES_DIR/<profile> when set", () => {
+    const home = "/tmp/not-used-home";
+    const dir = resolveGrokProfileDir("grok-personal", {
+      env: {
+        OFFROUTER_GROK_PROFILES_DIR: "/tmp/profiles-root",
+      },
+      homedir: () => home,
+    });
+    expect(dir).toBe(join("/tmp/profiles-root", "grok-personal"));
+  });
+
+  it("maps profile id grok to ~/.grok and grok-personal to ~/.grok-personal", () => {
+    const home = "/tmp/fake-home-map";
+    expect(
+      resolveGrokProfileDir("grok", {
+        env: {},
+        homedir: () => home,
+      }),
+    ).toBe(join(home, ".grok"));
+    expect(
+      resolveGrokProfileDir("grok-personal", {
+        env: {},
+        homedir: () => home,
+      }),
+    ).toBe(join(home, ".grok-personal"));
+  });
+
+  it("maps profile id grok to GROK_HOME when set", () => {
+    const home = "/tmp/fake-home-grok";
+    expect(
+      resolveGrokProfileDir("grok", {
+        env: { GROK_HOME: "/tmp/custom-grok-home" },
+        homedir: () => home,
+      }),
+    ).toBe("/tmp/custom-grok-home");
+  });
+
+  it("rejects unsafe profile ids before resolving profile paths", () => {
+    expect(() =>
+      resolveGrokProfileDir("../grok-personal", {
+        env: {
+          OFFROUTER_GROK_PROFILES_DIR: "/tmp/profiles-root",
+        },
+        homedir: () => "/tmp/fake-home",
+      }),
+    ).toThrow(/unsafe profile id/i);
+  });
+});
+
+describe("installGrokProfile", () => {
+  it("dry-run shows exact file changes and does not write files", async () => {
+    const home = await makeTempHome("lr-grok-install-dry-");
+    await writeAllowlist(join(home, ".offrouter"), ["grok-personal"]);
+    const opts = await installOpts(home, "grok-personal", { dryRun: true });
+    const result = await installGrokProfile(opts);
+
+    expect(result.ok).toBe(true);
+    expect(result.dryRun).toBe(true);
+    expect(result.profile).toBe("grok-personal");
+    expect(result.changes.length).toBeGreaterThan(0);
+
+    const profileDir = resolveGrokProfileDir("grok-personal", opts);
+    const configPath = join(profileDir, GROK_CONFIG_REL);
+    const statePath = join(profileDir, GROK_INSTALL_STATE_REL);
+
+    expect(result.changes.some((c) => c.relativePath === GROK_CONFIG_REL)).toBe(
+      true,
+    );
+    const configChange = result.changes.find(
+      (c) => c.relativePath === GROK_CONFIG_REL,
+    );
+    expect(configChange?.kind).toBe("create");
+    expect(await exists(configPath)).toBe(false);
+    expect(await exists(statePath)).toBe(false);
+    expect(await exists(join(home, ".grok"))).toBe(false);
+  });
+
+  it("install writes only selected profile and not sibling work/default dirs", async () => {
+    const home = await makeTempHome("lr-grok-install-scope-");
+    await writeAllowlist(join(home, ".offrouter"), ["grok-personal"]);
+
+    // Pre-create sibling profile dirs with markers so we can detect writes.
+    const profilesRoot = join(home, "grok-profiles");
+    await mkdir(join(profilesRoot, "grok-work"), { recursive: true });
+    await mkdir(join(profilesRoot, "grok"), { recursive: true });
+    await writeFile(
+      join(profilesRoot, "grok-work", "marker.txt"),
+      "work-untouched",
+      "utf8",
+    );
+    await writeFile(
+      join(profilesRoot, "grok", "marker.txt"),
+      "default-untouched",
+      "utf8",
+    );
+    await mkdir(join(home, ".grok"), { recursive: true });
+    await writeFile(
+      join(home, ".grok", "marker.txt"),
+      "global-untouched",
+      "utf8",
+    );
+
+    const opts = await installOpts(home, "grok-personal");
+    const result = await installGrokProfile(opts);
+    expect(result.ok).toBe(true);
+    expect(result.dryRun).toBe(false);
+
+    const profileDir = resolveGrokProfileDir("grok-personal", opts);
+    const configPath = join(profileDir, GROK_CONFIG_REL);
+    expect(await exists(configPath)).toBe(true);
+    const configRaw = await readFile(configPath, "utf8");
+    const parsed = parseMcpServers(configRaw);
+    const entry = parsed.mcp_servers.offrouter;
+    expect(entry).toBeDefined();
+    expect(entry.command).toBe("offrouter");
+    expect(entry.args).toEqual(["mcp", "serve"]);
+
+    // Sibling profile and real home ~/.grok markers untouched
+    expect(
+      await readFile(join(profilesRoot, "grok-work", "marker.txt"), "utf8"),
+    ).toBe("work-untouched");
+    expect(
+      await readFile(join(profilesRoot, "grok", "marker.txt"), "utf8"),
+    ).toBe("default-untouched");
+    expect(await readFile(join(home, ".grok", "marker.txt"), "utf8")).toBe(
+      "global-untouched",
+    );
+    expect(await exists(join(profilesRoot, "grok-work", "config.toml"))).toBe(
+      false,
+    );
+    expect(await exists(join(home, ".grok", "config.toml"))).toBe(false);
+
+    // State lives inside target profile only
+    const statePath = join(profileDir, GROK_INSTALL_STATE_REL);
+    expect(await exists(statePath)).toBe(true);
+    const state = JSON.parse(await readFile(statePath, "utf8")) as {
+      profile: string;
+      harness: string;
+      files: Record<string, { previous: string | null }>;
+    };
+    expect(state.profile).toBe("grok-personal");
+    expect(state.harness).toBe("grok");
+    expect(state.files[GROK_CONFIG_REL]).toBeDefined();
+  });
+
+  it("refuses denied work profiles", async () => {
+    const home = await makeTempHome("lr-grok-install-work-");
+    // Even if someone allowlists a work profile, policy still denies *-work.
+    await writeAllowlist(join(home, ".offrouter"), ["grok-work"]);
+    const opts = await installOpts(home, "grok-work", { dryRun: true });
+    const result = await installGrokProfile(opts);
+    expect(result.ok).toBe(false);
+    expect(result.errorCode).toBe("work_profile_denied");
+    expect(result.message.toLowerCase()).toMatch(/work|denied/);
+    expect(
+      await exists(join(home, "grok-profiles", "grok-work", "config.toml")),
+    ).toBe(false);
+  });
+
+  it("refuses work-like profile ids such as grok-work-staging even if allowlisted", async () => {
+    const home = await makeTempHome("lr-grok-install-work-staging-");
+    // Core policy only hard-denies ids ending in -work, so grok-work-staging
+    // would otherwise pass routeRequest. The installer must still refuse it.
+    await writeAllowlist(join(home, ".offrouter"), ["grok-work-staging"]);
+    const opts = await installOpts(home, "grok-work-staging", {
+      dryRun: true,
+    });
+    const result = await installGrokProfile(opts);
+    expect(result.ok).toBe(false);
+    expect(result.errorCode).toBe("work_profile_denied");
+    expect(result.message.toLowerCase()).toContain("work");
+    expect(
+      await exists(
+        join(home, "grok-profiles", "grok-work-staging", "config.toml"),
+      ),
+    ).toBe(false);
+  });
+
+  it("refuses unallowlisted personal profiles", async () => {
+    const home = await makeTempHome("lr-grok-install-unallow-");
+    await writeAllowlist(join(home, ".offrouter"), []); // nothing allowlisted
+    const opts = await installOpts(home, "grok-personal", { dryRun: true });
+    const result = await installGrokProfile(opts);
+    expect(result.ok).toBe(false);
+    expect(result.errorCode).toBe("profile_not_allowlisted");
+    expect(result.message.toLowerCase()).toMatch(
+      /allowlist|not allowlisted|explicitly/,
+    );
+  });
+
+  it("refuses unsafe profile ids with a structured install error", async () => {
+    const home = await makeTempHome("lr-grok-install-unsafe-");
+    await writeAllowlist(join(home, ".offrouter"), ["../grok-personal"]);
+    const opts = await installOpts(home, "../grok-personal", {
+      dryRun: true,
+    });
+    const result = await installGrokProfile(opts);
+    expect(result.ok).toBe(false);
+    expect(result.errorCode).toBe("install_error");
+    expect(result.profileDir).toBe("");
+    expect(result.message.toLowerCase()).toContain("unsafe profile id");
+    expect(await exists(join(home, "skills"))).toBe(false);
+  });
+
+  it("refuses allowlisted non-Grok profiles for Grok install", async () => {
+    const home = await makeTempHome("lr-grok-install-non-grok-");
+    await writeAllowlist(join(home, ".offrouter"), ["codex-personal"]);
+    const opts = await installOpts(home, "codex-personal", { dryRun: true });
+    const result = await installGrokProfile(opts);
+    expect(result.ok).toBe(false);
+    expect(result.errorCode).toBe("install_error");
+    expect(result.message.toLowerCase()).toContain("grok install");
+    expect(
+      await exists(
+        join(home, "grok-profiles", "codex-personal", "config.toml"),
+      ),
+    ).toBe(false);
+  });
+
+  it("install --all-personal --dry-run returns a matrix of allowlisted personal Grok profiles", async () => {
+    const home = await makeTempHome("lr-grok-install-all-");
+    await writeAllowlist(join(home, ".offrouter"), [
+      "grok",
+      "grok-personal",
+      "grok-hobby",
+      "codex-personal",
+      "grok-work",
+    ]);
+    const env = baseEnv(home);
+    const config = await loadConfig({ env, homedir: () => home });
+    const profiles = listAllowlistedPersonalGrokProfiles(config);
+    expect(profiles).toEqual(
+      expect.arrayContaining(["grok-personal", "grok-hobby"]),
+    );
+    expect(profiles).not.toContain("grok");
+    expect(profiles).not.toContain("grok-work");
+    expect(profiles).not.toContain("codex-personal");
+
+    const matrix: GrokInstallResult[] = [];
+    for (const profile of profiles) {
+      matrix.push(
+        await installGrokProfile({
+          profile,
+          env,
+          homedir: () => home,
+          config,
+          dryRun: true,
+        }),
+      );
+    }
+    expect(matrix.every((r) => r.ok && r.dryRun)).toBe(true);
+    expect(matrix.map((r) => r.profile).sort()).toEqual(
+      ["grok-hobby", "grok-personal"].sort(),
+    );
+    expect(
+      matrix.every((r) =>
+        r.changes.some((c) => c.kind === "create" || c.kind === "update"),
+      ),
+    ).toBe(true);
+  });
+
+  it("rollback restores previous config.toml", async () => {
+    const home = await makeTempHome("lr-grok-install-rb-");
+    await writeAllowlist(join(home, ".offrouter"), ["grok-personal"]);
+
+    const opts = await installOpts(home, "grok-personal");
+    const profileDir = resolveGrokProfileDir("grok-personal", opts);
+    const configPath = join(profileDir, GROK_CONFIG_REL);
+    await mkdir(profileDir, { recursive: true });
+    await writeFile(configPath, 'model = "grok-code-fast-1"\n', "utf8");
+
+    const installResult = await installGrokProfile(opts);
+    expect(installResult.ok).toBe(true);
+    const afterInstall = parseToml(await readFile(configPath, "utf8")) as {
+      model?: string;
+      mcp_servers: Record<string, unknown>;
+    };
+    expect(afterInstall.mcp_servers.offrouter).toBeDefined();
+    expect(afterInstall.model).toBe("grok-code-fast-1");
+
+    // Preserve a sibling file inside .offrouter
+    const siblingStateFile = join(profileDir, ".offrouter", "notes.json");
+    await writeFile(siblingStateFile, '{"keep":true}\n', "utf8");
+
+    const rb = await rollbackGrokProfile({
+      profile: "grok-personal",
+      env: opts.env,
+      homedir: opts.homedir,
+      dryRun: false,
+    });
+    expect(rb.ok).toBe(true);
+    const restored = parseToml(await readFile(configPath, "utf8")) as {
+      model?: string;
+      mcp_servers?: Record<string, unknown>;
+    };
+    expect(restored).toEqual({ model: "grok-code-fast-1" });
+
+    const statePath = join(profileDir, GROK_INSTALL_STATE_REL);
+    expect(await exists(statePath)).toBe(false);
+    expect(await readFile(siblingStateFile, "utf8")).toBe('{"keep":true}\n');
+  });
+
+  it("refuses to reinstall when prior install state is invalid", async () => {
+    const home = await makeTempHome("lr-grok-install-corrupt-state-");
+    await writeAllowlist(join(home, ".offrouter"), ["grok-personal"]);
+    const opts = await installOpts(home, "grok-personal");
+    const profileDir = resolveGrokProfileDir("grok-personal", opts);
+    const configPath = join(profileDir, GROK_CONFIG_REL);
+
+    const first = await installGrokProfile(opts);
+    expect(first.ok).toBe(true);
+    await writeFile(configPath, "# user edit is not toml\n", "utf8");
+    await writeFile(
+      join(profileDir, GROK_INSTALL_STATE_REL),
+      "{not valid json",
+      "utf8",
+    );
+
+    const second = await installGrokProfile(opts);
+    expect(second.ok).toBe(false);
+    expect(second.message.toLowerCase()).toContain("invalid install state");
+    expect(await readFile(configPath, "utf8")).toBe(
+      "# user edit is not toml\n",
+    );
+  });
+
+  it("rollback refuses install state paths outside the profile root (path traversal)", async () => {
+    const home = await makeTempHome("lr-grok-install-rb-escape-");
+    const env = baseEnv(home);
+    const profile = "grok-personal";
+    const profileDir = resolveGrokProfileDir(profile, {
+      env,
+      homedir: () => home,
+    });
+    const outsidePath = join(home, "outside.txt");
+    const statePath = join(profileDir, GROK_INSTALL_STATE_REL);
+    await writeFile(outsidePath, "keep\n", "utf8");
+    await mkdir(join(profileDir, ".offrouter"), { recursive: true });
+    await writeFile(
+      statePath,
+      `${JSON.stringify(
+        {
+          version: 1,
+          profile,
+          harness: "grok",
+          installedAt: new Date(0).toISOString(),
+          configRelative: GROK_CONFIG_REL,
+          files: {
+            "../../outside.txt": { previous: null },
+          },
+        },
+        null,
+        2,
+      )}\n`,
+      "utf8",
+    );
+
+    const rb = await rollbackGrokProfile({
+      profile,
+      env,
+      homedir: () => home,
+    });
+    expect(rb.ok).toBe(false);
+    expect(rb.errorCode).toBe("invalid_install_state");
+    expect(await readFile(outsidePath, "utf8")).toBe("keep\n");
+    expect(await exists(statePath)).toBe(true);
+  });
+
+  it("repeated install is idempotent and preserves original rollback", async () => {
+    const home = await makeTempHome("lr-grok-install-idemp-");
+    await writeAllowlist(join(home, ".offrouter"), ["grok-personal"]);
+    const opts = await installOpts(home, "grok-personal");
+    const profileDir = resolveGrokProfileDir("grok-personal", opts);
+    const configPath = join(profileDir, GROK_CONFIG_REL);
+
+    await mkdir(profileDir, { recursive: true });
+    await writeFile(configPath, 'model = "grok-code-fast-1"\n', "utf8");
+
+    const first = await installGrokProfile(opts);
+    const second = await installGrokProfile(opts);
+    expect(first.ok).toBe(true);
+    expect(second.ok).toBe(true);
+
+    const after = parseToml(await readFile(configPath, "utf8")) as {
+      model?: string;
+      mcp_servers: Record<string, { command: string; args: string[] }>;
+    };
+    expect(after.mcp_servers.offrouter).toBeDefined();
+    // Unrelated key is preserved across the TOML round-trip.
+    expect(after.model).toBe("grok-code-fast-1");
+
+    // State still tracks original contents for true rollback
+    const state = JSON.parse(
+      await readFile(join(profileDir, GROK_INSTALL_STATE_REL), "utf8"),
+    ) as { files: Record<string, { previous: string | null }> };
+    expect(state.files[GROK_CONFIG_REL]?.previous).toContain("model");
+
+    const rb = await rollbackGrokProfile({
+      profile: "grok-personal",
+      env: opts.env,
+      homedir: opts.homedir,
+    });
+    expect(rb.ok).toBe(true);
+    expect(parseToml(await readFile(configPath, "utf8"))).toEqual({
+      model: "grok-code-fast-1",
+    });
+  });
+});
+
+describe("patchConfigForMcp", () => {
+  it("creates a fresh config from a missing file", () => {
+    const out = patchConfigForMcp(null);
+    const parsed = parseMcpServers(out);
+    expect(parsed.mcp_servers.offrouter).toBeDefined();
+    expect(parsed.mcp_servers.offrouter.command).toBe("offrouter");
+    expect(parsed.mcp_servers.offrouter.args).toEqual(["mcp", "serve"]);
+  });
+
+  it("creates a fresh config from an empty or whitespace-only file", () => {
+    for (const empty of ["", "   ", "\n\n"]) {
+      const out = patchConfigForMcp(empty);
+      const parsed = parseMcpServers(out);
+      expect(parsed.mcp_servers.offrouter).toBeDefined();
+    }
+  });
+
+  it("preserves unrelated keys when installing", () => {
+    const existing =
+      'model = "grok-code-fast-1"\n\n' +
+      "[mcp_servers.other]\n" +
+      'command = "other-tool"\n' +
+      'args = ["run"]\n';
+    const out = patchConfigForMcp(existing);
+    const parsed = parseToml(out) as {
+      model: string;
+      mcp_servers: Record<string, { command: string; args: string[] }>;
+    };
+    expect(parsed.mcp_servers.offrouter).toBeDefined();
+    expect(parsed.mcp_servers.offrouter.command).toBe("offrouter");
+    // Unrelated keys and the other MCP server survive the round-trip.
+    expect(parsed.model).toBe("grok-code-fast-1");
+    expect(parsed.mcp_servers.other).toBeDefined();
+    expect(parsed.mcp_servers.other.command).toBe("other-tool");
+  });
+
+  it("overwrites a conflicting offrouter MCP entry", () => {
+    const existing =
+      "[mcp_servers.offrouter]\n" +
+      'command = "old-tool"\n' +
+      'args = ["different"]\n';
+    const out = patchConfigForMcp(existing);
+    const parsed = parseMcpServers(out);
+    expect(parsed.mcp_servers.offrouter.command).toBe("offrouter");
+    expect(parsed.mcp_servers.offrouter.args).toEqual(["mcp", "serve"]);
+    // The old command must be gone (overwritten, not appended).
+    expect(parsed.mcp_servers.offrouter.command).not.toBe("old-tool");
+  });
+
+  it("is idempotent when already installed correctly (detected by value)", () => {
+    // Matching command/args: detected as already installed, bytes untouched.
+    const existing =
+      "[mcp_servers.offrouter]\n" +
+      'command = "offrouter"\n' +
+      'args = ["mcp", "serve"]\n';
+    expect(patchConfigForMcp(existing)).toBe(existing);
+  });
+
+  it("treats a offrouter entry with wrong args as conflicting", () => {
+    const existing =
+      "[mcp_servers.offrouter]\n" +
+      'command = "offrouter"\n' +
+      'args = ["serve"]\n';
+    const out = patchConfigForMcp(existing);
+    const parsed = parseMcpServers(out);
+    expect(parsed.mcp_servers.offrouter.args).toEqual(["mcp", "serve"]);
+  });
+});