@minniexcode/codex-switch 0.0.10 → 0.0.11

package/dist/runtime/copilot-installer.js

@@ -40,10 +40,10 @@ exports.getCopilotSdkPackageName = getCopilotSdkPackageName;
 exports.probeCopilotSdkInstall = probeCopilotSdkInstall;
 exports.installCopilotSdk = installCopilotSdk;
 const fs = __importStar(require("node:fs"));
-const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const node_child_process_1 = require("node:child_process");
 const errors_1 = require("../domain/errors");
+const codex_paths_1 = require("../storage/codex-paths");
 const COPILOT_SDK_PACKAGE = "@github/copilot-sdk";
 const COPILOT_SDK_VERSION = "latest";
 let spawnImplementation = node_child_process_1.spawnSync;
@@ -60,14 +60,15 @@ function resetCopilotInstallerSpawnImplementation() {
     spawnImplementation = node_child_process_1.spawnSync;
 }
 /**
- * Returns the user-level runtime directory used to lazily install the Copilot SDK.
+ * Returns the tool-home runtime directory used to lazily install the Copilot SDK.
  */
-function getCopilotRuntimeInstallDir() {
+function getCopilotRuntimeInstallDir(runtimesDir) {
     const override = process.env.CODEX_SWITCH_COPILOT_RUNTIME_DIR;
     if (override && override.trim() !== "") {
         return path.resolve(override);
     }
-    return path.join(os.homedir(), ".codex-switch", "runtimes", "copilot");
+    const baseRuntimesDir = runtimesDir ? path.resolve(runtimesDir) : path.join((0, codex_paths_1.resolveCodexSwitchHome)(), "runtimes");
+    return path.join(baseRuntimesDir, "copilot");
 }
 /**
  * Returns the package name used by the Copilot runtime installer.
@@ -78,8 +79,8 @@ function getCopilotSdkPackageName() {
 /**
  * Reports whether the optional Copilot SDK runtime is currently installed.
  */
-function probeCopilotSdkInstall() {
-    const installDir = getCopilotRuntimeInstallDir();
+function probeCopilotSdkInstall(runtimesDir) {
+    const installDir = getCopilotRuntimeInstallDir(runtimesDir);
     const packageJsonPath = path.join(installDir, "node_modules", "@github", "copilot-sdk", "package.json");
     if (!fs.existsSync(packageJsonPath)) {
         return {
@@ -100,8 +101,8 @@ function probeCopilotSdkInstall() {
 /**
  * Installs the optional Copilot SDK into the user-level runtime directory.
  */
-function installCopilotSdk() {
-    const installDir = getCopilotRuntimeInstallDir();
+function installCopilotSdk(runtimesDir) {
+    const installDir = getCopilotRuntimeInstallDir(runtimesDir);
     fs.mkdirSync(installDir, { recursive: true });
     const packageJsonPath = path.join(installDir, "package.json");
     if (!fs.existsSync(packageJsonPath)) {
@@ -133,7 +134,7 @@ function installCopilotSdk() {
             args: installCommand.args,
         });
     }
-    return probeCopilotSdkInstall();
+    return probeCopilotSdkInstall(runtimesDir);
 }
 /**
  * Resolves a stable npm install invocation for the optional Copilot SDK runtime.

package/dist/runtime/copilot-sdk-loader.js

@@ -41,19 +41,19 @@ const copilot_installer_1 = require("./copilot-installer");
 /**
  * Dynamically resolves the lazily installed Copilot SDK entrypoint.
  */
-function getCopilotSdkEntrypoint() {
-    return path.join((0, copilot_installer_1.getCopilotRuntimeInstallDir)(), "node_modules", "@github", "copilot-sdk");
+function getCopilotSdkEntrypoint(runtimesDir) {
+    return path.join((0, copilot_installer_1.getCopilotRuntimeInstallDir)(runtimesDir), "node_modules", "@github", "copilot-sdk");
 }
 /**
  * Loads the Copilot SDK only when a Copilot runtime path is exercised.
  */
-async function loadCopilotSdk() {
-    const status = (0, copilot_installer_1.probeCopilotSdkInstall)();
+async function loadCopilotSdk(runtimesDir) {
+    const status = (0, copilot_installer_1.probeCopilotSdkInstall)(runtimesDir);
     if (!status.installed) {
         throw (0, errors_1.cliError)("COPILOT_SDK_MISSING", "The optional Copilot SDK runtime is not installed.", {
             installDir: status.installDir,
             packageName: status.packageName,
         });
     }
-    return Promise.resolve(`${getCopilotSdkEntrypoint()}`).then(s => __importStar(require(s)));
+    return Promise.resolve(`${getCopilotSdkEntrypoint(runtimesDir)}`).then(s => __importStar(require(s)));
 }

package/dist/storage/backup-repo.js

@@ -47,7 +47,7 @@ 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) {
+function createBackup(backupsDir, reason, files) {
     try {
         const backupDir = path.join(backupsDir, `${createTimestamp()}-${reason}`);
         (0, fs_utils_1.ensureDir)(backupsDir);
@@ -62,6 +62,7 @@ function createBackup(codexDir, backupsDir, reason, files) {
             }
             entries.push({
                 relativePath: file.relativePath,
+                restorePath: file.absolutePath,
                 existed: exists,
                 backupFileName,
             });
@@ -70,7 +71,6 @@ function createBackup(codexDir, backupsDir, reason, files) {
             version: 1,
             createdAt: new Date().toISOString(),
             reason,
-            rootDir: codexDir,
             backupDir,
             files: entries,
         };
@@ -84,11 +84,11 @@ function createBackup(codexDir, backupsDir, reason, files) {
     }
 }
 /**
- * Restores all files described by a backup manifest back into the Codex directory.
+ * Restores all files described by a backup manifest back into their original paths.
  */
 function restoreManifest(manifest) {
     for (const entry of manifest.files) {
-        const targetPath = path.join(manifest.rootDir, entry.relativePath);
+        const targetPath = entry.restorePath;
         if (!entry.existed) {
             if (fs.existsSync(targetPath)) {
                 // Remove files that were created by the failed mutation but were absent before it.

package/dist/storage/codex-paths.js

@@ -33,17 +33,32 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CODEX_DIR_ENV_NAME = void 0;
+exports.TOOL_HOME_ENV_NAME = exports.CODEX_DIR_ENV_NAME = void 0;
+exports.resolveCodexSwitchHome = resolveCodexSwitchHome;
 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";
+exports.TOOL_HOME_ENV_NAME = "CODEXS_HOME";
 const DEVELOPMENT_DEFAULT_CODEX_DIR = path.resolve(process.cwd(), "dev-codex", "local-sandbox");
 /**
- * Resolves the working Codex directory, defaulting to `~/.codex`.
+ * Resolves the tool home directory, defaulting to `~/.config/codex-switch`.
  */
-function resolveCodexDir(codexDir) {
+function resolveCodexSwitchHome(toolHomeDir) {
+    if (toolHomeDir) {
+        return path.resolve(toolHomeDir);
+    }
+    const envToolHome = process.env[exports.TOOL_HOME_ENV_NAME];
+    if (envToolHome) {
+        return path.resolve(envToolHome);
+    }
+    return path.join(os.homedir(), ".config", "codex-switch");
+}
+/**
+ * Resolves the working Codex directory using the documented precedence order.
+ */
+function resolveCodexDir(codexDir, toolConfig) {
     if (codexDir) {
         return path.resolve(codexDir);
     }
@@ -51,21 +66,32 @@ function resolveCodexDir(codexDir) {
     if (envCodexDir) {
         return path.resolve(envCodexDir);
     }
+    if (toolConfig?.defaultCodexDir) {
+        return path.resolve(toolConfig.defaultCodexDir);
+    }
     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.
+ * Expands the tool home and Codex runtime into the file paths used by the CLI.
  */
-function createCodexPaths(codexDir) {
+function createCodexPaths(args) {
+    const input = typeof args === "string" ? { codexDir: args } : args;
+    const toolHomeDir = resolveCodexSwitchHome(input.toolHomeDir);
+    const codexDir = path.resolve(input.codexDir);
     return {
+        toolHomeDir,
+        toolConfigPath: path.join(toolHomeDir, "codex-switch.json"),
+        providersPath: path.join(toolHomeDir, "providers.json"),
+        backupsDir: path.join(toolHomeDir, "backups"),
+        latestBackupPath: path.join(toolHomeDir, "backups", "latest.json"),
+        lockPath: path.join(toolHomeDir, ".codex-switch.lock"),
+        runtimeDir: path.join(toolHomeDir, "runtime"),
+        runtimesDir: path.join(toolHomeDir, "runtimes"),
         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/lock-repo.js

@@ -35,15 +35,13 @@ var __importStar = (this && this.__importStar) || (function () {
 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");
+function withCodexLock(lockPath, operation, run) {
+    (0, fs_utils_1.ensureDir)(require("node:path").dirname(lockPath));
     acquireLock(lockPath, operation);
     try {
         return run();

package/dist/storage/runtime-state-repo.js

@@ -39,25 +39,26 @@ exports.inspectCopilotBridgeState = inspectCopilotBridgeState;
 exports.writeCopilotBridgeState = writeCopilotBridgeState;
 exports.clearCopilotBridgeState = clearCopilotBridgeState;
 const fs = __importStar(require("node:fs"));
-const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const errors_1 = require("../domain/errors");
+const codex_paths_1 = require("./codex-paths");
 const fs_utils_1 = require("./fs-utils");
 /**
- * Returns the user-level runtime state file used by Copilot bridge helpers.
+ * Returns the tool-home runtime state file used by Copilot bridge helpers.
  */
-function getCopilotBridgeStatePath() {
+function getCopilotBridgeStatePath(runtimeDir) {
     const override = process.env.CODEX_SWITCH_RUNTIME_STATE_DIR;
     if (override && override.trim() !== "") {
         return path.join(path.resolve(override), "copilot-bridge-state.json");
     }
-    return path.join(os.homedir(), ".codex-switch", "runtime", "copilot-bridge-state.json");
+    const baseRuntimeDir = runtimeDir ? path.resolve(runtimeDir) : path.join((0, codex_paths_1.resolveCodexSwitchHome)(), "runtime");
+    return path.join(baseRuntimeDir, "copilot-bridge-state.json");
 }
 /**
  * Reads the Copilot bridge state manifest when present.
  */
-function readCopilotBridgeState() {
-    const statePath = getCopilotBridgeStatePath();
+function readCopilotBridgeState(runtimeDir) {
+    const statePath = getCopilotBridgeStatePath(runtimeDir);
     if (!fs.existsSync(statePath)) {
         return null;
     }
@@ -66,8 +67,8 @@ function readCopilotBridgeState() {
 /**
  * Safely inspects the runtime-state file for status/doctor style read paths.
  */
-function inspectCopilotBridgeState() {
-    const statePath = getCopilotBridgeStatePath();
+function inspectCopilotBridgeState(runtimeDir) {
+    const statePath = getCopilotBridgeStatePath(runtimeDir);
     if (!fs.existsSync(statePath)) {
         return {
             exists: false,
@@ -81,7 +82,7 @@ function inspectCopilotBridgeState() {
             exists: true,
             valid: true,
             parseError: null,
-            state: readCopilotBridgeState(),
+            state: readCopilotBridgeState(runtimeDir),
         };
     }
     catch (error) {
@@ -96,16 +97,16 @@ function inspectCopilotBridgeState() {
 /**
  * Persists the Copilot bridge state manifest.
  */
-function writeCopilotBridgeState(state) {
-    const statePath = getCopilotBridgeStatePath();
+function writeCopilotBridgeState(state, runtimeDir) {
+    const statePath = getCopilotBridgeStatePath(runtimeDir);
     (0, fs_utils_1.ensureDir)(path.dirname(statePath));
     (0, fs_utils_1.writeTextFileAtomic)(statePath, `${JSON.stringify(state, null, 2)}\n`);
 }
 /**
  * Deletes the Copilot bridge state manifest when present.
  */
-function clearCopilotBridgeState() {
-    const statePath = getCopilotBridgeStatePath();
+function clearCopilotBridgeState(runtimeDir) {
+    const statePath = getCopilotBridgeStatePath(runtimeDir);
     if (fs.existsSync(statePath)) {
         fs.rmSync(statePath, { force: true });
     }

package/dist/storage/tool-config-repo.js

@@ -0,0 +1,111 @@
+"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.readToolConfigIfExists = readToolConfigIfExists;
+exports.ensureToolConfig = ensureToolConfig;
+exports.writeToolConfig = writeToolConfig;
+const fs = __importStar(require("node:fs"));
+const errors_1 = require("../domain/errors");
+const fs_utils_1 = require("./fs-utils");
+/**
+ * Reads the optional tool-level codex-switch config file when present.
+ */
+function readToolConfigIfExists(toolConfigPath) {
+    if (!fs.existsSync(toolConfigPath)) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(fs.readFileSync(toolConfigPath, "utf8"));
+        return validateToolConfig(parsed, toolConfigPath);
+    }
+    catch (error) {
+        throw (0, errors_1.cliError)("INVALID_CONFIG", "codex-switch.json is invalid.", {
+            file: toolConfigPath,
+            cause: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+/**
+ * Ensures the tool-level config file exists with the minimum stable fields.
+ */
+function ensureToolConfig(toolConfigPath, version, defaultCodexDir) {
+    const current = readToolConfigIfExists(toolConfigPath);
+    if (current) {
+        return {
+            created: false,
+            config: current,
+        };
+    }
+    const next = {
+        version,
+    };
+    if (defaultCodexDir) {
+        next.defaultCodexDir = defaultCodexDir;
+    }
+    (0, fs_utils_1.ensureDir)(require("node:path").dirname(toolConfigPath));
+    (0, fs_utils_1.writeTextFileAtomic)(toolConfigPath, `${JSON.stringify(next, null, 2)}\n`);
+    return {
+        created: true,
+        config: next,
+    };
+}
+/**
+ * Writes the tool-level config file with a normalized shape.
+ */
+function writeToolConfig(toolConfigPath, config) {
+    const normalized = validateToolConfig(config, toolConfigPath);
+    (0, fs_utils_1.writeTextFileAtomic)(toolConfigPath, `${JSON.stringify(normalized, null, 2)}\n`);
+}
+function validateToolConfig(config, toolConfigPath) {
+    if (!config || typeof config !== "object") {
+        throw (0, errors_1.cliError)("INVALID_CONFIG", "codex-switch.json must contain a JSON object.", {
+            file: toolConfigPath,
+        });
+    }
+    if (typeof config.version !== "string" || config.version.trim() === "") {
+        throw (0, errors_1.cliError)("INVALID_CONFIG", "codex-switch.json requires a non-empty version field.", {
+            file: toolConfigPath,
+        });
+    }
+    if (config.defaultCodexDir !== undefined && typeof config.defaultCodexDir !== "string") {
+        throw (0, errors_1.cliError)("INVALID_CONFIG", "codex-switch.json.defaultCodexDir must be a string when provided.", {
+            file: toolConfigPath,
+        });
+    }
+    return {
+        version: config.version,
+        defaultCodexDir: config.defaultCodexDir,
+    };
+}