offrouter-adapter-claude 0.0.0

package/src/plugin.test.ts

@@ -0,0 +1,150 @@
+import { readFile, access } from "node:fs/promises";
+import { constants } from "node:fs";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+
+const repoRoot = resolve(fileURLToPath(new URL("../../../", import.meta.url)));
+const pluginRoot = join(repoRoot, "plugins", "claude-offrouter");
+
+async function exists(path: string): Promise<boolean> {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readText(path: string): Promise<string> {
+  return readFile(path, "utf8");
+}
+
+describe("Claude OffRouter plugin package", () => {
+  it("includes required plugin root files", async () => {
+    for (const rel of [
+      ".claude-plugin/plugin.json",
+      "skills/delegate/SKILL.md",
+      "skills/status/SKILL.md",
+      "hooks/hooks.json",
+      ".mcp.json",
+    ]) {
+      expect(await exists(join(pluginRoot, rel)), rel).toBe(true);
+    }
+  });
+
+  it("declares a strict-validation-friendly plugin manifest", async () => {
+    const raw = await readText(
+      join(pluginRoot, ".claude-plugin", "plugin.json"),
+    );
+    const manifest = JSON.parse(raw) as Record<string, unknown>;
+
+    expect(manifest.name).toBe("offrouter");
+    expect(typeof manifest.description).toBe("string");
+    expect(String(manifest.description).length).toBeGreaterThan(10);
+    if ("displayName" in manifest) {
+      expect(manifest.displayName).toBe("OffRouter");
+    }
+    if ("defaultEnabled" in manifest) {
+      expect(manifest.defaultEnabled).toBe(false);
+    }
+    expect(raw.toLowerCase()).not.toMatch(
+      /claude[-_ ]?router|codex[-_ ]?companion|openai[-_ ]?codex-plugin/,
+    );
+  });
+
+  it("skills document /offrouter:delegate and /offrouter:status via MCP with the V1 honesty boundary", async () => {
+    const delegate = await readText(
+      join(pluginRoot, "skills", "delegate", "SKILL.md"),
+    );
+    const status = await readText(
+      join(pluginRoot, "skills", "status", "SKILL.md"),
+    );
+
+    expect(delegate).toMatch(/offrouter:delegate|\/offrouter:delegate/);
+    expect(status).toMatch(/offrouter:status|\/offrouter:status/);
+
+    for (const skill of [delegate, status]) {
+      expect(skill.toLowerCase()).toContain("mcp");
+      expect(skill).toMatch(/primary model is unchanged/i);
+      expect(skill).toMatch(/routes delegated work/i);
+      // Reject affirmative takeover claims; allow the honesty boundary itself.
+      expect(skill.toLowerCase()).not.toMatch(
+        /\b(will|can|does|this plugin)\s+replace(s|ing)?\s+(claude|the primary)\b/i,
+      );
+      expect(skill.toLowerCase()).not.toMatch(
+        /\b(will|can|does|this plugin)\s+intercept(s|ing)?\s+(primary|claude)\b/i,
+      );
+      expect(skill.toLowerCase()).not.toMatch(
+        /claude[-_ ]?router|codex[-_ ]?companion/,
+      );
+    }
+  });
+
+  it("hooks UserPromptSubmit to the built offrouter CLI bridge without hardcoded profile names", async () => {
+    const raw = await readText(join(pluginRoot, "hooks", "hooks.json"));
+    const hooks = JSON.parse(raw) as {
+      hooks?: {
+        UserPromptSubmit?: Array<{
+          hooks?: Array<{ type?: string; command?: string }>;
+        }>;
+      };
+    };
+
+    const commands =
+      hooks.hooks?.UserPromptSubmit?.flatMap((entry) =>
+        (entry.hooks ?? [])
+          .filter((hook) => hook.type === "command")
+          .map((hook) => hook.command ?? ""),
+      ) ?? [];
+
+    expect(commands.length).toBeGreaterThan(0);
+
+    const joined = commands.join("\n");
+    expect(joined).toContain("offrouter hooks claude user-prompt-submit");
+    // Built CLI on PATH, not a repo-relative source or dist path that breaks
+    // after Claude caches the plugin.
+    expect(joined).not.toMatch(/packages\/cli\/src\//);
+    expect(joined).not.toMatch(/packages\/cli\/dist\//);
+    expect(joined).not.toContain("CLAUDE_PLUGIN_ROOT");
+    // Generic package must not hardcode profile selection.
+    expect(joined).not.toMatch(/claude-personal|claude-work/);
+    expect(raw.toLowerCase()).not.toMatch(
+      /claude[-_ ]?router|codex[-_ ]?companion/,
+    );
+  });
+
+  it("configures the exact offrouter MCP stdio server", async () => {
+    const raw = await readText(join(pluginRoot, ".mcp.json"));
+    const mcp = JSON.parse(raw) as {
+      mcpServers?: Record<
+        string,
+        { command?: string; args?: string[]; type?: string }
+      >;
+    };
+
+    expect(mcp.mcpServers?.offrouter).toEqual({
+      command: "offrouter",
+      args: ["mcp", "serve"],
+    });
+    expect(raw.toLowerCase()).not.toMatch(
+      /claude[-_ ]?router|codex[-_ ]?companion/,
+    );
+  });
+
+  it("contains no raw external-project references across plugin files", async () => {
+    const files = [
+      ".claude-plugin/plugin.json",
+      "skills/delegate/SKILL.md",
+      "skills/status/SKILL.md",
+      "hooks/hooks.json",
+      ".mcp.json",
+    ];
+    for (const rel of files) {
+      const text = (await readText(join(pluginRoot, rel))).toLowerCase();
+      expect(text, rel).not.toMatch(
+        /claude[-_ ]?router|codex[-_ ]?companion|openai[-_ ]?codex-plugin|claude[-_ ]?mem/,
+      );
+    }
+  });
+});

package/src/rollback.ts

@@ -0,0 +1,329 @@
+/**
+ * Rollback for profile-scoped Claude install state.
+ * Restores overwritten plugin files and removes files created by OffRouter.
+ */
+import {
+  access,
+  mkdir,
+  readFile,
+  rmdir,
+  unlink,
+  writeFile,
+} from "node:fs/promises";
+import { constants } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { homedir as osHomedir } from "node:os";
+import {
+  CLAUDE_INSTALL_STATE_REL,
+  ClaudeInstallStateSchema,
+  INSTALLED_PLUGIN_REL,
+  resolveClaudeProfileDir,
+  type ClaudeInstallState,
+  type InstallChangeKind,
+  type InstallFileChange,
+} from "./install.js";
+
+export interface ClaudeRollbackOptions {
+  profile: string;
+  env?: NodeJS.ProcessEnv;
+  homedir?: () => string;
+  dryRun?: boolean;
+  /** Optional absolute override of the profile directory (tests). */
+  profileDir?: string;
+}
+
+export interface ClaudeRollbackResult {
+  ok: boolean;
+  dryRun: boolean;
+  profile: string;
+  profileDir: string;
+  changes: InstallFileChange[];
+  message: string;
+  errorCode?: "no_install_state" | "invalid_install_state" | "rollback_error";
+}
+
+async function pathExists(path: string): Promise<boolean> {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function changeSummary(kind: InstallChangeKind, relativePath: string): string {
+  switch (kind) {
+    case "create":
+      return `+ ${relativePath}`;
+    case "update":
+      return `~ ${relativePath}`;
+    case "unchanged":
+      return `= ${relativePath}`;
+    case "remove":
+      return `- ${relativePath}`;
+    default:
+      return `? ${relativePath}`;
+  }
+}
+
+async function loadState(statePath: string): Promise<
+  | { ok: true; state: ClaudeInstallState }
+  | {
+      ok: false;
+      errorCode: "no_install_state" | "invalid_install_state";
+      message: string;
+    }
+> {
+  if (!(await pathExists(statePath))) {
+    return {
+      ok: false,
+      errorCode: "no_install_state",
+      message: `No install state at ${statePath}. Nothing to uninstall.`,
+    };
+  }
+  try {
+    const raw = await readFile(statePath, "utf8");
+    const state = ClaudeInstallStateSchema.parse(JSON.parse(raw));
+    return { ok: true, state };
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    return {
+      ok: false,
+      errorCode: "invalid_install_state",
+      message: `Invalid install state at ${statePath}: ${detail}`,
+    };
+  }
+}
+
+function isWindowsAbsolutePath(path: string): boolean {
+  return /^[A-Za-z]:[\\/]/.test(path);
+}
+
+function isInsideOrSame(root: string, candidate: string): boolean {
+  const rel = relative(root, candidate);
+  return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+
+function resolveProfileRelativePath(
+  profileDir: string,
+  relativePath: string,
+): string | null {
+  if (
+    relativePath.trim() === "" ||
+    relativePath.includes("\0") ||
+    isAbsolute(relativePath) ||
+    isWindowsAbsolutePath(relativePath)
+  ) {
+    return null;
+  }
+
+  const parts = relativePath.split(/[\\/]+/);
+  if (parts.some((part) => part === "" || part === "." || part === "..")) {
+    return null;
+  }
+
+  const root = resolve(profileDir);
+  const candidate = resolve(root, ...parts);
+  if (!isInsideOrSame(root, candidate)) {
+    return null;
+  }
+  return candidate;
+}
+
+function validateRollbackState(
+  profileDir: string,
+  state: ClaudeInstallState,
+):
+  | { ok: true; filePaths: Map<string, string>; pluginRoot: string }
+  | { ok: false; message: string } {
+  if (state.pluginRootRelative !== INSTALLED_PLUGIN_REL) {
+    return {
+      ok: false,
+      message: `Invalid plugin root in install state: ${state.pluginRootRelative}`,
+    };
+  }
+
+  const pluginRoot = resolveProfileRelativePath(
+    profileDir,
+    state.pluginRootRelative,
+  );
+  if (!pluginRoot) {
+    return {
+      ok: false,
+      message: `Invalid plugin root in install state: ${state.pluginRootRelative}`,
+    };
+  }
+
+  const filePaths = new Map<string, string>();
+  const pluginPrefix = `${INSTALLED_PLUGIN_REL}/`;
+  for (const relativePath of Object.keys(state.files)) {
+    if (!relativePath.startsWith(pluginPrefix)) {
+      return {
+        ok: false,
+        message: `Install state path is outside plugin root: ${relativePath}`,
+      };
+    }
+    const abs = resolveProfileRelativePath(profileDir, relativePath);
+    if (!abs) {
+      return {
+        ok: false,
+        message: `Invalid install state path: ${relativePath}`,
+      };
+    }
+    filePaths.set(relativePath, abs);
+  }
+
+  return { ok: true, filePaths, pluginRoot };
+}
+
+function collectParentDirsUntil(
+  filePath: string,
+  stopDir: string,
+  out: Set<string>,
+): void {
+  const stop = resolve(stopDir);
+  let dir = dirname(filePath);
+  while (isInsideOrSame(stop, dir)) {
+    out.add(dir);
+    if (dir === stop) break;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+}
+
+/**
+ * Restore files tracked by claude-install-state.json for a profile.
+ */
+export async function rollbackClaudeProfile(
+  options: ClaudeRollbackOptions,
+): Promise<ClaudeRollbackResult> {
+  const {
+    profile,
+    dryRun = false,
+    env = process.env,
+    homedir = osHomedir,
+  } = options;
+  const profileDir =
+    options.profileDir ?? resolveClaudeProfileDir(profile, { env, homedir });
+  const statePath = join(profileDir, CLAUDE_INSTALL_STATE_REL);
+
+  const loaded = await loadState(statePath);
+  if (!loaded.ok) {
+    return {
+      ok: false,
+      dryRun,
+      profile,
+      profileDir,
+      changes: [],
+      message: loaded.message,
+      errorCode: loaded.errorCode,
+    };
+  }
+
+  const { state } = loaded;
+  const validated = validateRollbackState(profileDir, state);
+  if (!validated.ok) {
+    return {
+      ok: false,
+      dryRun,
+      profile,
+      profileDir,
+      changes: [],
+      message: validated.message,
+      errorCode: "invalid_install_state",
+    };
+  }
+
+  const changes: InstallFileChange[] = [];
+  const emptyDirsToRemove = new Set<string>();
+
+  // Restore/remove plugin files in reverse path length so nested files go first.
+  const entries = Object.entries(state.files).sort(
+    (a, b) => b[0].length - a[0].length,
+  );
+
+  for (const [relativePath, fileState] of entries) {
+    const abs = validated.filePaths.get(relativePath)!;
+    const previous = fileState.previous;
+
+    if (previous === null) {
+      // File was created by install; remove it on rollback.
+      const existed = await pathExists(abs);
+      const kind: InstallChangeKind = existed ? "remove" : "unchanged";
+      changes.push({
+        path: abs,
+        relativePath,
+        kind,
+        summary: changeSummary(kind, relativePath),
+      });
+      if (!dryRun && existed) {
+        collectParentDirsUntil(abs, validated.pluginRoot, emptyDirsToRemove);
+        await unlink(abs);
+      }
+      continue;
+    }
+
+    let current: string | null = null;
+    if (await pathExists(abs)) {
+      current = await readFile(abs, "utf8");
+    }
+    let kind: InstallChangeKind;
+    if (current === previous) {
+      kind = "unchanged";
+    } else if (current === null) {
+      kind = "create"; // restore missing prior content
+    } else {
+      kind = "update";
+    }
+    changes.push({
+      path: abs,
+      relativePath,
+      kind,
+      summary: changeSummary(kind, relativePath),
+    });
+    if (!dryRun && kind !== "unchanged") {
+      await mkdir(dirname(abs), { recursive: true });
+      await writeFile(abs, previous, "utf8");
+    }
+  }
+
+  // Drop install state last
+  const stateChangeKind: InstallChangeKind = "remove";
+  changes.push({
+    path: statePath,
+    relativePath: CLAUDE_INSTALL_STATE_REL,
+    kind: stateChangeKind,
+    summary: changeSummary(stateChangeKind, CLAUDE_INSTALL_STATE_REL),
+  });
+  if (!dryRun) {
+    await unlink(statePath);
+    for (const dir of [...emptyDirsToRemove].sort(
+      (a, b) => b.length - a.length,
+    )) {
+      try {
+        await rmdir(dir);
+      } catch {
+        // ignore non-empty or already-removed directories
+      }
+    }
+    // Best-effort remove only the empty install-state directory.
+    try {
+      await rmdir(join(profileDir, ".offrouter"));
+    } catch {
+      // ignore
+    }
+  }
+
+  const applied = changes.filter((c) => c.kind !== "unchanged");
+  return {
+    ok: true,
+    dryRun,
+    profile,
+    profileDir,
+    changes,
+    message: dryRun
+      ? `Dry run: would roll back ${applied.length} change(s) for profile ${profile}.`
+      : `Rolled back OffRouter Claude install for profile ${profile} (${applied.length} change(s)).`,
+  };
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["src/**/*.test.ts"],
+  "references": [{ "path": "../core" }]
+}