@minniexcode/codex-switch 0.0.3 → 0.0.5

package/dist/infra/backup-repo.js

@@ -37,8 +37,11 @@ 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");
 /**
@@ -115,16 +118,12 @@ function saveLatestManifest(latestBackupPath, manifest) {
  */
 function loadLatestManifest(latestBackupPath) {
     if (!fs.existsSync(latestBackupPath)) {
-        throw (0, errors_1.cliError)("ROLLBACK_FAILED", "No rollback backup is available.", {
+        throw (0, errors_1.cliError)("BACKUP_NOT_FOUND", "No rollback backup is available.", {
             file: latestBackupPath,
         });
     }
     try {
-        const manifest = JSON.parse(fs.readFileSync(latestBackupPath, "utf8"));
-        if (!manifest || typeof manifest !== "object" || !Array.isArray(manifest.files)) {
-            throw new Error("Invalid latest backup manifest.");
-        }
-        return manifest;
+        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.", {
@@ -133,6 +132,66 @@ function loadLatestManifest(latestBackupPath) {
         });
     }
 }
+/**
+ * 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.
  */

package/dist/infra/codex-cli.js

@@ -4,9 +4,23 @@ 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.
  */
@@ -23,7 +37,8 @@ function resetCodexSpawnImplementation() {
  * Runs `codex login --with-api-key` in the target Codex directory.
  */
 function runCodexLogin(apiKey, workingDir) {
-    const result = spawnImplementation("codex", ["login", "--with-api-key"], {
+    const invocation = getCodexInvocation(["login", "--with-api-key"]);
+    const result = spawnImplementation(invocation.command, invocation.args, {
         cwd: workingDir,
         input: `${apiKey}\n`,
         stdio: "pipe",
@@ -39,7 +54,8 @@ function runCodexLogin(apiKey, workingDir) {
  * Checks whether the Codex CLI is available on PATH.
  */
 function checkCodexAvailable() {
-    const result = spawnImplementation("codex", ["--version"], {
+    const invocation = getCodexInvocation(["--version"]);
+    const result = spawnImplementation(invocation.command, invocation.args, {
         stdio: "pipe",
         encoding: "utf8",
     });
@@ -51,3 +67,64 @@ function checkCodexAvailable() {
     }
     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/infra/codex-discovery.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findCodexDirCandidates = findCodexDirCandidates;
+const config_repo_1 = require("./config-repo");
+/**
+ * Finds candidate Codex home directories using the shared config-aware discovery rules.
+ */
+function findCodexDirCandidates(explicitCodexDir) {
+    return (0, config_repo_1.findCodexDirCandidates)(explicitCodexDir);
+}

package/dist/infra/codex-paths.js

@@ -33,15 +33,28 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CODEX_DIR_ENV_NAME = void 0;
 exports.resolveCodexDir = resolveCodexDir;
 exports.createCodexPaths = createCodexPaths;
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
+exports.CODEX_DIR_ENV_NAME = "CODEXS_CODEX_DIR";
+const DEVELOPMENT_DEFAULT_CODEX_DIR = path.resolve(process.cwd(), "dev-codex", "local-sandbox");
 /**
  * Resolves the working Codex directory, defaulting to `~/.codex`.
  */
 function resolveCodexDir(codexDir) {
-    return codexDir ? path.resolve(codexDir) : path.join(os.homedir(), ".codex");
+    if (codexDir) {
+        return path.resolve(codexDir);
+    }
+    const envCodexDir = process.env[exports.CODEX_DIR_ENV_NAME];
+    if (envCodexDir) {
+        return path.resolve(envCodexDir);
+    }
+    if (process.env.NODE_ENV === "development") {
+        return DEVELOPMENT_DEFAULT_CODEX_DIR;
+    }
+    return path.join(os.homedir(), ".codex");
 }
 /**
  * Expands a Codex home directory into the file paths used by the CLI.

package/dist/infra/config-repo.js

@@ -1,12 +1,53 @@
 "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.readConfigFile = readConfigFile;
+exports.readStructuredConfig = readStructuredConfig;
 exports.readCurrentProfile = readCurrentProfile;
 exports.listConfigProfiles = listConfigProfiles;
 exports.ensureProfileExists = ensureProfileExists;
 exports.updateTopLevelProfile = updateTopLevelProfile;
-const errors_1 = require("../domain/errors");
+exports.createConfigMutationPlan = createConfigMutationPlan;
+exports.applyConfigMutation = applyConfigMutation;
+exports.findCodexDirCandidates = findCodexDirCandidates;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
 const config_1 = require("../domain/config");
+const errors_1 = require("../domain/errors");
+const codex_paths_1 = require("./codex-paths");
 const fs_utils_1 = require("./fs-utils");
 /**
  * Reads config.toml and throws a typed error when the file is missing.
@@ -14,12 +55,26 @@ const fs_utils_1 = require("./fs-utils");
 function readConfigFile(configPath) {
     return (0, fs_utils_1.readRequiredFile)(configPath, "CONFIG_NOT_FOUND", "config.toml");
 }
+/**
+ * Reads and parses config.toml into the managed structured document shape.
+ */
+function readStructuredConfig(configPath) {
+    const content = readConfigFile(configPath);
+    try {
+        return (0, config_1.parseStructuredConfig)(content);
+    }
+    catch (error) {
+        throw (0, errors_1.cliError)("CONFIG_PARSE_ERROR", "Failed to parse config.toml.", {
+            file: configPath,
+            cause: (0, errors_1.normalizeError)(error).message,
+        });
+    }
+}
 /**
  * Reads the active top-level profile from config.toml.
  */
 function readCurrentProfile(configPath) {
-    const content = readConfigFile(configPath);
-    const profile = (0, config_1.parseTopLevelProfile)(content);
+    const profile = readStructuredConfig(configPath).activeProfile ?? (0, config_1.parseTopLevelProfile)(readConfigFile(configPath));
     if (!profile) {
         throw (0, errors_1.cliError)("PROFILE_NOT_FOUND", "No top-level profile is set in config.toml.", {
             file: configPath,
@@ -31,26 +86,64 @@ function readCurrentProfile(configPath) {
  * Lists all named profile sections declared in config.toml.
  */
 function listConfigProfiles(configPath) {
-    return (0, config_1.parseProfileNames)(readConfigFile(configPath));
+    return new Set(readStructuredConfig(configPath).profiles.map((profile) => profile.name));
 }
 /**
  * Verifies that a provider's target profile exists before a switch operation proceeds.
  */
 function ensureProfileExists(configPath, profile, provider) {
-    const configContent = readConfigFile(configPath);
-    const profiles = (0, config_1.parseProfileNames)(configContent);
-    if (!profiles.has(profile)) {
+    const document = readStructuredConfig(configPath);
+    if (!document.profiles.some((entry) => entry.name === profile)) {
         throw (0, errors_1.cliError)("PROFILE_NOT_FOUND", `Profile "${profile}" does not exist in config.toml.`, {
             file: configPath,
             provider,
             profile,
         });
     }
-    return configContent;
+    return document;
 }
 /**
  * Rewrites config.toml so the requested profile becomes the active top-level profile.
  */
 function updateTopLevelProfile(configPath, configContent, profile) {
-    (0, fs_utils_1.writeTextFileAtomic)(configPath, (0, config_1.replaceTopLevelProfile)(configContent, profile));
+    (0, fs_utils_1.writeTextFileAtomic)(configPath, (0, config_1.applyPatchOperations)(configContent, (0, config_1.planConfigMutation)((0, config_1.parseStructuredConfig)(configContent), {
+        setActiveProfile: profile,
+    }).operations));
+}
+/**
+ * Exposes the config mutation planner to application services.
+ */
+function createConfigMutationPlan(document, args) {
+    return (0, config_1.planConfigMutation)(document, args);
+}
+/**
+ * Applies a previously generated mutation plan to config.toml in one write.
+ */
+function applyConfigMutation(configPath, document, plan) {
+    (0, fs_utils_1.writeTextFileAtomic)(configPath, (0, config_1.applyPatchOperations)(document.rawText, plan.operations));
+}
+/**
+ * Finds candidate Codex directories in a stable, non-recursive order.
+ */
+function findCodexDirCandidates(explicitCodexDir) {
+    if (explicitCodexDir) {
+        return [(0, codex_paths_1.resolveCodexDir)(explicitCodexDir)];
+    }
+    const candidates = new Set();
+    const ordered = [];
+    const envCandidate = process.env[codex_paths_1.CODEX_DIR_ENV_NAME];
+    if (envCandidate) {
+        ordered.push((0, codex_paths_1.resolveCodexDir)(envCandidate));
+    }
+    if (process.env.NODE_ENV === "development") {
+        ordered.push(path.resolve(process.cwd(), "dev-codex", "local-sandbox"));
+    }
+    ordered.push(path.join(os.homedir(), ".codex"));
+    for (const candidate of ordered) {
+        if (!candidate || candidates.has(candidate) || !fs.existsSync(candidate)) {
+            continue;
+        }
+        candidates.add(candidate);
+    }
+    return [...candidates];
 }

package/dist/infra/providers-repo.js

@@ -36,6 +36,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.readProvidersFile = readProvidersFile;
 exports.readProvidersFileIfExists = readProvidersFileIfExists;
 exports.writeProvidersFile = writeProvidersFile;
+exports.readProviderRecord = readProviderRecord;
+exports.mergeProviders = mergeProviders;
 const fs = __importStar(require("node:fs"));
 const errors_1 = require("../domain/errors");
 const providers_1 = require("../domain/providers");
@@ -67,3 +69,30 @@ function readProvidersFileIfExists(providersPath) {
 function writeProvidersFile(providersPath, providers) {
     (0, fs_utils_1.writeTextFileAtomic)(providersPath, `${JSON.stringify((0, providers_1.sortProviders)(providers), null, 2)}\n`);
 }
+/**
+ * Returns a single provider record or throws a typed not-found error.
+ */
+function readProviderRecord(providersPath, providerName) {
+    const providers = readProvidersFile(providersPath);
+    const record = providers.providers[providerName];
+    if (!record) {
+        throw (0, errors_1.cliError)("PROVIDER_NOT_FOUND", `Provider "${providerName}" was not found.`, {
+            provider: providerName,
+            file: providersPath,
+        });
+    }
+    return record;
+}
+/**
+ * Merges imported providers into the current registry, preferring the imported side on conflicts.
+ */
+function mergeProviders(current, imported) {
+    const providers = {};
+    for (const [name, record] of Object.entries(current.providers)) {
+        providers[name] = (0, providers_1.cleanProviderRecord)(record);
+    }
+    for (const [name, record] of Object.entries(imported.providers)) {
+        providers[name] = (0, providers_1.cleanProviderRecord)(record);
+    }
+    return (0, providers_1.sortProviders)({ providers });
+}