offrouter-adapter-claude 0.0.0

package/src/install.test.ts

@@ -0,0 +1,589 @@
+import { access, mkdir, 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 {
+  CLAUDE_INSTALL_STATE_REL,
+  INSTALLED_PLUGIN_REL,
+  installClaudeProfile,
+  listAllowlistedPersonalClaudeProfiles,
+  resolveClaudeProfileDir,
+  type ClaudeInstallOptions,
+  type ClaudeInstallResult,
+} from "./install.js";
+import { rollbackClaudeProfile } from "./rollback.js";
+
+const tempRoots: string[] = [];
+
+async function makeTempHome(prefix: string): Promise<string> {
+  const { mkdtemp } = await import("node:fs/promises");
+  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_CLAUDE_PROFILES_DIR: join(home, "claude-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<ClaudeInstallOptions> = {},
+): Promise<ClaudeInstallOptions> {
+  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("resolveClaudeProfileDir", () => {
+  it("uses OFFROUTER_CLAUDE_PROFILES_DIR/<profile> when set", () => {
+    const home = "/tmp/not-used-home";
+    const dir = resolveClaudeProfileDir("claude-personal", {
+      env: {
+        OFFROUTER_CLAUDE_PROFILES_DIR: "/tmp/profiles-root",
+      },
+      homedir: () => home,
+    });
+    expect(dir).toBe(join("/tmp/profiles-root", "claude-personal"));
+  });
+
+  it("maps profile id claude to ~/.claude and claude-personal to ~/.claude-personal", () => {
+    const home = "/tmp/fake-home-map";
+    expect(
+      resolveClaudeProfileDir("claude", {
+        env: {},
+        homedir: () => home,
+      }),
+    ).toBe(join(home, ".claude"));
+    expect(
+      resolveClaudeProfileDir("claude-personal", {
+        env: {},
+        homedir: () => home,
+      }),
+    ).toBe(join(home, ".claude-personal"));
+  });
+
+  it("rejects unsafe profile ids before resolving profile paths", () => {
+    expect(() =>
+      resolveClaudeProfileDir("../claude-personal", {
+        env: {
+          OFFROUTER_CLAUDE_PROFILES_DIR: "/tmp/profiles-root",
+        },
+        homedir: () => "/tmp/fake-home",
+      }),
+    ).toThrow(/unsafe profile id/i);
+  });
+});
+
+describe("installClaudeProfile", () => {
+  it("dry-run shows exact file changes and does not write files", async () => {
+    const home = await makeTempHome("lr-install-dry-");
+    await writeAllowlist(join(home, ".offrouter"), ["claude-personal"]);
+    const opts = await installOpts(home, "claude-personal", { dryRun: true });
+    const result = await installClaudeProfile(opts);
+
+    expect(result.ok).toBe(true);
+    expect(result.dryRun).toBe(true);
+    expect(result.profile).toBe("claude-personal");
+    expect(result.changes.length).toBeGreaterThan(0);
+
+    const profileDir = resolveClaudeProfileDir("claude-personal", opts);
+    const targetHook = join(
+      profileDir,
+      "skills",
+      "offrouter",
+      "hooks",
+      "hooks.json",
+    );
+    const statePath = join(
+      profileDir,
+      ".offrouter",
+      "claude-install-state.json",
+    );
+
+    expect(
+      result.changes.some(
+        (c) =>
+          c.path.endsWith(
+            join("skills", "offrouter", "hooks", "hooks.json"),
+          ) || c.relativePath === "skills/offrouter/hooks/hooks.json",
+      ),
+    ).toBe(true);
+    expect(await exists(targetHook)).toBe(false);
+    expect(await exists(statePath)).toBe(false);
+    expect(await exists(join(home, ".claude"))).toBe(false);
+  });
+
+  it("install writes only selected profile paths and not sibling work/default dirs", async () => {
+    const home = await makeTempHome("lr-install-scope-");
+    await writeAllowlist(join(home, ".offrouter"), ["claude-personal"]);
+
+    // Pre-create sibling profile dirs with markers so we can detect writes.
+    const profilesRoot = join(home, "claude-profiles");
+    await mkdir(join(profilesRoot, "claude-work"), { recursive: true });
+    await mkdir(join(profilesRoot, "claude"), { recursive: true });
+    await writeFile(
+      join(profilesRoot, "claude-work", "marker.txt"),
+      "work-untouched",
+      "utf8",
+    );
+    await writeFile(
+      join(profilesRoot, "claude", "marker.txt"),
+      "default-untouched",
+      "utf8",
+    );
+    await mkdir(join(home, ".claude"), { recursive: true });
+    await writeFile(
+      join(home, ".claude", "marker.txt"),
+      "global-untouched",
+      "utf8",
+    );
+
+    const opts = await installOpts(home, "claude-personal");
+    const result = await installClaudeProfile(opts);
+    expect(result.ok).toBe(true);
+    expect(result.dryRun).toBe(false);
+
+    const profileDir = resolveClaudeProfileDir("claude-personal", opts);
+    const hookPath = join(
+      profileDir,
+      "skills",
+      "offrouter",
+      "hooks",
+      "hooks.json",
+    );
+    expect(await exists(hookPath)).toBe(true);
+    const hooksRaw = await readFile(hookPath, "utf8");
+    const hooks = JSON.parse(hooksRaw) as {
+      hooks?: {
+        UserPromptSubmit?: Array<{
+          hooks?: Array<{ command?: string }>;
+        }>;
+      };
+    };
+    const commands =
+      hooks.hooks?.UserPromptSubmit?.flatMap((e) =>
+        (e.hooks ?? []).map((h) => h.command ?? ""),
+      ) ?? [];
+    const joined = commands.join("\n");
+    expect(joined).toContain("OFFROUTER_PROFILE=claude-personal");
+    expect(joined).toContain("offrouter hooks claude user-prompt-submit");
+    expect(joined).not.toContain("OFFROUTER_WORKSPACE_TRUSTED");
+
+    // Sibling profile and real home ~/.claude markers untouched
+    expect(
+      await readFile(join(profilesRoot, "claude-work", "marker.txt"), "utf8"),
+    ).toBe("work-untouched");
+    expect(
+      await readFile(join(profilesRoot, "claude", "marker.txt"), "utf8"),
+    ).toBe("default-untouched");
+    expect(await readFile(join(home, ".claude", "marker.txt"), "utf8")).toBe(
+      "global-untouched",
+    );
+    expect(await exists(join(profilesRoot, "claude-work", "skills"))).toBe(
+      false,
+    );
+    expect(await exists(join(home, ".claude", "skills"))).toBe(false);
+
+    // State lives inside target profile only
+    const statePath = join(
+      profileDir,
+      ".offrouter",
+      "claude-install-state.json",
+    );
+    expect(await exists(statePath)).toBe(true);
+    const state = JSON.parse(await readFile(statePath, "utf8")) as {
+      profile: string;
+      files: Record<string, { previous: string | null }>;
+    };
+    expect(state.profile).toBe("claude-personal");
+    expect(Object.keys(state.files).length).toBeGreaterThan(0);
+  });
+
+  it("refuses denied work profiles", async () => {
+    const home = await makeTempHome("lr-install-work-");
+    // Even if someone allowlists a work profile, policy still denies *-work.
+    await writeAllowlist(join(home, ".offrouter"), ["claude-work"]);
+    const opts = await installOpts(home, "claude-work", { dryRun: true });
+    const result = await installClaudeProfile(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, "claude-profiles", "claude-work", "skills", "offrouter"),
+      ),
+    ).toBe(false);
+  });
+
+  it("refuses work-like profile ids such as claude-work-staging even if allowlisted", async () => {
+    const home = await makeTempHome("lr-install-work-staging-");
+    // Core policy only hard-denies ids ending in -work, so claude-work-staging
+    // would otherwise pass routeRequest. The installer must still refuse it.
+    await writeAllowlist(join(home, ".offrouter"), ["claude-work-staging"]);
+    const opts = await installOpts(home, "claude-work-staging", {
+      dryRun: true,
+    });
+    const result = await installClaudeProfile(opts);
+    expect(result.ok).toBe(false);
+    expect(result.errorCode).toBe("work_profile_denied");
+    expect(result.message.toLowerCase()).toContain("work");
+    expect(
+      await exists(
+        join(
+          home,
+          "claude-profiles",
+          "claude-work-staging",
+          "skills",
+          "offrouter",
+        ),
+      ),
+    ).toBe(false);
+  });
+
+  it("refuses unallowlisted personal profiles", async () => {
+    const home = await makeTempHome("lr-install-unallow-");
+    await writeAllowlist(join(home, ".offrouter"), []); // nothing allowlisted
+    const opts = await installOpts(home, "claude-personal", { dryRun: true });
+    const result = await installClaudeProfile(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-install-unsafe-");
+    await writeAllowlist(join(home, ".offrouter"), ["../claude-personal"]);
+    const opts = await installOpts(home, "../claude-personal", {
+      dryRun: true,
+    });
+    const result = await installClaudeProfile(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-Claude profiles for Claude install", async () => {
+    const home = await makeTempHome("lr-install-non-claude-");
+    await writeAllowlist(join(home, ".offrouter"), ["codex-personal"]);
+    const opts = await installOpts(home, "codex-personal", { dryRun: true });
+    const result = await installClaudeProfile(opts);
+    expect(result.ok).toBe(false);
+    expect(result.errorCode).toBe("install_error");
+    expect(result.message.toLowerCase()).toContain("claude install");
+    expect(
+      await exists(join(home, "claude-profiles", "codex-personal", "skills")),
+    ).toBe(false);
+  });
+
+  it("install --all-personal --dry-run returns a matrix of allowlisted personal Claude profiles", async () => {
+    const home = await makeTempHome("lr-install-all-");
+    await writeAllowlist(join(home, ".offrouter"), [
+      "claude",
+      "claude-personal",
+      "claude-hobby",
+      "codex-personal",
+      "claude-work",
+    ]);
+    const env = baseEnv(home);
+    const config = await loadConfig({ env, homedir: () => home });
+    const profiles = listAllowlistedPersonalClaudeProfiles(config);
+    expect(profiles).toEqual(
+      expect.arrayContaining(["claude-personal", "claude-hobby"]),
+    );
+    expect(profiles).not.toContain("claude");
+    expect(profiles).not.toContain("claude-work");
+    expect(profiles).not.toContain("codex-personal");
+
+    const matrix: ClaudeInstallResult[] = [];
+    for (const profile of profiles) {
+      matrix.push(
+        await installClaudeProfile({
+          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(
+      ["claude-hobby", "claude-personal"].sort(),
+    );
+    expect(
+      matrix.every((r) =>
+        r.changes.some((c) => c.kind === "create" || c.kind === "update"),
+      ),
+    ).toBe(true);
+  });
+
+  it("rollback restores previous files from metadata", async () => {
+    const home = await makeTempHome("lr-install-rb-");
+    await writeAllowlist(join(home, ".offrouter"), ["claude-personal"]);
+
+    const opts = await installOpts(home, "claude-personal");
+    const profileDir = resolveClaudeProfileDir("claude-personal", opts);
+    const existingPath = join(
+      profileDir,
+      "skills",
+      "offrouter",
+      "hooks",
+      "hooks.json",
+    );
+    await mkdir(join(profileDir, "skills", "offrouter", "hooks"), {
+      recursive: true,
+    });
+    await writeFile(existingPath, '{"description":"preexisting"}\n', "utf8");
+
+    const installResult = await installClaudeProfile(opts);
+    expect(installResult.ok).toBe(true);
+    const siblingStateFile = join(profileDir, ".offrouter", "notes.json");
+    await writeFile(siblingStateFile, '{"keep":true}\n', "utf8");
+    const afterInstall = await readFile(existingPath, "utf8");
+    expect(afterInstall).not.toContain("preexisting");
+    expect(afterInstall).toContain("OFFROUTER_PROFILE=claude-personal");
+
+    const rb = await rollbackClaudeProfile({
+      profile: "claude-personal",
+      env: opts.env,
+      homedir: opts.homedir,
+      dryRun: false,
+    });
+    expect(rb.ok).toBe(true);
+    expect(await readFile(existingPath, "utf8")).toContain("preexisting");
+
+    // Files created by OffRouter with no previous content are removed
+    const pluginManifest = join(
+      profileDir,
+      "skills",
+      "offrouter",
+      ".claude-plugin",
+      "plugin.json",
+    );
+    expect(await exists(pluginManifest)).toBe(false);
+
+    const statePath = join(
+      profileDir,
+      ".offrouter",
+      "claude-install-state.json",
+    );
+    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-install-corrupt-state-");
+    await writeAllowlist(join(home, ".offrouter"), ["claude-personal"]);
+    const opts = await installOpts(home, "claude-personal");
+    const profileDir = resolveClaudeProfileDir("claude-personal", opts);
+    const hookPath = join(
+      profileDir,
+      "skills",
+      "offrouter",
+      "hooks",
+      "hooks.json",
+    );
+
+    const first = await installClaudeProfile(opts);
+    expect(first.ok).toBe(true);
+    await writeFile(hookPath, '{"description":"user edit"}\n', "utf8");
+    await writeFile(
+      join(profileDir, ".offrouter", "claude-install-state.json"),
+      "{not valid json",
+      "utf8",
+    );
+
+    const second = await installClaudeProfile(opts);
+    expect(second.ok).toBe(false);
+    expect(second.message.toLowerCase()).toContain("invalid install state");
+    expect(await readFile(hookPath, "utf8")).toBe(
+      '{"description":"user edit"}\n',
+    );
+  });
+
+  it("rollback refuses install state paths outside the installed plugin root", async () => {
+    const home = await makeTempHome("lr-install-rb-escape-");
+    const env = baseEnv(home);
+    const profile = "claude-personal";
+    const profileDir = resolveClaudeProfileDir(profile, {
+      env,
+      homedir: () => home,
+    });
+    const outsidePath = join(home, "outside.txt");
+    const statePath = join(profileDir, CLAUDE_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: "claude",
+          installedAt: new Date(0).toISOString(),
+          pluginRootRelative: INSTALLED_PLUGIN_REL,
+          files: {
+            "../../outside.txt": { previous: null },
+          },
+        },
+        null,
+        2,
+      )}\n`,
+      "utf8",
+    );
+
+    const rb = await rollbackClaudeProfile({
+      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("rollback refuses prefix-matching paths that still escape the plugin root", async () => {
+    const home = await makeTempHome("lr-install-rb-prefix-escape-");
+    const env = baseEnv(home);
+    const profile = "claude-personal";
+    const profileDir = resolveClaudeProfileDir(profile, {
+      env,
+      homedir: () => home,
+    });
+    const secretPath = join(home, "secret.txt");
+    const statePath = join(profileDir, CLAUDE_INSTALL_STATE_REL);
+    await writeFile(secretPath, "top-secret\n", "utf8");
+    await mkdir(join(profileDir, ".offrouter"), { recursive: true });
+    await writeFile(
+      statePath,
+      `${JSON.stringify(
+        {
+          version: 1,
+          profile,
+          harness: "claude",
+          installedAt: new Date(0).toISOString(),
+          pluginRootRelative: INSTALLED_PLUGIN_REL,
+          files: {
+            // Starts with the plugin prefix but traverses out via "..".
+            "skills/offrouter/../../../secret.txt": { previous: null },
+          },
+        },
+        null,
+        2,
+      )}\n`,
+      "utf8",
+    );
+
+    const rb = await rollbackClaudeProfile({
+      profile,
+      env,
+      homedir: () => home,
+    });
+    expect(rb.ok).toBe(false);
+    expect(rb.errorCode).toBe("invalid_install_state");
+    expect(await readFile(secretPath, "utf8")).toBe("top-secret\n");
+    expect(await exists(statePath)).toBe(true);
+  });
+
+  it("repeated install is idempotent and preserves original rollback", async () => {
+    const home = await makeTempHome("lr-install-idemp-");
+    await writeAllowlist(join(home, ".offrouter"), ["claude-personal"]);
+    const opts = await installOpts(home, "claude-personal");
+    const profileDir = resolveClaudeProfileDir("claude-personal", opts);
+    const hookPath = join(
+      profileDir,
+      "skills",
+      "offrouter",
+      "hooks",
+      "hooks.json",
+    );
+
+    await mkdir(join(profileDir, "skills", "offrouter", "hooks"), {
+      recursive: true,
+    });
+    await writeFile(hookPath, '{"description":"original"}\n', "utf8");
+
+    const first = await installClaudeProfile(opts);
+    const second = await installClaudeProfile(opts);
+    expect(first.ok).toBe(true);
+    expect(second.ok).toBe(true);
+
+    const after = await readFile(hookPath, "utf8");
+    expect(after).toContain("OFFROUTER_PROFILE=claude-personal");
+
+    // State still tracks original contents for true rollback
+    const state = JSON.parse(
+      await readFile(
+        join(profileDir, ".offrouter", "claude-install-state.json"),
+        "utf8",
+      ),
+    ) as { files: Record<string, { previous: string | null }> };
+    const hookRel = "skills/offrouter/hooks/hooks.json";
+    expect(state.files[hookRel]?.previous).toContain("original");
+
+    const rb = await rollbackClaudeProfile({
+      profile: "claude-personal",
+      env: opts.env,
+      homedir: opts.homedir,
+    });
+    expect(rb.ok).toBe(true);
+    expect(await readFile(hookPath, "utf8")).toContain("original");
+  });
+});