@minniexcode/codex-switch 0.0.5 → 0.0.7

package/dist/interaction/prompt.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPromptRuntime = createPromptRuntime;
+const inquirer_1 = __importDefault(require("inquirer"));
+const errors_1 = require("../domain/errors");
+/**
+ * Creates the default prompt runtime backed by inquirer on the current process TTY.
+ */
+function createPromptRuntime() {
+    return {
+        isInteractive: () => Boolean(process.stdin.isTTY && process.stdout.isTTY),
+        inputText: async (message, options) => {
+            return handlePromptCancellation(async () => {
+                const answer = await inquirer_1.default.prompt([
+                    {
+                        type: "input",
+                        name: "value",
+                        message,
+                        default: options?.defaultValue ?? undefined,
+                    },
+                ]);
+                return String(answer.value ?? "");
+            });
+        },
+        inputSecret: async (message) => {
+            return handlePromptCancellation(async () => {
+                const answer = await inquirer_1.default.prompt([
+                    {
+                        type: "password",
+                        name: "value",
+                        message,
+                        mask: "*",
+                    },
+                ]);
+                return String(answer.value ?? "");
+            });
+        },
+        selectOne: async (message, choices) => {
+            return handlePromptCancellation(async () => {
+                const answer = await inquirer_1.default.prompt([
+                    {
+                        type: "select",
+                        name: "value",
+                        message,
+                        choices: choices.map((choice) => ({
+                            value: choice.value,
+                            name: choice.hint ? `${choice.label} (${choice.hint})` : choice.label,
+                        })),
+                    },
+                ]);
+                return answer.value;
+            });
+        },
+        selectMany: async (message, choices, options) => {
+            return handlePromptCancellation(async () => {
+                const answer = await inquirer_1.default.prompt([
+                    {
+                        type: "checkbox",
+                        name: "value",
+                        message,
+                        choices: choices.map((choice) => ({
+                            value: choice.value,
+                            name: choice.hint ? `${choice.label} (${choice.hint})` : choice.label,
+                            checked: Boolean(options?.defaultValues?.includes(choice.value)),
+                        })),
+                    },
+                ]);
+                return (Array.isArray(answer.value) ? answer.value : []);
+            });
+        },
+        confirmAction: async (message, options) => {
+            return handlePromptCancellation(async () => {
+                const answer = await inquirer_1.default.prompt([
+                    {
+                        type: "confirm",
+                        name: "value",
+                        message,
+                        default: options?.defaultValue ?? false,
+                    },
+                ]);
+                return Boolean(answer.value);
+            });
+        },
+        writeLine: (message) => {
+            process.stdout.write(`${message}\n`);
+        },
+    };
+}
+async function handlePromptCancellation(run) {
+    try {
+        return await run();
+    }
+    catch (error) {
+        if (isPromptCancellation(error)) {
+            throw (0, errors_1.cliError)("PROMPT_CANCELLED", "Interactive prompt was cancelled.");
+        }
+        throw (0, errors_1.cliError)("INVALID_ARGUMENT", "Interactive prompt failed.", {
+            cause: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+function isPromptCancellation(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return error.name === "ExitPromptError" || error.message.includes("force closed");
+}

package/dist/runtime/codex-cli.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setCodexSpawnImplementation = setCodexSpawnImplementation;
+exports.resetCodexSpawnImplementation = resetCodexSpawnImplementation;
+exports.runCodexLogin = runCodexLogin;
+exports.checkCodexAvailable = checkCodexAvailable;
+exports.readCodexVersion = readCodexVersion;
+exports.checkCodexVersion = checkCodexVersion;
+const node_child_process_1 = require("node:child_process");
+const errors_1 = require("../domain/errors");
+let spawnImplementation = node_child_process_1.spawnSync;
+function getCodexInvocation(args) {
+    if (process.platform === "win32") {
+        return {
+            command: process.env.ComSpec || "cmd.exe",
+            args: ["/d", "/s", "/c", ["codex", ...args].join(" ")],
+        };
+    }
+    return {
+        command: "codex",
+        args,
+    };
+}
+/**
+ * Overrides the spawn implementation for tests.
+ */
+function setCodexSpawnImplementation(spawnLike) {
+    spawnImplementation = spawnLike;
+}
+/**
+ * Restores the default Node spawn implementation after tests.
+ */
+function resetCodexSpawnImplementation() {
+    spawnImplementation = node_child_process_1.spawnSync;
+}
+/**
+ * Runs `codex login --with-api-key` in the target Codex directory.
+ */
+function runCodexLogin(apiKey, workingDir) {
+    const invocation = getCodexInvocation(["login", "--with-api-key"]);
+    const result = spawnImplementation(invocation.command, invocation.args, {
+        cwd: workingDir,
+        input: `${apiKey}\n`,
+        stdio: "pipe",
+        encoding: "utf8",
+    });
+    if (result.error || result.status !== 0) {
+        throw (0, errors_1.cliError)("CODEX_LOGIN_FAILED", "codex login --with-api-key failed.", {
+            cause: result.error?.message ?? (result.stderr.trim() || "Unknown codex login failure"),
+        });
+    }
+}
+/**
+ * Checks whether the Codex CLI is available on PATH.
+ */
+function checkCodexAvailable() {
+    const invocation = getCodexInvocation(["--version"]);
+    const result = spawnImplementation(invocation.command, invocation.args, {
+        stdio: "pipe",
+        encoding: "utf8",
+    });
+    if (result.error || result.status !== 0) {
+        return {
+            ok: false,
+            cause: result.error?.message ?? (result.stderr.trim() || "Unknown failure"),
+        };
+    }
+    return { ok: true };
+}
+/**
+ * Reads the installed codex CLI version string.
+ */
+function readCodexVersion() {
+    const invocation = getCodexInvocation(["--version"]);
+    const result = spawnImplementation(invocation.command, invocation.args, {
+        stdio: "pipe",
+        encoding: "utf8",
+    });
+    if (result.error || result.status !== 0) {
+        return {
+            ok: false,
+            cause: result.error?.message ?? (result.stderr.trim() || "Unknown failure"),
+        };
+    }
+    const raw = `${result.stdout ?? ""} ${result.stderr ?? ""}`.trim();
+    const match = raw.match(/(\d+\.\d+\.\d+)/);
+    if (!match) {
+        return {
+            ok: false,
+            cause: `Unable to parse codex version from output: ${raw || "(empty output)"}`,
+        };
+    }
+    return { ok: true, version: match[1] };
+}
+/**
+ * Compares the installed codex version against a minimum required version.
+ */
+function checkCodexVersion(minVersion) {
+    const current = readCodexVersion();
+    if (!current.ok) {
+        return {
+            ok: false,
+            cause: current.cause,
+        };
+    }
+    if (compareVersions(current.version, minVersion) < 0) {
+        return {
+            ok: false,
+            currentVersion: current.version,
+            cause: `codex ${current.version} is below required ${minVersion}`,
+        };
+    }
+    return {
+        ok: true,
+        currentVersion: current.version,
+    };
+}
+function compareVersions(left, right) {
+    const leftParts = left.split(".").map((value) => Number.parseInt(value, 10));
+    const rightParts = right.split(".").map((value) => Number.parseInt(value, 10));
+    const length = Math.max(leftParts.length, rightParts.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftValue = leftParts[index] ?? 0;
+        const rightValue = rightParts[index] ?? 0;
+        if (leftValue !== rightValue) {
+            return leftValue - rightValue;
+        }
+    }
+    return 0;
+}

package/dist/runtime/codex-probe.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codexRuntimeProbe = void 0;
+exports.probeCodexRuntime = probeCodexRuntime;
+const codex_cli_1 = require("./codex-cli");
+/**
+ * Default dependency probe implementation for the local codex CLI runtime.
+ */
+exports.codexRuntimeProbe = {
+    probe(options) {
+        if (options?.minVersion) {
+            return probeCodexRuntime(options.minVersion);
+        }
+        return probeCodexRuntime();
+    },
+};
+/**
+ * Checks whether the codex CLI is installed and, optionally, satisfies a minimum version.
+ */
+function probeCodexRuntime(minVersion) {
+    const availability = (0, codex_cli_1.checkCodexAvailable)();
+    if (!availability.ok) {
+        return {
+            ok: false,
+            runtime: "codex",
+            reason: "missing",
+            cause: availability.cause ?? "Unknown codex availability failure",
+        };
+    }
+    const versionInfo = (0, codex_cli_1.readCodexVersion)();
+    if (!versionInfo.ok) {
+        return {
+            ok: false,
+            runtime: "codex",
+            reason: "failed",
+            cause: versionInfo.cause,
+        };
+    }
+    if (minVersion) {
+        // Reuse the dedicated semver check so doctor and setup report the same unsupported-version behavior.
+        const versionCheck = (0, codex_cli_1.checkCodexVersion)(minVersion);
+        if (!versionCheck.ok) {
+            return {
+                ok: false,
+                runtime: "codex",
+                reason: "unsupported",
+                cause: versionCheck.cause ?? `codex ${versionInfo.version} is below required ${minVersion}`,
+                version: versionCheck.currentVersion,
+            };
+        }
+    }
+    return {
+        ok: true,
+        runtime: "codex",
+        version: versionInfo.version,
+    };
+}

package/dist/runtime/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/storage/auth-repo.js

@@ -0,0 +1,160 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readAuthFileIfExists = readAuthFileIfExists;
+exports.buildManagedAuthPayload = buildManagedAuthPayload;
+exports.buildManagedAuthJson = buildManagedAuthJson;
+exports.writeAuthFile = writeAuthFile;
+exports.extractManagedAuthFingerprint = extractManagedAuthFingerprint;
+exports.readManagedAuthState = readManagedAuthState;
+const fs = __importStar(require("node:fs"));
+const errors_1 = require("../domain/errors");
+const fs_utils_1 = require("./fs-utils");
+const LEGACY_MANAGED_SECRET_KEYS = new Set(["api_key"]);
+/**
+ * Reads auth.json when it exists and returns null otherwise.
+ */
+function readAuthFileIfExists(authPath) {
+    if (!fs.existsSync(authPath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(fs.readFileSync(authPath, "utf8"));
+    }
+    catch (error) {
+        throw (0, errors_1.cliError)("AUTH_JSON_INVALID", "Failed to parse auth.json.", {
+            file: authPath,
+            cause: (0, errors_1.normalizeError)(error).message,
+        });
+    }
+}
+/**
+ * Builds the stable managed auth payload for one provider.
+ */
+function buildManagedAuthPayload(provider) {
+    return {
+        auth_mode: "apikey",
+        [provider.envKey]: provider.apiKey,
+    };
+}
+/**
+ * Builds the next auth.json object while preserving unmanaged metadata.
+ */
+function buildManagedAuthJson(provider, existingAuthJson) {
+    const nextManaged = buildManagedAuthPayload(provider);
+    const result = {};
+    if (existingAuthJson && typeof existingAuthJson === "object" && !Array.isArray(existingAuthJson)) {
+        for (const [key, value] of Object.entries(existingAuthJson)) {
+            if (key === "auth_mode" || LEGACY_MANAGED_SECRET_KEYS.has(key) || looksLikeManagedSecretKey(key)) {
+                continue;
+            }
+            result[key] = value;
+        }
+    }
+    result.auth_mode = nextManaged.auth_mode;
+    result[provider.envKey] = provider.apiKey;
+    return result;
+}
+/**
+ * Writes auth.json atomically using the managed mirror strategy.
+ */
+function writeAuthFile(authPath, provider, existingAuthJson) {
+    (0, fs_utils_1.writeTextFileAtomic)(authPath, `${JSON.stringify(buildManagedAuthJson(provider, existingAuthJson), null, 2)}\n`);
+}
+/**
+ * Extracts a lightweight fingerprint used by doctor/status.
+ */
+function extractManagedAuthFingerprint(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+        return {
+            authMode: null,
+            managedSecretKeys: [],
+            payload: null,
+        };
+    }
+    const payload = input;
+    const authMode = typeof payload.auth_mode === "string" ? payload.auth_mode : null;
+    const managedSecretKeys = Object.keys(payload)
+        .filter((key) => key !== "auth_mode" && looksLikeManagedSecretKey(key))
+        .sort();
+    return {
+        authMode,
+        managedSecretKeys,
+        payload,
+    };
+}
+/**
+ * Reads auth.json into a doctor-friendly managed state summary.
+ */
+function readManagedAuthState(authPath) {
+    if (!fs.existsSync(authPath)) {
+        return {
+            exists: false,
+            valid: false,
+            parseError: null,
+            authMode: null,
+            managedSecretKeys: [],
+            payload: null,
+        };
+    }
+    try {
+        const payload = readAuthFileIfExists(authPath);
+        const fingerprint = extractManagedAuthFingerprint(payload);
+        return {
+            exists: true,
+            valid: Boolean(fingerprint.payload),
+            parseError: null,
+            authMode: fingerprint.authMode,
+            managedSecretKeys: fingerprint.managedSecretKeys,
+            payload: fingerprint.payload,
+        };
+    }
+    catch (error) {
+        return {
+            exists: true,
+            valid: false,
+            parseError: (0, errors_1.normalizeError)(error).message,
+            authMode: null,
+            managedSecretKeys: [],
+            payload: null,
+        };
+    }
+}
+function looksLikeManagedSecretKey(key) {
+    if (LEGACY_MANAGED_SECRET_KEYS.has(key)) {
+        return true;
+    }
+    return /^[A-Z0-9_]+$/.test(key);
+}

package/dist/storage/backup-repo.js

@@ -0,0 +1,210 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBackup = createBackup;
+exports.restoreManifest = restoreManifest;
+exports.saveLatestManifest = saveLatestManifest;
+exports.loadLatestManifest = loadLatestManifest;
+exports.loadManifestById = loadManifestById;
+exports.listBackups = listBackups;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const backups_1 = require("../domain/backups");
+const errors_1 = require("../domain/errors");
+const fs_utils_1 = require("./fs-utils");
+/**
+ * Creates a point-in-time backup for the managed files involved in a mutation.
+ */
+function createBackup(codexDir, backupsDir, reason, files) {
+    try {
+        const backupDir = path.join(backupsDir, `${createTimestamp()}-${reason}`);
+        (0, fs_utils_1.ensureDir)(backupsDir);
+        (0, fs_utils_1.ensureDir)(backupDir);
+        const entries = [];
+        for (const file of files) {
+            const exists = fs.existsSync(file.absolutePath);
+            const backupFileName = exists ? file.relativePath.replace(/[\\/]/g, "__") : null;
+            if (exists && backupFileName) {
+                // Flatten relative paths into a single filename inside the backup directory.
+                fs.copyFileSync(file.absolutePath, path.join(backupDir, backupFileName));
+            }
+            entries.push({
+                relativePath: file.relativePath,
+                existed: exists,
+                backupFileName,
+            });
+        }
+        const manifest = {
+            version: 1,
+            createdAt: new Date().toISOString(),
+            reason,
+            rootDir: codexDir,
+            backupDir,
+            files: entries,
+        };
+        (0, fs_utils_1.writeTextFileAtomic)(path.join(backupDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`);
+        return manifest;
+    }
+    catch (error) {
+        throw (0, errors_1.cliError)("BACKUP_FAILED", "Failed to create backup.", {
+            cause: (0, errors_1.normalizeError)(error).message,
+        });
+    }
+}
+/**
+ * Restores all files described by a backup manifest back into the Codex directory.
+ */
+function restoreManifest(manifest) {
+    for (const entry of manifest.files) {
+        const targetPath = path.join(manifest.rootDir, entry.relativePath);
+        if (!entry.existed) {
+            if (fs.existsSync(targetPath)) {
+                // Remove files that were created by the failed mutation but were absent before it.
+                fs.rmSync(targetPath, { force: true });
+            }
+            continue;
+        }
+        if (!entry.backupFileName) {
+            throw new Error(`Backup file for ${entry.relativePath} is missing from manifest.`);
+        }
+        const sourcePath = path.join(manifest.backupDir, entry.backupFileName);
+        if (!fs.existsSync(sourcePath)) {
+            throw new Error(`Backup file not found: ${sourcePath}`);
+        }
+        (0, fs_utils_1.ensureDir)(path.dirname(targetPath));
+        fs.copyFileSync(sourcePath, targetPath);
+    }
+}
+/**
+ * Persists the latest successful backup manifest for manual rollback.
+ */
+function saveLatestManifest(latestBackupPath, manifest) {
+    (0, fs_utils_1.writeTextFileAtomic)(latestBackupPath, `${JSON.stringify(manifest, null, 2)}\n`);
+}
+/**
+ * Loads and validates the latest rollback manifest file.
+ */
+function loadLatestManifest(latestBackupPath) {
+    if (!fs.existsSync(latestBackupPath)) {
+        throw (0, errors_1.cliError)("BACKUP_NOT_FOUND", "No rollback backup is available.", {
+            file: latestBackupPath,
+        });
+    }
+    try {
+        return (0, backups_1.validateBackupManifest)(JSON.parse(fs.readFileSync(latestBackupPath, "utf8")));
+    }
+    catch (error) {
+        throw (0, errors_1.cliError)("ROLLBACK_FAILED", "Failed to read latest backup manifest.", {
+            file: latestBackupPath,
+            cause: (0, errors_1.normalizeError)(error).message,
+        });
+    }
+}
+/**
+ * Loads a backup manifest by its explicit backup id.
+ */
+function loadManifestById(backupsDir, backupId) {
+    const manifestPath = path.join(backupsDir, backupId, "manifest.json");
+    if (!fs.existsSync(manifestPath)) {
+        throw (0, errors_1.cliError)("BACKUP_NOT_FOUND", `Backup "${backupId}" was not found.`, {
+            backupId,
+            file: manifestPath,
+        });
+    }
+    try {
+        return (0, backups_1.validateBackupManifest)(JSON.parse(fs.readFileSync(manifestPath, "utf8")));
+    }
+    catch (error) {
+        throw (0, errors_1.cliError)("ROLLBACK_FAILED", `Failed to read backup manifest "${backupId}".`, {
+            backupId,
+            file: manifestPath,
+            cause: (0, errors_1.normalizeError)(error).message,
+        });
+    }
+}
+/**
+ * Lists valid backup manifests under backups/, newest first, while skipping corrupt entries with warnings.
+ */
+function listBackups(backupsDir) {
+    if (!fs.existsSync(backupsDir)) {
+        throw (0, errors_1.cliError)("BACKUP_NOT_FOUND", "No backups directory exists.", {
+            directory: backupsDir,
+        });
+    }
+    const entries = fs.readdirSync(backupsDir, { withFileTypes: true });
+    const backups = [];
+    const warnings = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name === "latest.json") {
+            continue;
+        }
+        const manifestPath = path.join(backupsDir, entry.name, "manifest.json");
+        if (!fs.existsSync(manifestPath)) {
+            warnings.push(`Skipped backup "${entry.name}" because manifest.json is missing.`);
+            continue;
+        }
+        try {
+            backups.push((0, backups_1.toBackupListItem)((0, backups_1.validateBackupManifest)(JSON.parse(fs.readFileSync(manifestPath, "utf8")))));
+        }
+        catch (error) {
+            warnings.push(`Skipped backup "${entry.name}" because manifest.json is invalid: ${(0, errors_1.normalizeError)(error).message}`);
+        }
+    }
+    if (backups.length === 0) {
+        throw (0, errors_1.cliError)("BACKUP_NOT_FOUND", "No valid backups were found.", {
+            directory: backupsDir,
+        });
+    }
+    return {
+        backups: (0, backups_1.sortBackupList)(backups),
+        warnings,
+    };
+}
+/**
+ * Formats a filesystem-safe timestamp for backup directory names.
+ */
+function createTimestamp() {
+    const now = new Date();
+    const pad = (value) => value.toString().padStart(2, "0");
+    return [
+        now.getFullYear().toString(),
+        pad(now.getMonth() + 1),
+        pad(now.getDate()),
+        "-",
+        pad(now.getHours()),
+        pad(now.getMinutes()),
+        pad(now.getSeconds()),
+    ].join("");
+}