offrouter-adapter-gemini 0.2.1 → 0.3.0

package/src/install.test.ts

@@ -1,615 +0,0 @@
-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 { loadConfig } from "offrouter-core";
-import {
-  GEMINI_CONFIG_REL,
-  GEMINI_INSTALL_STATE_REL,
-  installGeminiProfile,
-  patchConfigForMcp,
-  type GeminiInstallOptions,
-  type GeminiInstallResult,
-} from "./install.js";
-import {
-  listAllowlistedPersonalGeminiProfiles,
-  resolveGeminiProfileDir,
-} from "./profile.js";
-import { rollbackGeminiProfile } 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_GEMINI_PROFILES_DIR: join(home, "gemini-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<GeminiInstallOptions> = {},
-): Promise<GeminiInstallOptions> {
-  const env = baseEnv(home);
-  const config = await loadConfig({
-    env,
-    homedir: () => home,
-  });
-  return {
-    profile,
-    env,
-    homedir: () => home,
-    config,
-    ...overrides,
-  };
-}
-
-afterEach(async () => {
-  while (tempRoots.length > 0) {
-    const root = tempRoots.pop();
-    if (root) {
-      await rm(root, { recursive: true, force: true });
-    }
-  }
-});
-
-describe("resolveGeminiProfileDir", () => {
-  it("uses OFFROUTER_GEMINI_PROFILES_DIR/<profile> when set", () => {
-    const home = "/tmp/not-used-home";
-    const dir = resolveGeminiProfileDir("gemini-personal", {
-      env: {
-        OFFROUTER_GEMINI_PROFILES_DIR: "/tmp/profiles-root",
-      },
-      homedir: () => home,
-    });
-    expect(dir).toBe(join("/tmp/profiles-root", "gemini-personal"));
-  });
-
-  it("maps profile id gemini to ~/.gemini and gemini-personal to ~/.gemini-personal", () => {
-    const home = "/tmp/fake-home-map";
-    expect(
-      resolveGeminiProfileDir("gemini", {
-        env: {},
-        homedir: () => home,
-      }),
-    ).toBe(join(home, ".gemini"));
-    expect(
-      resolveGeminiProfileDir("gemini-personal", {
-        env: {},
-        homedir: () => home,
-      }),
-    ).toBe(join(home, ".gemini-personal"));
-  });
-
-  it("maps profile id gemini to GEMINI_HOME when set", () => {
-    const home = "/tmp/fake-home-gemini";
-    expect(
-      resolveGeminiProfileDir("gemini", {
-        env: { GEMINI_HOME: "/tmp/custom-gemini-home" },
-        homedir: () => home,
-      }),
-    ).toBe("/tmp/custom-gemini-home");
-  });
-
-  it("rejects unsafe profile ids before resolving profile paths", () => {
-    expect(() =>
-      resolveGeminiProfileDir("../gemini-personal", {
-        env: {
-          OFFROUTER_GEMINI_PROFILES_DIR: "/tmp/profiles-root",
-        },
-        homedir: () => "/tmp/fake-home",
-      }),
-    ).toThrow(/unsafe profile id/i);
-  });
-});
-
-describe("installGeminiProfile", () => {
-  it("dry-run shows exact file changes and does not write files", async () => {
-    const home = await makeTempHome("lr-gemini-install-dry-");
-    await writeAllowlist(join(home, ".offrouter"), ["gemini-personal"]);
-    const opts = await installOpts(home, "gemini-personal", { dryRun: true });
-    const result = await installGeminiProfile(opts);
-
-    expect(result.ok).toBe(true);
-    expect(result.dryRun).toBe(true);
-    expect(result.profile).toBe("gemini-personal");
-    expect(result.changes.length).toBeGreaterThan(0);
-
-    const profileDir = resolveGeminiProfileDir("gemini-personal", opts);
-    const configPath = join(profileDir, GEMINI_CONFIG_REL);
-    const statePath = join(profileDir, GEMINI_INSTALL_STATE_REL);
-
-    expect(
-      result.changes.some((c) => c.relativePath === GEMINI_CONFIG_REL),
-    ).toBe(true);
-    const configChange = result.changes.find(
-      (c) => c.relativePath === GEMINI_CONFIG_REL,
-    );
-    expect(configChange?.kind).toBe("create");
-    expect(await exists(configPath)).toBe(false);
-    expect(await exists(statePath)).toBe(false);
-    expect(await exists(join(home, ".gemini"))).toBe(false);
-  });
-
-  it("install writes only selected profile and not sibling work/default dirs", async () => {
-    const home = await makeTempHome("lr-gemini-install-scope-");
-    await writeAllowlist(join(home, ".offrouter"), ["gemini-personal"]);
-
-    // Pre-create sibling profile dirs with markers so we can detect writes.
-    const profilesRoot = join(home, "gemini-profiles");
-    await mkdir(join(profilesRoot, "gemini-work"), { recursive: true });
-    await mkdir(join(profilesRoot, "gemini"), { recursive: true });
-    await writeFile(
-      join(profilesRoot, "gemini-work", "marker.txt"),
-      "work-untouched",
-      "utf8",
-    );
-    await writeFile(
-      join(profilesRoot, "gemini", "marker.txt"),
-      "default-untouched",
-      "utf8",
-    );
-    await mkdir(join(home, ".gemini"), { recursive: true });
-    await writeFile(
-      join(home, ".gemini", "marker.txt"),
-      "global-untouched",
-      "utf8",
-    );
-
-    const opts = await installOpts(home, "gemini-personal");
-    const result = await installGeminiProfile(opts);
-    expect(result.ok).toBe(true);
-    expect(result.dryRun).toBe(false);
-
-    const profileDir = resolveGeminiProfileDir("gemini-personal", opts);
-    const configPath = join(profileDir, GEMINI_CONFIG_REL);
-    expect(await exists(configPath)).toBe(true);
-    const configRaw = await readFile(configPath, "utf8");
-    const parsed = JSON.parse(configRaw) as {
-      mcpServers: Record<string, { command: string; args: string[] }>;
-    };
-    const entry = parsed.mcpServers.offrouter;
-    expect(entry).toBeDefined();
-    expect(entry.command).toBe("offrouter");
-    expect(entry.args).toEqual(["mcp", "serve"]);
-
-    // Sibling profile and real home ~/.gemini markers untouched
-    expect(
-      await readFile(join(profilesRoot, "gemini-work", "marker.txt"), "utf8"),
-    ).toBe("work-untouched");
-    expect(
-      await readFile(join(profilesRoot, "gemini", "marker.txt"), "utf8"),
-    ).toBe("default-untouched");
-    expect(await readFile(join(home, ".gemini", "marker.txt"), "utf8")).toBe(
-      "global-untouched",
-    );
-    expect(
-      await exists(join(profilesRoot, "gemini-work", "settings.json")),
-    ).toBe(false);
-    expect(await exists(join(home, ".gemini", "settings.json"))).toBe(false);
-
-    // State lives inside target profile only
-    const statePath = join(profileDir, GEMINI_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("gemini-personal");
-    expect(state.harness).toBe("gemini");
-    expect(state.files[GEMINI_CONFIG_REL]).toBeDefined();
-  });
-
-  it("refuses denied work profiles", async () => {
-    const home = await makeTempHome("lr-gemini-install-work-");
-    // Even if someone allowlists a work profile, policy still denies *-work.
-    await writeAllowlist(join(home, ".offrouter"), ["gemini-work"]);
-    const opts = await installOpts(home, "gemini-work", { dryRun: true });
-    const result = await installGeminiProfile(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, "gemini-profiles", "gemini-work", "settings.json"),
-      ),
-    ).toBe(false);
-  });
-
-  it("refuses work-like profile ids such as gemini-work-staging even if allowlisted", async () => {
-    const home = await makeTempHome("lr-gemini-install-work-staging-");
-    // Core policy only hard-denies ids ending in -work, so gemini-work-staging
-    // would otherwise pass routeRequest. The installer must still refuse it.
-    await writeAllowlist(join(home, ".offrouter"), ["gemini-work-staging"]);
-    const opts = await installOpts(home, "gemini-work-staging", {
-      dryRun: true,
-    });
-    const result = await installGeminiProfile(opts);
-    expect(result.ok).toBe(false);
-    expect(result.errorCode).toBe("work_profile_denied");
-    expect(result.message.toLowerCase()).toContain("work");
-    expect(
-      await exists(
-        join(home, "gemini-profiles", "gemini-work-staging", "settings.json"),
-      ),
-    ).toBe(false);
-  });
-
-  it("refuses unallowlisted personal profiles", async () => {
-    const home = await makeTempHome("lr-gemini-install-unallow-");
-    await writeAllowlist(join(home, ".offrouter"), []); // nothing allowlisted
-    const opts = await installOpts(home, "gemini-personal", { dryRun: true });
-    const result = await installGeminiProfile(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-gemini-install-unsafe-");
-    await writeAllowlist(join(home, ".offrouter"), ["../gemini-personal"]);
-    const opts = await installOpts(home, "../gemini-personal", {
-      dryRun: true,
-    });
-    const result = await installGeminiProfile(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-Gemini profiles for Gemini install", async () => {
-    const home = await makeTempHome("lr-gemini-install-non-gemini-");
-    await writeAllowlist(join(home, ".offrouter"), ["codex-personal"]);
-    const opts = await installOpts(home, "codex-personal", { dryRun: true });
-    const result = await installGeminiProfile(opts);
-    expect(result.ok).toBe(false);
-    expect(result.errorCode).toBe("install_error");
-    expect(result.message.toLowerCase()).toContain("gemini install");
-    expect(
-      await exists(
-        join(home, "gemini-profiles", "codex-personal", "settings.json"),
-      ),
-    ).toBe(false);
-  });
-
-  it("install --all-personal --dry-run returns a matrix of allowlisted personal Gemini profiles", async () => {
-    const home = await makeTempHome("lr-gemini-install-all-");
-    await writeAllowlist(join(home, ".offrouter"), [
-      "gemini",
-      "gemini-personal",
-      "gemini-hobby",
-      "codex-personal",
-      "gemini-work",
-    ]);
-    const env = baseEnv(home);
-    const config = await loadConfig({ env, homedir: () => home });
-    const profiles = listAllowlistedPersonalGeminiProfiles(config);
-    expect(profiles).toEqual(
-      expect.arrayContaining(["gemini-personal", "gemini-hobby"]),
-    );
-    expect(profiles).not.toContain("gemini");
-    expect(profiles).not.toContain("gemini-work");
-    expect(profiles).not.toContain("codex-personal");
-
-    const matrix: GeminiInstallResult[] = [];
-    for (const profile of profiles) {
-      matrix.push(
-        await installGeminiProfile({
-          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(
-      ["gemini-hobby", "gemini-personal"].sort(),
-    );
-    expect(
-      matrix.every((r) =>
-        r.changes.some((c) => c.kind === "create" || c.kind === "update"),
-      ),
-    ).toBe(true);
-  });
-
-  it("rollback restores previous settings.json", async () => {
-    const home = await makeTempHome("lr-gemini-install-rb-");
-    await writeAllowlist(join(home, ".offrouter"), ["gemini-personal"]);
-
-    const opts = await installOpts(home, "gemini-personal");
-    const profileDir = resolveGeminiProfileDir("gemini-personal", opts);
-    const configPath = join(profileDir, GEMINI_CONFIG_REL);
-    await mkdir(profileDir, { recursive: true });
-    await writeFile(
-      configPath,
-      `${JSON.stringify({ theme: "dark" }, null, 2)}\n`,
-      "utf8",
-    );
-
-    const installResult = await installGeminiProfile(opts);
-    expect(installResult.ok).toBe(true);
-    const afterInstall = JSON.parse(await readFile(configPath, "utf8")) as {
-      theme?: string;
-      mcpServers: Record<string, unknown>;
-    };
-    expect(afterInstall.mcpServers.offrouter).toBeDefined();
-    expect(afterInstall.theme).toBe("dark");
-
-    // Preserve a sibling file inside .offrouter
-    const siblingStateFile = join(profileDir, ".offrouter", "notes.json");
-    await writeFile(siblingStateFile, '{"keep":true}\n', "utf8");
-
-    const rb = await rollbackGeminiProfile({
-      profile: "gemini-personal",
-      env: opts.env,
-      homedir: opts.homedir,
-      dryRun: false,
-    });
-    expect(rb.ok).toBe(true);
-    const restored = JSON.parse(await readFile(configPath, "utf8"));
-    expect(restored).toEqual({ theme: "dark" });
-
-    const statePath = join(profileDir, GEMINI_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-gemini-install-corrupt-state-");
-    await writeAllowlist(join(home, ".offrouter"), ["gemini-personal"]);
-    const opts = await installOpts(home, "gemini-personal");
-    const profileDir = resolveGeminiProfileDir("gemini-personal", opts);
-    const configPath = join(profileDir, GEMINI_CONFIG_REL);
-
-    const first = await installGeminiProfile(opts);
-    expect(first.ok).toBe(true);
-    await writeFile(configPath, "// user edit is not json\n", "utf8");
-    await writeFile(
-      join(profileDir, GEMINI_INSTALL_STATE_REL),
-      "{not valid json",
-      "utf8",
-    );
-
-    const second = await installGeminiProfile(opts);
-    expect(second.ok).toBe(false);
-    expect(second.message.toLowerCase()).toContain("invalid install state");
-    expect(await readFile(configPath, "utf8")).toBe(
-      "// user edit is not json\n",
-    );
-  });
-
-  it("rollback refuses install state paths outside the profile root (path traversal)", async () => {
-    const home = await makeTempHome("lr-gemini-install-rb-escape-");
-    const env = baseEnv(home);
-    const profile = "gemini-personal";
-    const profileDir = resolveGeminiProfileDir(profile, {
-      env,
-      homedir: () => home,
-    });
-    const outsidePath = join(home, "outside.txt");
-    const statePath = join(profileDir, GEMINI_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: "gemini",
-          installedAt: new Date(0).toISOString(),
-          configRelative: GEMINI_CONFIG_REL,
-          files: {
-            "../../outside.txt": { previous: null },
-          },
-        },
-        null,
-        2,
-      )}\n`,
-      "utf8",
-    );
-
-    const rb = await rollbackGeminiProfile({
-      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-gemini-install-idemp-");
-    await writeAllowlist(join(home, ".offrouter"), ["gemini-personal"]);
-    const opts = await installOpts(home, "gemini-personal");
-    const profileDir = resolveGeminiProfileDir("gemini-personal", opts);
-    const configPath = join(profileDir, GEMINI_CONFIG_REL);
-
-    await mkdir(profileDir, { recursive: true });
-    await writeFile(
-      configPath,
-      `${JSON.stringify({ model: "gemini-2.5-pro" }, null, 2)}\n`,
-      "utf8",
-    );
-
-    const first = await installGeminiProfile(opts);
-    const second = await installGeminiProfile(opts);
-    expect(first.ok).toBe(true);
-    expect(second.ok).toBe(true);
-
-    const after = JSON.parse(await readFile(configPath, "utf8")) as {
-      model?: string;
-      mcpServers: Record<string, { command: string; args: string[] }>;
-    };
-    expect(after.mcpServers.offrouter).toBeDefined();
-    // Unrelated key is preserved across the JSON round-trip.
-    expect(after.model).toBe("gemini-2.5-pro");
-
-    // State still tracks original contents for true rollback
-    const state = JSON.parse(
-      await readFile(join(profileDir, GEMINI_INSTALL_STATE_REL), "utf8"),
-    ) as { files: Record<string, { previous: string | null }> };
-    expect(state.files[GEMINI_CONFIG_REL]?.previous).toContain("model");
-
-    const rb = await rollbackGeminiProfile({
-      profile: "gemini-personal",
-      env: opts.env,
-      homedir: opts.homedir,
-    });
-    expect(rb.ok).toBe(true);
-    expect(JSON.parse(await readFile(configPath, "utf8"))).toEqual({
-      model: "gemini-2.5-pro",
-    });
-  });
-});
-
-describe("patchConfigForMcp", () => {
-  it("creates a fresh config from a missing file", () => {
-    const out = patchConfigForMcp(null);
-    const parsed = JSON.parse(out) as {
-      mcpServers: Record<string, { command: string; args: string[] }>;
-    };
-    expect(parsed.mcpServers.offrouter).toBeDefined();
-    expect(parsed.mcpServers.offrouter.command).toBe("offrouter");
-    expect(parsed.mcpServers.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 = JSON.parse(out) as {
-        mcpServers: Record<string, unknown>;
-      };
-      expect(parsed.mcpServers.offrouter).toBeDefined();
-    }
-  });
-
-  it("preserves unrelated keys when installing", () => {
-    const existing = JSON.stringify(
-      {
-        theme: "dark",
-        model: "gemini-2.5-pro",
-        mcpServers: {
-          other: { command: "other-tool", args: ["run"] },
-        },
-      },
-      null,
-      2,
-    );
-    const out = patchConfigForMcp(existing);
-    const parsed = JSON.parse(out) as {
-      theme: string;
-      model: string;
-      mcpServers: Record<string, { command: string; args: string[] }>;
-    };
-    expect(parsed.mcpServers.offrouter).toBeDefined();
-    expect(parsed.mcpServers.offrouter.command).toBe("offrouter");
-    // Unrelated keys and the other MCP server survive the round-trip.
-    expect(parsed.theme).toBe("dark");
-    expect(parsed.model).toBe("gemini-2.5-pro");
-    expect(parsed.mcpServers.other).toBeDefined();
-    expect(parsed.mcpServers.other.command).toBe("other-tool");
-  });
-
-  it("overwrites a conflicting offrouter MCP entry", () => {
-    const existing = JSON.stringify(
-      {
-        mcpServers: {
-          offrouter: { command: "old-tool", args: ["different"] },
-        },
-      },
-      null,
-      2,
-    );
-    const out = patchConfigForMcp(existing);
-    const parsed = JSON.parse(out) as {
-      mcpServers: Record<string, { command: string; args: string[] }>;
-    };
-    expect(parsed.mcpServers.offrouter.command).toBe("offrouter");
-    expect(parsed.mcpServers.offrouter.args).toEqual(["mcp", "serve"]);
-    // The old command must be gone (overwritten, not appended).
-    expect(parsed.mcpServers.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 = JSON.stringify(
-      {
-        mcpServers: {
-          offrouter: { command: "offrouter", args: ["mcp", "serve"] },
-        },
-      },
-      null,
-      2,
-    );
-    expect(patchConfigForMcp(existing)).toBe(existing);
-  });
-
-  it("treats a offrouter entry with wrong args as conflicting", () => {
-    const existing = JSON.stringify(
-      {
-        mcpServers: {
-          offrouter: { command: "offrouter", args: ["serve"] },
-        },
-      },
-      null,
-      2,
-    );
-    const out = patchConfigForMcp(existing);
-    const parsed = JSON.parse(out) as {
-      mcpServers: Record<string, { command: string; args: string[] }>;
-    };
-    expect(parsed.mcpServers.offrouter.args).toEqual(["mcp", "serve"]);
-  });
-});