offrouter-adapter-codex 0.0.0

package/src/rollback.ts

@@ -0,0 +1,283 @@
+/**
+ * Rollback for profile-scoped Codex install state.
+ * Restores the profile's config.toml to its previous content (or removes the
+ * OffRouter-created file) and drops the install-state metadata.
+ */
+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 {
+  CODEX_CONFIG_REL,
+  CODEX_INSTALL_STATE_REL,
+  CodexInstallStateSchema,
+  type CodexInstallState,
+  type InstallChangeKind,
+  type InstallFileChange,
+} from "./install.js";
+import { resolveCodexProfileDir } from "./profile.js";
+
+export interface CodexRollbackOptions {
+  profile: string;
+  env?: NodeJS.ProcessEnv;
+  homedir?: () => string;
+  dryRun?: boolean;
+  /** Optional absolute override of the profile directory (tests). */
+  profileDir?: string;
+}
+
+export interface CodexRollbackResult {
+  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: CodexInstallState }
+  | {
+      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 = CodexInstallStateSchema.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: CodexInstallState,
+): { ok: true; configPath: string } | { ok: false; message: string } {
+  if (state.configRelative !== CODEX_CONFIG_REL) {
+    return {
+      ok: false,
+      message: `Invalid config relative path in install state: ${state.configRelative}`,
+    };
+  }
+
+  const configPath = resolveProfileRelativePath(
+    profileDir,
+    state.configRelative,
+  );
+  if (!configPath) {
+    return {
+      ok: false,
+      message: `Invalid config relative path in install state: ${state.configRelative}`,
+    };
+  }
+
+  for (const relativePath of Object.keys(state.files)) {
+    if (relativePath !== CODEX_CONFIG_REL) {
+      return {
+        ok: false,
+        message: `Install state path is outside config root: ${relativePath}`,
+      };
+    }
+    const abs = resolveProfileRelativePath(profileDir, relativePath);
+    if (!abs) {
+      return {
+        ok: false,
+        message: `Invalid install state path: ${relativePath}`,
+      };
+    }
+  }
+
+  return { ok: true, configPath };
+}
+
+/**
+ * Restore files tracked by codex-install-state.json for a profile.
+ */
+export async function rollbackCodexProfile(
+  options: CodexRollbackOptions,
+): Promise<CodexRollbackResult> {
+  const {
+    profile,
+    dryRun = false,
+    env = process.env,
+    homedir = osHomedir,
+  } = options;
+  const profileDir =
+    options.profileDir ?? resolveCodexProfileDir(profile, { env, homedir });
+  const statePath = join(profileDir, CODEX_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 configPath = validated.configPath;
+  const fileState = state.files[CODEX_CONFIG_REL];
+  const previous = fileState?.previous ?? null;
+
+  if (previous === null) {
+    // File was created by install; remove it on rollback.
+    const existed = await pathExists(configPath);
+    const kind: InstallChangeKind = existed ? "remove" : "unchanged";
+    changes.push({
+      path: configPath,
+      relativePath: CODEX_CONFIG_REL,
+      kind,
+      summary: changeSummary(kind, CODEX_CONFIG_REL),
+    });
+    if (!dryRun && existed) {
+      await unlink(configPath);
+    }
+  } else {
+    let current: string | null = null;
+    if (await pathExists(configPath)) {
+      current = await readFile(configPath, "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: configPath,
+      relativePath: CODEX_CONFIG_REL,
+      kind,
+      summary: changeSummary(kind, CODEX_CONFIG_REL),
+    });
+    if (!dryRun && kind !== "unchanged") {
+      await mkdir(dirname(configPath), { recursive: true });
+      await writeFile(configPath, previous, "utf8");
+    }
+  }
+
+  // Drop install state last
+  const stateChangeKind: InstallChangeKind = "remove";
+  changes.push({
+    path: statePath,
+    relativePath: CODEX_INSTALL_STATE_REL,
+    kind: stateChangeKind,
+    summary: changeSummary(stateChangeKind, CODEX_INSTALL_STATE_REL),
+  });
+  if (!dryRun) {
+    await unlink(statePath);
+    // 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 Codex 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" }]
+}