@minniexcode/codex-switch 0.0.4 → 0.0.6

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("");
+}

package/dist/storage/codex-paths.js

@@ -0,0 +1,71 @@
+"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.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) {
+    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.
+ */
+function createCodexPaths(codexDir) {
+    return {
+        codexDir,
+        configPath: path.join(codexDir, "config.toml"),
+        providersPath: path.join(codexDir, "providers.json"),
+        authPath: path.join(codexDir, "auth.json"),
+        backupsDir: path.join(codexDir, "backups"),
+        latestBackupPath: path.join(codexDir, "backups", "latest.json"),
+    };
+}

package/dist/storage/config-repo.js

@@ -0,0 +1,208 @@
+"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.requireManagedProfileRuntime = requireManagedProfileRuntime;
+exports.requireModelProviderRuntimeSection = requireModelProviderRuntimeSection;
+exports.updateTopLevelProfile = updateTopLevelProfile;
+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.
+ */
+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 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,
+        });
+    }
+    return profile;
+}
+/**
+ * Lists all named profile sections declared in config.toml.
+ */
+function listConfigProfiles(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 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 document;
+}
+/**
+ * Resolves one profile view and enforces the managed model_provider contract.
+ */
+function requireManagedProfileRuntime(document, providers, profile) {
+    const view = (0, config_1.buildManagedProfileViews)(document, providers).find((entry) => entry.name === profile);
+    if (!view) {
+        throw (0, errors_1.cliError)("PROFILE_NOT_FOUND", `Profile "${profile}" does not exist in config.toml.`, {
+            profile,
+        });
+    }
+    if (!view.modelProvider) {
+        throw (0, errors_1.cliError)("MANAGED_PROFILE_FIELDS_MISSING", `Managed profile "${profile}" requires model_provider.`, {
+            profile,
+            missingFields: ["model_provider"],
+        });
+    }
+    if (view.modelProvider !== profile) {
+        throw (0, errors_1.cliError)("INVALID_ARGUMENT", `Managed profile "${profile}" must use the same model_provider name.`, {
+            profile,
+            modelProvider: view.modelProvider,
+        });
+    }
+    const modelProviderSection = document.modelProviders.find((entry) => entry.name === view.modelProvider);
+    if (!modelProviderSection) {
+        throw (0, errors_1.cliError)("PROFILE_NOT_FOUND", `Model provider "${view.modelProvider}" does not exist in config.toml.`, {
+            profile,
+            modelProvider: view.modelProvider,
+        });
+    }
+    if (!modelProviderSection.baseUrl) {
+        throw (0, errors_1.cliError)("MANAGED_PROFILE_FIELDS_MISSING", `Model provider "${view.modelProvider}" requires base_url.`, {
+            profile,
+            modelProvider: view.modelProvider,
+            missingFields: ["base_url"],
+        });
+    }
+    return view;
+}
+/**
+ * Verifies that a same-named model_provider runtime section exists and has base_url.
+ */
+function requireModelProviderRuntimeSection(document, profile) {
+    const modelProviderSection = document.modelProviders.find((entry) => entry.name === profile);
+    if (!modelProviderSection) {
+        throw (0, errors_1.cliError)("PROFILE_NOT_FOUND", `Model provider "${profile}" does not exist in config.toml.`, {
+            profile,
+            modelProvider: profile,
+        });
+    }
+    if (!modelProviderSection.baseUrl) {
+        throw (0, errors_1.cliError)("MANAGED_PROFILE_FIELDS_MISSING", `Model provider "${profile}" requires base_url.`, {
+            profile,
+            modelProvider: profile,
+            missingFields: ["base_url"],
+        });
+    }
+}
+/**
+ * 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.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/storage/fs-utils.js

@@ -0,0 +1,97 @@
+"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.ensureDir = ensureDir;
+exports.writeTextFileAtomic = writeTextFileAtomic;
+exports.readRequiredFile = readRequiredFile;
+exports.formatDetail = formatDetail;
+exports.printErrorDetails = printErrorDetails;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const errors_1 = require("../domain/errors");
+/**
+ * Creates a directory tree when it does not already exist.
+ */
+function ensureDir(directoryPath) {
+    fs.mkdirSync(directoryPath, { recursive: true });
+}
+/**
+ * Writes a text file via a temporary sibling file and atomic rename.
+ */
+function writeTextFileAtomic(filePath, contents) {
+    ensureDir(path.dirname(filePath));
+    // Use the current process id in the temp name to reduce collision risk.
+    const tempPath = `${filePath}.tmp-${process.pid}`;
+    fs.writeFileSync(tempPath, contents, "utf8");
+    fs.renameSync(tempPath, filePath);
+}
+/**
+ * Reads a required text file and throws a typed error when it is missing.
+ */
+function readRequiredFile(filePath, code, label) {
+    if (!fs.existsSync(filePath)) {
+        throw (0, errors_1.cliError)(code, `${label} does not exist.`, { file: filePath });
+    }
+    return fs.readFileSync(filePath, "utf8");
+}
+/**
+ * Formats arbitrary error detail values for human-readable output.
+ */
+function formatDetail(value) {
+    if (Array.isArray(value)) {
+        return value.join(", ");
+    }
+    if (value && typeof value === "object") {
+        return JSON.stringify(value);
+    }
+    return String(value);
+}
+/**
+ * Renders structured error details while suppressing secret-looking API key fields.
+ */
+function printErrorDetails(error) {
+    if (!error.details) {
+        return [];
+    }
+    const lines = [];
+    for (const [key, value] of Object.entries(error.details)) {
+        if (typeof value === "string" && key.toLowerCase().includes("apikey")) {
+            // Do not leak API keys back into the terminal if one appears in error details.
+            continue;
+        }
+        lines.push(`  ${key}: ${formatDetail(value)}`);
+    }
+    return lines;
+}

package/dist/storage/lock-repo.js

@@ -0,0 +1,99 @@
+"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.withCodexLock = withCodexLock;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const errors_1 = require("../domain/errors");
+const fs_utils_1 = require("./fs-utils");
+/**
+ * Executes a mutation while holding an exclusive codex-switch lock file.
+ */
+function withCodexLock(codexDir, operation, run) {
+    (0, fs_utils_1.ensureDir)(codexDir);
+    const lockPath = path.join(codexDir, ".codex-switch.lock");
+    acquireLock(lockPath, operation);
+    try {
+        return run();
+    }
+    finally {
+        releaseLock(lockPath);
+    }
+}
+/**
+ * Acquires the lock file using exclusive create semantics.
+ */
+function acquireLock(lockPath, operation) {
+    const payload = {
+        pid: process.pid,
+        operation,
+        createdAt: new Date().toISOString(),
+    };
+    try {
+        fs.writeFileSync(lockPath, `${JSON.stringify(payload, null, 2)}\n`, { encoding: "utf8", flag: "wx" });
+    }
+    catch {
+        const existing = readLockRecord(lockPath);
+        throw (0, errors_1.cliError)("LOCK_CONFLICT", "Another codex-switch write operation is already running.", {
+            file: lockPath,
+            activeOperation: existing?.operation ?? "unknown",
+            activePid: existing?.pid ?? null,
+            activeSince: existing?.createdAt ?? null,
+            requestedOperation: operation,
+        });
+    }
+}
+/**
+ * Removes the lock file when the mutation completes.
+ */
+function releaseLock(lockPath) {
+    if (fs.existsSync(lockPath)) {
+        fs.rmSync(lockPath, { force: true });
+    }
+}
+/**
+ * Reads the current lock metadata when a lock conflict occurs.
+ */
+function readLockRecord(lockPath) {
+    if (!fs.existsSync(lockPath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(fs.readFileSync(lockPath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}