@minniexcode/codex-switch 0.0.9 → 0.0.10

package/dist/interaction/add-interactive.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.COMMON_TAG_CHOICES = void 0;
 exports.collectAddInput = collectAddInput;
+exports.collectCopilotAddInput = collectCopilotAddInput;
 exports.createNonInteractiveAddError = createNonInteractiveAddError;
 exports.promptTags = promptTags;
 const errors_1 = require("../domain/errors");
@@ -37,10 +38,51 @@ async function collectAddInput(runtime, defaults, providerExists, profileExists)
         tags,
     };
 }
+/**
+ * Collects Copilot add command inputs interactively when required values are missing.
+ */
+async function collectCopilotAddInput(runtime, defaults, providerExists, profileExists, options) {
+    runtime.writeLine("Interactive add mode");
+    runtime.writeLine("Provide the missing Copilot provider fields. Press Enter to keep optional values empty.");
+    const providerName = defaults.providerName
+        ? normalizeRequiredValue(defaults.providerName)
+        : await promptProviderName(runtime, providerExists);
+    const profile = defaults.profile ? normalizeRequiredValue(defaults.profile) : await promptRequiredValue(runtime, "Profile");
+    const createProfile = !profileExists(profile);
+    const model = createProfile
+        ? defaults.model
+            ? normalizeRequiredValue(defaults.model)
+            : await promptRequiredValue(runtime, `Model for new profile "${profile}"`)
+        : defaults.model ?? null;
+    const note = defaults.note ?? normalizeOptionalValue(await runtime.inputText("Note (optional)"));
+    const tags = defaults.tags.length > 0 ? defaults.tags : await promptTags(runtime);
+    const bridgeHost = options?.bridgeHost ?? normalizeOptionalValue(await runtime.inputText("Bridge host (optional)", { defaultValue: "127.0.0.1" }));
+    const bridgePortText = options?.bridgePort !== undefined && options.bridgePort !== null
+        ? String(options.bridgePort)
+        : await runtime.inputText("Bridge port (optional)", { defaultValue: "41415" });
+    const bridgePort = normalizeBridgePort(runtime, bridgePortText);
+    const bridgeApiKey = options?.bridgeApiKey ?? normalizeOptionalValue(await runtime.inputSecret("Bridge API key (optional)"));
+    return {
+        providerName,
+        profile,
+        createProfile,
+        model,
+        note,
+        tags,
+        bridgeApiKey,
+        bridgeHost,
+        bridgePort,
+    };
+}
 /**
  * Throws a consistent error when interactive add is unavailable.
  */
-function createNonInteractiveAddError() {
+function createNonInteractiveAddError(options) {
+    if (options?.copilot) {
+        return (0, errors_1.cliError)("INVALID_ARGUMENT", "add --copilot requires <provider> and --profile when running without an interactive TTY.", {
+            suggestion: "Run in a terminal TTY or pass <provider>, --profile, and any optional Copilot bridge flags explicitly.",
+        });
+    }
     return (0, errors_1.cliError)("INVALID_ARGUMENT", "add requires <provider>, --profile, and --api-key when running without an interactive TTY.", {
         suggestion: "Run in a terminal TTY or pass all required values explicitly.",
     });
@@ -90,6 +132,18 @@ function normalizeOptionalValue(value) {
     const normalized = value.trim();
     return normalized === "" ? null : normalized;
 }
+function normalizeBridgePort(runtime, value) {
+    const normalized = value.trim();
+    if (normalized === "") {
+        return null;
+    }
+    const parsed = Number(normalized);
+    if (Number.isInteger(parsed) && parsed > 0) {
+        return parsed;
+    }
+    runtime.writeLine("Bridge port must be a positive integer. Falling back to the default port.");
+    return null;
+}
 async function promptTags(runtime, defaults = []) {
     const defaultPresetTags = defaults.filter(isCommonTag);
     return runtime.selectMany("Select tags (optional)", exports.COMMON_TAG_CHOICES.map((tag) => ({ value: tag, label: tag })), { defaultValues: defaultPresetTags });

package/dist/interaction/interactive.js

@@ -222,7 +222,7 @@ async function chooseSetupProfiles(runtime, profiles) {
     return runtime.selectMany("Choose unmanaged config profiles to adopt into providers.json.", profiles.map((profile) => ({
         value: profile.name,
         label: profile.name,
-        hint: `${profile.model} | ${profile.baseUrl} | ${profile.envKey}`,
+        hint: `${profile.model} | ${profile.baseUrl}`,
     })));
 }
 /**
@@ -235,9 +235,6 @@ async function collectSetupProviderDetails(runtime, profiles, defaultsByProfile
         const providerName = (await runtime.inputText(`Provider name for profile "${profile}"`, {
             defaultValue: defaults.providerName ?? profile,
         })).trim();
-        if (defaults.envKey) {
-            runtime.writeLine(`Runtime env key for "${profile}": ${defaults.envKey}`);
-        }
         const apiKey = await promptRequiredSecret(runtime, `API key for profile "${profile}"`, defaults.apiKey?.trim() || undefined);
         const baseUrl = (await runtime.inputText(`Base URL note for profile "${profile}" (optional)`, {
             defaultValue: defaults.baseUrl ?? "",
@@ -249,7 +246,6 @@ async function collectSetupProviderDetails(runtime, profiles, defaultsByProfile
         result[profile] = {
             providerName: providerName || defaults.providerName || profile,
             apiKey,
-            envKey: defaults.envKey,
             baseUrl: baseUrl || defaults.baseUrl || undefined,
             note: note || defaults.note || undefined,
             // Empty selections are omitted so downstream setup validation can distinguish unset from explicit data.

package/dist/runtime/copilot-adapter.js

@@ -114,7 +114,7 @@ async function createCopilotSession() {
         throw (0, errors_1.cliError)("COPILOT_SDK_UNSUPPORTED", "The installed Copilot SDK does not expose a supported createSession API.", {});
     }
     try {
-        const session = (await Promise.resolve(createSession({})));
+        const session = (await Promise.resolve(createSession(createSessionOptions(sdk))));
         return {
             sdk,
             client,
@@ -122,11 +122,30 @@ async function createCopilotSession() {
         };
     }
     catch (error) {
+        if (classifyCopilotSessionError(error) === "unsupported") {
+            throw (0, errors_1.cliError)("COPILOT_SDK_UNSUPPORTED", "The installed Copilot SDK does not expose a compatible permission-handling session API.", {
+                cause: error instanceof Error ? error.message : String(error),
+            });
+        }
         throw (0, errors_1.cliError)("COPILOT_AUTH_REQUIRED", "Copilot authentication is required before the local bridge can be used.", {
             cause: error instanceof Error ? error.message : String(error),
         });
     }
 }
+/**
+ * Builds the session options used consistently across auth probes and request execution.
+ */
+function createSessionOptions(sdk) {
+    const approveAll = resolveApproveAll(sdk);
+    if (approveAll) {
+        return {
+            onPermissionRequest: (request) => approveAll(request),
+        };
+    }
+    return {
+        onPermissionRequest: () => true,
+    };
+}
 function createCopilotClient(sdk) {
     const ClientCtor = resolveConstructor(sdk, "CopilotClient");
     if (!ClientCtor) {
@@ -146,6 +165,16 @@ async function stopCopilotClient(client) {
         await Promise.resolve(client.stop());
     }
 }
+/**
+ * Distinguishes true auth failures from SDK API-shape mismatches.
+ */
+function classifyCopilotSessionError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/onPermissionRequest/i.test(message) || /permission/i.test(message)) {
+        return "unsupported";
+    }
+    return "auth";
+}
 function resolveCallable(target, name) {
     if (!target) {
         return null;
@@ -171,3 +200,17 @@ function resolveConstructor(target, name) {
     }
     return null;
 }
+/**
+ * Resolves the SDK-provided permission helper when available.
+ */
+function resolveApproveAll(target) {
+    const direct = target.approveAll;
+    if (typeof direct === "function") {
+        return direct;
+    }
+    const nestedDefault = target.default;
+    if (nestedDefault && typeof nestedDefault.approveAll === "function") {
+        return nestedDefault.approveAll;
+    }
+    return null;
+}

package/dist/runtime/copilot-bridge.js

@@ -65,8 +65,8 @@ function resetCopilotBridgeSpawnImplementation() {
 /**
  * Returns the last known Copilot bridge runtime status.
  */
-async function probeCopilotBridgeRuntime(provider) {
-    const state = (0, runtime_state_repo_1.readCopilotBridgeState)();
+async function probeCopilotBridgeRuntime(provider, persistedState) {
+    const state = persistedState === undefined ? (0, runtime_state_repo_1.readCopilotBridgeState)() : persistedState;
     if (state && (!provider || !(0, providers_1.isCopilotBridgeProvider)(provider))) {
         return {
             ok: false,

package/dist/runtime/copilot-cli.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setCopilotCliSpawnImplementation = setCopilotCliSpawnImplementation;
+exports.resetCopilotCliSpawnImplementation = resetCopilotCliSpawnImplementation;
+exports.checkCopilotCliAvailable = checkCopilotCliAvailable;
+exports.runCopilotLogin = runCopilotLogin;
+const node_child_process_1 = require("node:child_process");
+let spawnImplementation = node_child_process_1.spawnSync;
+/**
+ * Overrides the spawn implementation for Copilot CLI tests.
+ */
+function setCopilotCliSpawnImplementation(spawnLike) {
+    spawnImplementation = spawnLike;
+}
+/**
+ * Restores the default spawn implementation after tests.
+ */
+function resetCopilotCliSpawnImplementation() {
+    spawnImplementation = node_child_process_1.spawnSync;
+}
+/**
+ * Checks whether the GitHub Copilot CLI is available on PATH.
+ */
+function checkCopilotCliAvailable() {
+    const invocation = getCopilotInvocation(["--help"]);
+    const result = spawnImplementation(invocation.command, invocation.args, {
+        stdio: "pipe",
+        encoding: "utf8",
+        shell: false,
+    });
+    if (result.error || result.status !== 0) {
+        return {
+            ok: false,
+            cause: result.error?.message ?? (result.stderr.trim() || "Unknown failure"),
+        };
+    }
+    return { ok: true };
+}
+/**
+ * Launches the official `copilot login` flow in the current terminal.
+ */
+function runCopilotLogin(options) {
+    const args = ["login"];
+    if (options?.host) {
+        args.push("--hostname", options.host);
+    }
+    const invocation = getCopilotInvocation(args);
+    const result = spawnImplementation(invocation.command, invocation.args, {
+        stdio: "inherit",
+        shell: false,
+    });
+    if (result.error || result.status !== 0) {
+        throw new Error(result.error?.message ?? `copilot login exited with status ${String(result.status)}`);
+    }
+}
+/**
+ * Resolves a cross-platform invocation for the Copilot CLI.
+ */
+function getCopilotInvocation(args) {
+    if (process.platform === "win32") {
+        return {
+            command: process.env.ComSpec || "cmd.exe",
+            args: ["/d", "/s", "/c", ["copilot", ...args].join(" ")],
+        };
+    }
+    return {
+        command: "copilot",
+        args,
+    };
+}

package/dist/runtime/copilot-installer.js

@@ -107,19 +107,66 @@ function installCopilotSdk() {
     if (!fs.existsSync(packageJsonPath)) {
         fs.writeFileSync(packageJsonPath, `${JSON.stringify({ name: "codex-switch-copilot-runtime", private: true, version: "0.0.0" }, null, 2)}\n`, "utf8");
     }
-    const command = process.platform === "win32" ? "npm.cmd" : "npm";
-    const result = spawnImplementation(command, ["install", "--no-save", `${COPILOT_SDK_PACKAGE}@${COPILOT_SDK_VERSION}`], {
+    const installCommand = resolveNpmInstallCommand();
+    const result = spawnImplementation(installCommand.command, installCommand.args, {
         cwd: installDir,
         stdio: "pipe",
         encoding: "utf8",
         shell: false,
     });
+    if (result.error) {
+        throw (0, errors_1.cliError)("COPILOT_SDK_INSTALL_FAILED", "Failed to install the optional Copilot SDK runtime.", {
+            installDir,
+            packageName: COPILOT_SDK_PACKAGE,
+            cause: result.error.message,
+            errorCode: result.error.code ?? null,
+            command: installCommand.command,
+            args: installCommand.args,
+        });
+    }
     if (result.status !== 0) {
         throw (0, errors_1.cliError)("COPILOT_SDK_INSTALL_FAILED", "Failed to install the optional Copilot SDK runtime.", {
             installDir,
             packageName: COPILOT_SDK_PACKAGE,
             cause: result.stderr || result.stdout || `npm exited with status ${String(result.status)}`,
+            command: installCommand.command,
+            args: installCommand.args,
         });
     }
     return probeCopilotSdkInstall();
 }
+/**
+ * Resolves a stable npm install invocation for the optional Copilot SDK runtime.
+ */
+function resolveNpmInstallCommand() {
+    const installArgs = ["install", "--no-save", `${COPILOT_SDK_PACKAGE}@${COPILOT_SDK_VERSION}`];
+    const npmCliPath = resolveNpmCliPath();
+    if (npmCliPath) {
+        return {
+            command: process.execPath,
+            args: [npmCliPath, ...installArgs],
+        };
+    }
+    return {
+        command: process.platform === "win32" ? "npm.cmd" : "npm",
+        args: installArgs,
+    };
+}
+/**
+ * Finds a locally available npm CLI script near the active Node runtime.
+ */
+function resolveNpmCliPath() {
+    const execDir = path.dirname(process.execPath);
+    const candidates = [
+        process.env.npm_execpath,
+        path.join(execDir, "node_modules", "npm", "bin", "npm-cli.js"),
+        path.join(execDir, "..", "node_modules", "npm", "bin", "npm-cli.js"),
+        path.join(execDir, "..", "..", "node_modules", "npm", "bin", "npm-cli.js"),
+    ];
+    for (const candidate of candidates) {
+        if (candidate && fs.existsSync(candidate)) {
+            return path.resolve(candidate);
+        }
+    }
+    return null;
+}

package/dist/storage/auth-repo.js

@@ -34,15 +34,10 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readAuthFileIfExists = readAuthFileIfExists;
-exports.buildManagedAuthPayload = buildManagedAuthPayload;
-exports.buildManagedAuthJson = buildManagedAuthJson;
-exports.writeAuthFile = writeAuthFile;
-exports.extractManagedAuthFingerprint = extractManagedAuthFingerprint;
-exports.readManagedAuthState = readManagedAuthState;
+exports.readAuthFileState = readAuthFileState;
+exports.writeOpenAiApiKeyAuth = writeOpenAiApiKeyAuth;
 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.
  */
@@ -61,84 +56,27 @@ function readAuthFileIfExists(authPath) {
     }
 }
 /**
- * Builds the stable managed auth payload for one provider.
+ * Reads auth.json into a neutral file-state summary for status and doctor.
  */
-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) {
+function readAuthFileState(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);
+        const authMode = payload && typeof payload === "object" && !Array.isArray(payload) && typeof payload.auth_mode === "string"
+            ? String(payload.auth_mode)
+            : null;
         return {
             exists: true,
-            valid: Boolean(fingerprint.payload),
+            valid: Boolean(payload && typeof payload === "object" && !Array.isArray(payload)),
             parseError: null,
-            authMode: fingerprint.authMode,
-            managedSecretKeys: fingerprint.managedSecretKeys,
-            payload: fingerprint.payload,
+            authMode,
         };
     }
     catch (error) {
@@ -147,14 +85,27 @@ function readManagedAuthState(authPath) {
             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;
+/**
+ * Writes the active direct-provider auth projection expected by Codex.
+ * Invalid or missing existing auth.json content is replaced with a minimal valid object.
+ */
+function writeOpenAiApiKeyAuth(authPath, apiKey) {
+    let next = {};
+    if (fs.existsSync(authPath)) {
+        try {
+            const payload = JSON.parse(fs.readFileSync(authPath, "utf8"));
+            if (payload && typeof payload === "object" && !Array.isArray(payload)) {
+                next = { ...payload };
+            }
+        }
+        catch {
+            next = {};
+        }
     }
-    return /^[A-Z0-9_]+$/.test(key);
+    next.auth_mode = "apikey";
+    next.OPENAI_API_KEY = apiKey;
+    fs.writeFileSync(authPath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
 }

package/dist/storage/config-repo.js

@@ -40,7 +40,6 @@ exports.listConfigProfiles = listConfigProfiles;
 exports.ensureProfileExists = ensureProfileExists;
 exports.requireManagedProfileRuntime = requireManagedProfileRuntime;
 exports.requireModelProviderRuntimeSection = requireModelProviderRuntimeSection;
-exports.requireRuntimeEnvKey = requireRuntimeEnvKey;
 exports.resolveActiveProviderName = resolveActiveProviderName;
 exports.updateTopLevelProfile = updateTopLevelProfile;
 exports.createConfigMutationPlan = createConfigMutationPlan;
@@ -143,13 +142,6 @@ 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;
 }
 /**
@@ -170,33 +162,6 @@ 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.
@@ -212,7 +177,7 @@ function resolveActiveProviderName(document, providers) {
         });
     }
     if (matches.length > 1) {
-        throw (0, errors_1.cliError)("ACTIVE_PROVIDER_UNRESOLVED", `Active profile "${document.activeProfile}" maps to multiple providers.`, {
+        throw (0, errors_1.cliError)("ACTIVE_PROVIDER_UNRESOLVED", `Active profile "${document.activeProfile}" maps to multiple providers, so the active managed provider is ambiguous.`, {
             profile: document.activeProfile,
             providers: matches,
         });

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

@@ -35,11 +35,13 @@ 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 fs_utils_1 = require("./fs-utils");
 /**
  * Returns the user-level runtime state file used by Copilot bridge helpers.
@@ -61,6 +63,36 @@ function readCopilotBridgeState() {
     }
     return JSON.parse(fs.readFileSync(statePath, "utf8"));
 }
+/**
+ * Safely inspects the runtime-state file for status/doctor style read paths.
+ */
+function inspectCopilotBridgeState() {
+    const statePath = getCopilotBridgeStatePath();
+    if (!fs.existsSync(statePath)) {
+        return {
+            exists: false,
+            valid: false,
+            parseError: null,
+            state: null,
+        };
+    }
+    try {
+        return {
+            exists: true,
+            valid: true,
+            parseError: null,
+            state: readCopilotBridgeState(),
+        };
+    }
+    catch (error) {
+        return {
+            exists: true,
+            valid: false,
+            parseError: (0, errors_1.normalizeError)(error).message,
+            state: null,
+        };
+    }
+}
 /**
  * Persists the Copilot bridge state manifest.
  */