offrouter-adapter-codex 0.2.1 → 0.3.0

package/src/install.test.ts

@@ -1,551 +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 {
-  CODEX_CONFIG_REL,
-  CODEX_INSTALL_STATE_REL,
-  installCodexProfile,
-  patchConfigForMcp,
-  type CodexInstallOptions,
-  type CodexInstallResult,
-} from "./install.js";
-import {
-  listAllowlistedPersonalCodexProfiles,
-  resolveCodexProfileDir,
-} from "./profile.js";
-import { rollbackCodexProfile } 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_CODEX_PROFILES_DIR: join(home, "codex-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<CodexInstallOptions> = {},
-): Promise<CodexInstallOptions> {
-  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("resolveCodexProfileDir", () => {
-  it("uses OFFROUTER_CODEX_PROFILES_DIR/<profile> when set", () => {
-    const home = "/tmp/not-used-home";
-    const dir = resolveCodexProfileDir("codex-personal", {
-      env: {
-        OFFROUTER_CODEX_PROFILES_DIR: "/tmp/profiles-root",
-      },
-      homedir: () => home,
-    });
-    expect(dir).toBe(join("/tmp/profiles-root", "codex-personal"));
-  });
-
-  it("maps profile id codex to ~/.codex and codex-personal to ~/.codex-personal", () => {
-    const home = "/tmp/fake-home-map";
-    expect(
-      resolveCodexProfileDir("codex", {
-        env: {},
-        homedir: () => home,
-      }),
-    ).toBe(join(home, ".codex"));
-    expect(
-      resolveCodexProfileDir("codex-personal", {
-        env: {},
-        homedir: () => home,
-      }),
-    ).toBe(join(home, ".codex-personal"));
-  });
-
-  it("maps profile id codex to CODEX_HOME when set", () => {
-    const home = "/tmp/fake-home-codex";
-    expect(
-      resolveCodexProfileDir("codex", {
-        env: { CODEX_HOME: "/tmp/custom-codex-home" },
-        homedir: () => home,
-      }),
-    ).toBe("/tmp/custom-codex-home");
-  });
-
-  it("rejects unsafe profile ids before resolving profile paths", () => {
-    expect(() =>
-      resolveCodexProfileDir("../codex-personal", {
-        env: {
-          OFFROUTER_CODEX_PROFILES_DIR: "/tmp/profiles-root",
-        },
-        homedir: () => "/tmp/fake-home",
-      }),
-    ).toThrow(/unsafe profile id/i);
-  });
-});
-
-describe("installCodexProfile", () => {
-  it("dry-run shows exact file changes and does not write files", async () => {
-    const home = await makeTempHome("lr-codex-install-dry-");
-    await writeAllowlist(join(home, ".offrouter"), ["codex-personal"]);
-    const opts = await installOpts(home, "codex-personal", { dryRun: true });
-    const result = await installCodexProfile(opts);
-
-    expect(result.ok).toBe(true);
-    expect(result.dryRun).toBe(true);
-    expect(result.profile).toBe("codex-personal");
-    expect(result.changes.length).toBeGreaterThan(0);
-
-    const profileDir = resolveCodexProfileDir("codex-personal", opts);
-    const configPath = join(profileDir, CODEX_CONFIG_REL);
-    const statePath = join(profileDir, CODEX_INSTALL_STATE_REL);
-
-    expect(
-      result.changes.some((c) => c.relativePath === CODEX_CONFIG_REL),
-    ).toBe(true);
-    const configChange = result.changes.find(
-      (c) => c.relativePath === CODEX_CONFIG_REL,
-    );
-    expect(configChange?.kind).toBe("create");
-    expect(await exists(configPath)).toBe(false);
-    expect(await exists(statePath)).toBe(false);
-    expect(await exists(join(home, ".codex"))).toBe(false);
-  });
-
-  it("install writes only selected profile and not sibling work/default dirs", async () => {
-    const home = await makeTempHome("lr-codex-install-scope-");
-    await writeAllowlist(join(home, ".offrouter"), ["codex-personal"]);
-
-    // Pre-create sibling profile dirs with markers so we can detect writes.
-    const profilesRoot = join(home, "codex-profiles");
-    await mkdir(join(profilesRoot, "codex-work"), { recursive: true });
-    await mkdir(join(profilesRoot, "codex"), { recursive: true });
-    await writeFile(
-      join(profilesRoot, "codex-work", "marker.txt"),
-      "work-untouched",
-      "utf8",
-    );
-    await writeFile(
-      join(profilesRoot, "codex", "marker.txt"),
-      "default-untouched",
-      "utf8",
-    );
-    await mkdir(join(home, ".codex"), { recursive: true });
-    await writeFile(
-      join(home, ".codex", "marker.txt"),
-      "global-untouched",
-      "utf8",
-    );
-
-    const opts = await installOpts(home, "codex-personal");
-    const result = await installCodexProfile(opts);
-    expect(result.ok).toBe(true);
-    expect(result.dryRun).toBe(false);
-
-    const profileDir = resolveCodexProfileDir("codex-personal", opts);
-    const configPath = join(profileDir, CODEX_CONFIG_REL);
-    expect(await exists(configPath)).toBe(true);
-    const configRaw = await readFile(configPath, "utf8");
-    expect(configRaw).toContain("[mcp_servers.offrouter]");
-    expect(configRaw).toContain('command = "offrouter"');
-    expect(configRaw).toContain('args = [ "mcp", "serve" ]');
-
-    // Sibling profile and real home ~/.codex markers untouched
-    expect(
-      await readFile(join(profilesRoot, "codex-work", "marker.txt"), "utf8"),
-    ).toBe("work-untouched");
-    expect(
-      await readFile(join(profilesRoot, "codex", "marker.txt"), "utf8"),
-    ).toBe("default-untouched");
-    expect(await readFile(join(home, ".codex", "marker.txt"), "utf8")).toBe(
-      "global-untouched",
-    );
-    expect(await exists(join(profilesRoot, "codex-work", "config.toml"))).toBe(
-      false,
-    );
-    expect(await exists(join(home, ".codex", "config.toml"))).toBe(false);
-
-    // State lives inside target profile only
-    const statePath = join(profileDir, CODEX_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("codex-personal");
-    expect(state.harness).toBe("codex");
-    expect(state.files[CODEX_CONFIG_REL]).toBeDefined();
-  });
-
-  it("refuses denied work profiles", async () => {
-    const home = await makeTempHome("lr-codex-install-work-");
-    // Even if someone allowlists a work profile, policy still denies *-work.
-    await writeAllowlist(join(home, ".offrouter"), ["codex-work"]);
-    const opts = await installOpts(home, "codex-work", { dryRun: true });
-    const result = await installCodexProfile(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, "codex-profiles", "codex-work", "config.toml")),
-    ).toBe(false);
-  });
-
-  it("refuses work-like profile ids such as codex-work-staging even if allowlisted", async () => {
-    const home = await makeTempHome("lr-codex-install-work-staging-");
-    // Core policy only hard-denies ids ending in -work, so codex-work-staging
-    // would otherwise pass routeRequest. The installer must still refuse it.
-    await writeAllowlist(join(home, ".offrouter"), ["codex-work-staging"]);
-    const opts = await installOpts(home, "codex-work-staging", {
-      dryRun: true,
-    });
-    const result = await installCodexProfile(opts);
-    expect(result.ok).toBe(false);
-    expect(result.errorCode).toBe("work_profile_denied");
-    expect(result.message.toLowerCase()).toContain("work");
-    expect(
-      await exists(
-        join(home, "codex-profiles", "codex-work-staging", "config.toml"),
-      ),
-    ).toBe(false);
-  });
-
-  it("refuses unallowlisted personal profiles", async () => {
-    const home = await makeTempHome("lr-codex-install-unallow-");
-    await writeAllowlist(join(home, ".offrouter"), []); // nothing allowlisted
-    const opts = await installOpts(home, "codex-personal", { dryRun: true });
-    const result = await installCodexProfile(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-codex-install-unsafe-");
-    await writeAllowlist(join(home, ".offrouter"), ["../codex-personal"]);
-    const opts = await installOpts(home, "../codex-personal", {
-      dryRun: true,
-    });
-    const result = await installCodexProfile(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-Codex profiles for Codex install", async () => {
-    const home = await makeTempHome("lr-codex-install-non-codex-");
-    await writeAllowlist(join(home, ".offrouter"), ["claude-personal"]);
-    const opts = await installOpts(home, "claude-personal", { dryRun: true });
-    const result = await installCodexProfile(opts);
-    expect(result.ok).toBe(false);
-    expect(result.errorCode).toBe("install_error");
-    expect(result.message.toLowerCase()).toContain("codex install");
-    expect(
-      await exists(join(home, "codex-profiles", "claude-personal", "config.toml")),
-    ).toBe(false);
-  });
-
-  it("install --all-personal --dry-run returns a matrix of allowlisted personal Codex profiles", async () => {
-    const home = await makeTempHome("lr-codex-install-all-");
-    await writeAllowlist(join(home, ".offrouter"), [
-      "codex",
-      "codex-personal",
-      "codex-hobby",
-      "claude-personal",
-      "codex-work",
-    ]);
-    const env = baseEnv(home);
-    const config = await loadConfig({ env, homedir: () => home });
-    const profiles = listAllowlistedPersonalCodexProfiles(config);
-    expect(profiles).toEqual(
-      expect.arrayContaining(["codex-personal", "codex-hobby"]),
-    );
-    expect(profiles).not.toContain("codex");
-    expect(profiles).not.toContain("codex-work");
-    expect(profiles).not.toContain("claude-personal");
-
-    const matrix: CodexInstallResult[] = [];
-    for (const profile of profiles) {
-      matrix.push(
-        await installCodexProfile({
-          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(
-      ["codex-hobby", "codex-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-codex-install-rb-");
-    await writeAllowlist(join(home, ".offrouter"), ["codex-personal"]);
-
-    const opts = await installOpts(home, "codex-personal");
-    const profileDir = resolveCodexProfileDir("codex-personal", opts);
-    const configPath = join(profileDir, CODEX_CONFIG_REL);
-    await mkdir(profileDir, { recursive: true });
-    await writeFile(configPath, 'editor = "vim"\n', "utf8");
-
-    const installResult = await installCodexProfile(opts);
-    expect(installResult.ok).toBe(true);
-    const afterInstall = await readFile(configPath, "utf8");
-    expect(afterInstall).toContain("[mcp_servers.offrouter]");
-    expect(afterInstall).toContain('editor = "vim"');
-
-    // Preserve a sibling file inside .offrouter
-    const siblingStateFile = join(profileDir, ".offrouter", "notes.json");
-    await writeFile(siblingStateFile, '{"keep":true}\n', "utf8");
-
-    const rb = await rollbackCodexProfile({
-      profile: "codex-personal",
-      env: opts.env,
-      homedir: opts.homedir,
-      dryRun: false,
-    });
-    expect(rb.ok).toBe(true);
-    expect(await readFile(configPath, "utf8")).toBe('editor = "vim"\n');
-
-    const statePath = join(profileDir, CODEX_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-codex-install-corrupt-state-");
-    await writeAllowlist(join(home, ".offrouter"), ["codex-personal"]);
-    const opts = await installOpts(home, "codex-personal");
-    const profileDir = resolveCodexProfileDir("codex-personal", opts);
-    const configPath = join(profileDir, CODEX_CONFIG_REL);
-
-    const first = await installCodexProfile(opts);
-    expect(first.ok).toBe(true);
-    await writeFile(configPath, "# user edit\n", "utf8");
-    await writeFile(
-      join(profileDir, CODEX_INSTALL_STATE_REL),
-      "{not valid json",
-      "utf8",
-    );
-
-    const second = await installCodexProfile(opts);
-    expect(second.ok).toBe(false);
-    expect(second.message.toLowerCase()).toContain("invalid install state");
-    expect(await readFile(configPath, "utf8")).toBe("# user edit\n");
-  });
-
-  it("rollback refuses install state paths outside the profile root (path traversal)", async () => {
-    const home = await makeTempHome("lr-codex-install-rb-escape-");
-    const env = baseEnv(home);
-    const profile = "codex-personal";
-    const profileDir = resolveCodexProfileDir(profile, {
-      env,
-      homedir: () => home,
-    });
-    const outsidePath = join(home, "outside.txt");
-    const statePath = join(profileDir, CODEX_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: "codex",
-          installedAt: new Date(0).toISOString(),
-          configRelative: CODEX_CONFIG_REL,
-          files: {
-            "../../outside.txt": { previous: null },
-          },
-        },
-        null,
-        2,
-      )}\n`,
-      "utf8",
-    );
-
-    const rb = await rollbackCodexProfile({
-      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-codex-install-idemp-");
-    await writeAllowlist(join(home, ".offrouter"), ["codex-personal"]);
-    const opts = await installOpts(home, "codex-personal");
-    const profileDir = resolveCodexProfileDir("codex-personal", opts);
-    const configPath = join(profileDir, CODEX_CONFIG_REL);
-
-    await mkdir(profileDir, { recursive: true });
-    await writeFile(configPath, 'model = "o3"\n', "utf8");
-
-    const first = await installCodexProfile(opts);
-    const second = await installCodexProfile(opts);
-    expect(first.ok).toBe(true);
-    expect(second.ok).toBe(true);
-
-    const after = await readFile(configPath, "utf8");
-    expect(after).toContain("[mcp_servers.offrouter]");
-    // Unrelated key is preserved across the TOML round-trip.
-    expect(after).toContain('model = "o3"');
-
-    // State still tracks original contents for true rollback
-    const state = JSON.parse(
-      await readFile(join(profileDir, CODEX_INSTALL_STATE_REL), "utf8"),
-    ) as { files: Record<string, { previous: string | null }> };
-    expect(state.files[CODEX_CONFIG_REL]?.previous).toContain("model");
-
-    const rb = await rollbackCodexProfile({
-      profile: "codex-personal",
-      env: opts.env,
-      homedir: opts.homedir,
-    });
-    expect(rb.ok).toBe(true);
-    expect(await readFile(configPath, "utf8")).toBe('model = "o3"\n');
-  });
-});
-
-describe("patchConfigForMcp", () => {
-  it("creates a fresh config from a missing file", () => {
-    const out = patchConfigForMcp(null);
-    expect(out).toContain("[mcp_servers.offrouter]");
-    expect(out).toContain('command = "offrouter"');
-    expect(out).toContain('args = [ "mcp", "serve" ]');
-  });
-
-  it("creates a fresh config from an empty or whitespace-only file", () => {
-    for (const empty of ["", "   ", "\n\n"]) {
-      const out = patchConfigForMcp(empty);
-      expect(out).toContain("[mcp_servers.offrouter]");
-      expect(out).toContain('command = "offrouter"');
-    }
-  });
-
-  it("preserves unrelated keys when installing", () => {
-    const existing =
-      'editor = "vim"\n' +
-      'model = "o3"\n' +
-      "\n" +
-      "[mcp_servers.other]\n" +
-      'command = "other-tool"\n' +
-      'args = ["run"]\n';
-    const out = patchConfigForMcp(existing);
-    // OffRouter entry is present.
-    expect(out).toContain("[mcp_servers.offrouter]");
-    expect(out).toContain('command = "offrouter"');
-    expect(out).toContain('args = [ "mcp", "serve" ]');
-    // Unrelated keys and the other MCP server survive the round-trip.
-    expect(out).toContain('editor = "vim"');
-    expect(out).toContain('model = "o3"');
-    expect(out).toContain("[mcp_servers.other]");
-    expect(out).toContain('command = "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);
-    expect(out).toContain('command = "offrouter"');
-    expect(out).toContain('args = [ "mcp", "serve" ]');
-    // The old command must be gone (overwritten, not appended).
-    expect(out).not.toContain('command = "old-tool"');
-    expect(out).not.toContain("different");
-  });
-
-  it("is idempotent when already installed correctly (detected by value)", () => {
-    // Matching command/args but different quote/whitespace style than the
-    // canonical block: still 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);
-    expect(out).toContain('args = [ "mcp", "serve" ]');
-    expect(out).not.toContain('args = ["serve"]');
-  });
-});