@minniexcode/codex-switch 0.0.9 → 0.0.11

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

@@ -35,45 +35,78 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCopilotBridgeStatePath = getCopilotBridgeStatePath;
 exports.readCopilotBridgeState = readCopilotBridgeState;
+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;
     }
     return JSON.parse(fs.readFileSync(statePath, "utf8"));
 }
+/**
+ * Safely inspects the runtime-state file for status/doctor style read paths.
+ */
+function inspectCopilotBridgeState(runtimeDir) {
+    const statePath = getCopilotBridgeStatePath(runtimeDir);
+    if (!fs.existsSync(statePath)) {
+        return {
+            exists: false,
+            valid: false,
+            parseError: null,
+            state: null,
+        };
+    }
+    try {
+        return {
+            exists: true,
+            valid: true,
+            parseError: null,
+            state: readCopilotBridgeState(runtimeDir),
+        };
+    }
+    catch (error) {
+        return {
+            exists: true,
+            valid: false,
+            parseError: (0, errors_1.normalizeError)(error).message,
+            state: null,
+        };
+    }
+}
 /**
  * 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,
+    };
+}