@minniexcode/codex-switch 0.0.6 → 0.0.8

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/config-repo.js

@@ -40,6 +40,8 @@ exports.listConfigProfiles = listConfigProfiles;
 exports.ensureProfileExists = ensureProfileExists;
 exports.requireManagedProfileRuntime = requireManagedProfileRuntime;
 exports.requireModelProviderRuntimeSection = requireModelProviderRuntimeSection;
+exports.requireRuntimeEnvKey = requireRuntimeEnvKey;
+exports.resolveActiveProviderName = resolveActiveProviderName;
 exports.updateTopLevelProfile = updateTopLevelProfile;
 exports.createConfigMutationPlan = createConfigMutationPlan;
 exports.applyConfigMutation = applyConfigMutation;
@@ -49,6 +51,7 @@ 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 providers_1 = require("../domain/providers");
 const codex_paths_1 = require("./codex-paths");
 const fs_utils_1 = require("./fs-utils");
 /**
@@ -140,6 +143,13 @@ function requireManagedProfileRuntime(document, providers, profile) {
             missingFields: ["base_url"],
         });
     }
+    if (!modelProviderSection.envKey) {
+        throw (0, errors_1.cliError)("MODEL_PROVIDER_ENV_KEY_MISSING", `Model provider "${view.modelProvider}" requires env_key.`, {
+            profile,
+            modelProvider: view.modelProvider,
+            missingFields: ["env_key"],
+        });
+    }
     return view;
 }
 /**
@@ -160,6 +170,54 @@ function requireModelProviderRuntimeSection(document, profile) {
             missingFields: ["base_url"],
         });
     }
+    if (!modelProviderSection.envKey) {
+        throw (0, errors_1.cliError)("MODEL_PROVIDER_ENV_KEY_MISSING", `Model provider "${profile}" requires env_key.`, {
+            profile,
+            modelProvider: profile,
+            missingFields: ["env_key"],
+        });
+    }
+}
+/**
+ * Returns the runtime env_key for one profile or throws a typed error.
+ */
+function requireRuntimeEnvKey(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.envKey) {
+        throw (0, errors_1.cliError)("MODEL_PROVIDER_ENV_KEY_MISSING", `Model provider "${profile}" requires env_key.`, {
+            profile,
+            modelProvider: profile,
+            missingFields: ["env_key"],
+        });
+    }
+    return modelProviderSection.envKey;
+}
+/**
+ * Resolves the current active provider and requires the mapping to be unique.
+ */
+function resolveActiveProviderName(document, providers) {
+    if (!document.activeProfile) {
+        throw (0, errors_1.cliError)("PROFILE_NOT_FOUND", "No top-level profile is set in config.toml.");
+    }
+    const matches = (0, providers_1.findProvidersByProfile)(providers, document.activeProfile);
+    if (matches.length === 0) {
+        throw (0, errors_1.cliError)("UNMANAGED_ACTIVE_PROFILE", `Active profile "${document.activeProfile}" is not mapped by providers.json.`, {
+            profile: document.activeProfile,
+        });
+    }
+    if (matches.length > 1) {
+        throw (0, errors_1.cliError)("ACTIVE_PROVIDER_UNRESOLVED", `Active profile "${document.activeProfile}" maps to multiple providers.`, {
+            profile: document.activeProfile,
+            providers: matches,
+        });
+    }
+    return matches[0];
 }
 /**
  * Rewrites config.toml so the requested profile becomes the active top-level profile.

package/dist/storage/fs-utils.js

@@ -55,6 +55,9 @@ function writeTextFileAtomic(filePath, contents) {
     // Use the current process id in the temp name to reduce collision risk.
     const tempPath = `${filePath}.tmp-${process.pid}`;
     fs.writeFileSync(tempPath, contents, "utf8");
+    if (fs.existsSync(filePath)) {
+        fs.rmSync(filePath, { force: true });
+    }
     fs.renameSync(tempPath, filePath);
 }
 /**

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

@@ -0,0 +1,80 @@
+"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.getCopilotBridgeStatePath = getCopilotBridgeStatePath;
+exports.readCopilotBridgeState = readCopilotBridgeState;
+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 fs_utils_1 = require("./fs-utils");
+/**
+ * Returns the user-level runtime state file used by Copilot bridge helpers.
+ */
+function getCopilotBridgeStatePath() {
+    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");
+}
+/**
+ * Reads the Copilot bridge state manifest when present.
+ */
+function readCopilotBridgeState() {
+    const statePath = getCopilotBridgeStatePath();
+    if (!fs.existsSync(statePath)) {
+        return null;
+    }
+    return JSON.parse(fs.readFileSync(statePath, "utf8"));
+}
+/**
+ * Persists the Copilot bridge state manifest.
+ */
+function writeCopilotBridgeState(state) {
+    const statePath = getCopilotBridgeStatePath();
+    (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();
+    if (fs.existsSync(statePath)) {
+        fs.rmSync(statePath, { force: true });
+    }
+}