@minniexcode/codex-switch 0.0.7 → 0.0.9

package/README.md

@@ -18,7 +18,7 @@ What it does:
 - Run diagnostics and detect local drift
 - List backups and roll back to a previous managed state
 
-Current version: `0.0.7`
+Current version: `0.0.8`
 
 ## Install
 

package/dist/app/add-provider.js

@@ -1,6 +1,40 @@
 "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.addProvider = addProvider;
+const crypto = __importStar(require("node:crypto"));
 const config_1 = require("../domain/config");
 const providers_1 = require("../domain/providers");
 const errors_1 = require("../domain/errors");
@@ -8,6 +42,7 @@ const config_repo_1 = require("../storage/config-repo");
 const fs_utils_1 = require("../storage/fs-utils");
 const providers_repo_1 = require("../storage/providers-repo");
 const auth_repo_1 = require("../storage/auth-repo");
+const copilot_installer_1 = require("../runtime/copilot-installer");
 const run_mutation_1 = require("./run-mutation");
 /**
  * Adds a new provider record to the managed providers registry.
@@ -18,6 +53,34 @@ function addProvider(args) {
     if (providers.providers[args.providerName]) {
         throw (0, errors_1.cliError)("INVALID_IMPORT_FILE", `Provider "${args.providerName}" already exists.`);
     }
+    const bridgeHost = args.bridgeHost ?? "127.0.0.1";
+    const bridgePort = args.bridgePort ?? 41415;
+    const runtime = args.copilot
+        ? {
+            kind: "copilot-sdk-bridge",
+            upstream: "github-copilot",
+            bridgeHost,
+            bridgePort,
+            bridgePath: "/v1",
+            premiumRequests: true,
+            authSource: "official-sdk",
+            sdkInstallMode: "lazy",
+        }
+        : undefined;
+    if (args.copilot) {
+        const installStatus = (0, copilot_installer_1.probeCopilotSdkInstall)();
+        if (!installStatus.installed) {
+            if (!args.installCopilotSdk) {
+                throw (0, errors_1.cliError)(args.interactive ? "COPILOT_SDK_MISSING" : "COPILOT_SDK_INSTALL_REQUIRES_TTY", args.interactive
+                    ? "The optional Copilot SDK runtime is not installed. Re-run with --install-copilot-sdk or confirm installation interactively."
+                    : "The optional Copilot SDK runtime is not installed. Pass --install-copilot-sdk when running non-interactively.", {
+                    installDir: installStatus.installDir,
+                    packageName: installStatus.packageName,
+                });
+            }
+            (0, copilot_installer_1.installCopilotSdk)();
+        }
+    }
     const document = (0, config_repo_1.readStructuredConfig)(args.configPath);
     const existingProfile = document.profiles.find((profile) => profile.name === args.profile);
     const existingModelProvider = document.modelProviders.find((entry) => entry.name === args.profile);
@@ -38,7 +101,7 @@ function addProvider(args) {
     const upsertModelProviders = !existingModelProvider && args.createProfile
         ? {
             [args.profile]: {
-                baseUrl: args.baseUrl ?? undefined,
+                baseUrl: args.copilot ? (0, providers_1.buildCopilotBridgeBaseUrl)(runtime) : args.baseUrl ?? undefined,
                 envKey: (0, config_1.buildManagedProfileEnvKey)(args.profile),
             },
         }
@@ -47,16 +110,19 @@ function addProvider(args) {
         (0, config_repo_1.requireManagedProfileRuntime)(document, providers, args.profile);
     }
     const envKey = existingModelProvider?.envKey ?? (0, config_1.buildManagedProfileEnvKey)(args.profile);
+    const apiKey = args.copilot ? args.bridgeApiKey ?? crypto.randomBytes(24).toString("hex") : args.apiKey;
+    const baseUrl = args.copilot ? (0, providers_1.buildCopilotBridgeBaseUrl)(runtime) : args.baseUrl ?? undefined;
     const next = {
         providers: {
             ...providers.providers,
             [args.providerName]: (0, providers_1.cleanProviderRecord)({
                 profile: args.profile,
-                apiKey: args.apiKey,
+                apiKey,
                 envKey,
-                baseUrl: args.baseUrl ?? undefined,
+                baseUrl,
                 note: args.note ?? undefined,
                 tags: args.tags,
+                runtime,
             }),
         },
     };
@@ -87,6 +153,7 @@ function addProvider(args) {
                 provider: args.providerName,
                 profile: args.profile,
                 envKey,
+                runtimeKind: runtime?.kind ?? null,
                 createdProfileSections: configPlan.createdProfileSections,
                 createdModelProviderSections: configPlan.createdModelProviderSections,
                 deletedProfileSections: configPlan.deletedProfileSections,

package/dist/app/bridge.js

@@ -0,0 +1,296 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startBridge = startBridge;
+exports.stopBridge = stopBridge;
+exports.statusBridge = statusBridge;
+const errors_1 = require("../domain/errors");
+const providers_1 = require("../domain/providers");
+const config_repo_1 = require("../storage/config-repo");
+const providers_repo_1 = require("../storage/providers-repo");
+const interactive_1 = require("../interaction/interactive");
+const copilot_bridge_1 = require("../runtime/copilot-bridge");
+const runtime_state_repo_1 = require("../storage/runtime-state-repo");
+const copilot_installer_1 = require("../runtime/copilot-installer");
+const copilot_adapter_1 = require("../runtime/copilot-adapter");
+const DEFAULT_BRIDGE_PORT = 41415;
+/**
+ * Starts or reuses the managed Copilot bridge for one provider.
+ */
+async function startBridge(args) {
+    const providers = (0, providers_repo_1.readProvidersFile)(args.providersPath);
+    const target = await resolveBridgeTarget({
+        requestedProviderName: args.providerName ?? null,
+        providers,
+        configPath: args.configPath,
+        runtime: args.runtime,
+        json: args.json,
+        commandName: "start",
+        preferRuntimeState: false,
+    });
+    await requireBridgeRuntimeReadiness();
+    const bridge = await (0, copilot_bridge_1.ensureCopilotBridge)(target.providerName, target.provider);
+    const nextProvider = bridge.portChanged ? rewriteBridgeProviderPort(target.provider, bridge.port) : target.provider;
+    if (bridge.portChanged) {
+        try {
+            persistRecoveredBridgePort({
+                providersPath: args.providersPath,
+                configPath: args.configPath,
+                providers,
+                providerName: target.providerName,
+                previousProvider: target.provider,
+                provider: nextProvider,
+            });
+        }
+        catch (error) {
+            if (!bridge.reused) {
+                (0, copilot_bridge_1.stopCopilotBridge)();
+            }
+            throw error;
+        }
+    }
+    return {
+        data: {
+            provider: target.providerName,
+            profile: nextProvider.profile,
+            baseUrl: (0, providers_1.buildCopilotBridgeBaseUrl)(nextProvider.runtime),
+            host: bridge.host,
+            port: bridge.port,
+            reused: bridge.reused,
+            portChanged: bridge.portChanged,
+            defaultPort: DEFAULT_BRIDGE_PORT,
+        },
+    };
+}
+/**
+ * Stops the managed Copilot bridge.
+ */
+async function stopBridge(args) {
+    const providers = (0, providers_repo_1.readProvidersFile)(args.providersPath);
+    const state = (0, runtime_state_repo_1.readCopilotBridgeState)();
+    if (!state && !args.providerName) {
+        return {
+            data: {
+                provider: null,
+                stopped: true,
+                hadRuntimeState: false,
+            },
+        };
+    }
+    if (!state && args.providerName) {
+        resolveNamedBridgeProvider(providers, args.providerName);
+        return {
+            data: {
+                provider: args.providerName,
+                stopped: true,
+                hadRuntimeState: false,
+            },
+        };
+    }
+    const target = await resolveBridgeTarget({
+        requestedProviderName: args.providerName ?? null,
+        providers,
+        configPath: args.configPath,
+        runtime: args.runtime,
+        json: args.json,
+        commandName: "stop",
+        preferRuntimeState: true,
+    });
+    if (args.providerName && state?.provider && state.provider !== args.providerName) {
+        throw (0, errors_1.cliError)("BRIDGE_PROVIDER_MISMATCH", `Bridge runtime state belongs to "${state.provider}" not "${args.providerName}".`, {
+            stateProvider: state.provider,
+            requestedProvider: args.providerName,
+        });
+    }
+    (0, copilot_bridge_1.stopCopilotBridge)();
+    return {
+        data: {
+            provider: target.providerName,
+            stopped: true,
+            hadRuntimeState: Boolean(state),
+        },
+    };
+}
+/**
+ * Reports the managed Copilot bridge state.
+ */
+async function statusBridge(args) {
+    const providers = (0, providers_repo_1.readProvidersFile)(args.providersPath);
+    const state = (0, runtime_state_repo_1.readCopilotBridgeState)();
+    const target = await resolveBridgeTarget({
+        requestedProviderName: args.providerName ?? null,
+        providers,
+        configPath: args.configPath,
+        runtime: args.runtime,
+        json: args.json,
+        commandName: "status",
+        preferRuntimeState: true,
+    });
+    const provider = target.provider;
+    const runtimeStatus = await (0, copilot_bridge_1.probeCopilotBridgeRuntime)(provider);
+    const expectedBaseUrl = (0, providers_1.buildCopilotBridgeBaseUrl)(provider.runtime);
+    if (args.providerName && state?.provider && state.provider !== args.providerName) {
+        throw (0, errors_1.cliError)("BRIDGE_PROVIDER_MISMATCH", `Bridge runtime state belongs to "${state.provider}" not "${args.providerName}".`, {
+            stateProvider: state.provider,
+            requestedProvider: args.providerName,
+        });
+    }
+    return {
+        data: {
+            provider: target.providerName,
+            profile: provider.profile,
+            runtimeState: state,
+            expectedBaseUrl,
+            matches: Boolean(state && state.provider === target.providerName && state.baseUrl === expectedBaseUrl),
+            active: runtimeStatus.ok,
+            health: runtimeStatus,
+        },
+    };
+}
+/**
+ * Resolves the Copilot provider target for one bridge command.
+ */
+async function resolveBridgeTarget(args) {
+    if (args.requestedProviderName) {
+        return resolveNamedBridgeProvider(args.providers, args.requestedProviderName);
+    }
+    if (args.preferRuntimeState) {
+        const runtimeState = (0, runtime_state_repo_1.readCopilotBridgeState)();
+        if (runtimeState?.provider && args.providers.providers[runtimeState.provider]) {
+            return resolveNamedBridgeProvider(args.providers, runtimeState.provider);
+        }
+    }
+    const activeTarget = resolveActiveCopilotBridgeProvider(args.providers, args.configPath);
+    if (activeTarget) {
+        return activeTarget;
+    }
+    const copilotTargets = listCopilotBridgeProviders(args.providers);
+    if (copilotTargets.length === 1) {
+        return copilotTargets[0];
+    }
+    if ((0, interactive_1.canPrompt)(args.runtime, args.json)) {
+        const selected = await promptForCopilotBridgeSelection(args.runtime, copilotTargets, args.commandName);
+        return resolveNamedBridgeProvider(args.providers, selected);
+    }
+    throw (0, errors_1.cliError)("BRIDGE_TARGET_UNRESOLVED", `Unable to resolve a Copilot provider for bridge ${args.commandName}.`, {
+        availableProviders: copilotTargets.map((entry) => entry.providerName),
+    });
+}
+/**
+ * Resolves the active provider when the current top-level profile maps to one Copilot bridge provider.
+ */
+function resolveActiveCopilotBridgeProvider(providers, configPath) {
+    try {
+        const currentProfile = (0, config_repo_1.readCurrentProfile)(configPath);
+        const matches = Object.entries(providers.providers)
+            .filter(([, provider]) => provider.profile === currentProfile && (0, providers_1.isCopilotBridgeProvider)(provider))
+            .sort(([left], [right]) => left.localeCompare(right));
+        if (matches.length === 1) {
+            return {
+                providerName: matches[0][0],
+                provider: matches[0][1],
+            };
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+/**
+ * Resolves one named provider and enforces the Copilot bridge runtime kind.
+ */
+function resolveNamedBridgeProvider(providers, providerName) {
+    const provider = providers.providers[providerName];
+    if (!provider) {
+        throw (0, errors_1.cliError)("PROVIDER_NOT_FOUND", `Provider "${providerName}" was not found.`, {
+            provider: providerName,
+        });
+    }
+    if (!(0, providers_1.isCopilotBridgeProvider)(provider)) {
+        throw (0, errors_1.cliError)("BRIDGE_PROVIDER_MISMATCH", `Provider "${providerName}" is not a Copilot bridge provider.`, {
+            provider: providerName,
+        });
+    }
+    return { providerName, provider };
+}
+/**
+ * Lists all configured Copilot bridge providers in stable order.
+ */
+function listCopilotBridgeProviders(providers) {
+    return Object.entries(providers.providers)
+        .filter(([, provider]) => (0, providers_1.isCopilotBridgeProvider)(provider))
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([providerName, provider]) => ({ providerName, provider }));
+}
+/**
+ * Uses a Copilot-only provider picker instead of the generic provider selector.
+ */
+async function promptForCopilotBridgeSelection(runtime, targets, commandName) {
+    if (targets.length === 0) {
+        throw (0, errors_1.cliError)("BRIDGE_TARGET_UNRESOLVED", `No Copilot bridge providers are configured for bridge ${commandName}.`);
+    }
+    return runtime.selectOne(`Choose a Copilot provider to ${commandName}`, targets.map((target) => ({
+        value: target.providerName,
+        label: target.providerName,
+        hint: target.provider.profile,
+    })));
+}
+/**
+ * Verifies that the local Copilot bridge prerequisites are available before startup.
+ */
+async function requireBridgeRuntimeReadiness() {
+    const installStatus = (0, copilot_installer_1.probeCopilotSdkInstall)();
+    if (!installStatus.installed) {
+        throw (0, errors_1.cliError)("COPILOT_SDK_MISSING", "The optional Copilot SDK runtime is not installed.", {
+            installDir: installStatus.installDir,
+            packageName: installStatus.packageName,
+        });
+    }
+    await (0, copilot_adapter_1.readCopilotAuthState)();
+}
+/**
+ * Rewrites one Copilot bridge provider record with a recovered runtime port.
+ */
+function rewriteBridgeProviderPort(provider, port) {
+    return (0, providers_1.cleanProviderRecord)({
+        ...provider,
+        baseUrl: `http://${provider.runtime.bridgeHost}:${port}${provider.runtime.bridgePath}`,
+        runtime: {
+            ...provider.runtime,
+            bridgePort: port,
+        },
+    });
+}
+/**
+ * Persists the recovered bridge port to both providers.json and config.toml.
+ */
+function persistRecoveredBridgePort(args) {
+    const previousProviders = {
+        providers: {
+            ...args.providers.providers,
+        },
+    };
+    const nextProviders = {
+        providers: {
+            ...args.providers.providers,
+            [args.providerName]: args.provider,
+        },
+    };
+    (0, providers_repo_1.writeProvidersFile)(args.providersPath, nextProviders);
+    try {
+        const document = (0, config_repo_1.readStructuredConfig)(args.configPath);
+        const configPlan = (0, config_repo_1.createConfigMutationPlan)(document, {
+            upsertModelProviders: {
+                [args.provider.profile]: {
+                    baseUrl: (0, providers_1.buildCopilotBridgeBaseUrl)(args.provider.runtime),
+                    envKey: (0, config_repo_1.requireRuntimeEnvKey)(document, args.provider.profile),
+                },
+            },
+        });
+        (0, config_repo_1.applyConfigMutation)(args.configPath, document, configPlan);
+    }
+    catch (error) {
+        (0, providers_repo_1.writeProvidersFile)(args.providersPath, previousProviders);
+        throw error;
+    }
+}

package/dist/app/get-status.js

@@ -41,10 +41,14 @@ const providers_1 = require("../domain/providers");
 const config_repo_1 = require("../storage/config-repo");
 const providers_repo_1 = require("../storage/providers-repo");
 const auth_repo_1 = require("../storage/auth-repo");
+const copilot_installer_1 = require("../runtime/copilot-installer");
+const copilot_bridge_1 = require("../runtime/copilot-bridge");
+const copilot_adapter_1 = require("../runtime/copilot-adapter");
+const runtime_state_repo_1 = require("../storage/runtime-state-repo");
 /**
  * Reports the current on-disk runtime state and how it maps back to managed providers.
  */
-function getStatus(codexDir, configPath, providersPath, authPath) {
+async function getStatus(codexDir, configPath, providersPath, authPath) {
     const configExists = fs.existsSync(configPath);
     const providersExists = fs.existsSync(providersPath);
     let currentProfile = null;
@@ -64,6 +68,30 @@ function getStatus(codexDir, configPath, providersPath, authPath) {
     }
     const liveState = (0, runtime_state_1.inspectLiveStateDrift)(currentProfile, providers);
     const activeProviderCandidates = currentProfile && providers ? (0, providers_1.findProvidersByProfile)(providers, currentProfile) : [];
+    const activeProvider = activeProviderCandidates.length === 1 && providers ? providers.providers[activeProviderCandidates[0]] : null;
+    const copilotInstall = (0, copilot_installer_1.probeCopilotSdkInstall)();
+    const runtimeState = (0, runtime_state_repo_1.readCopilotBridgeState)();
+    const runtimeStateProvider = runtimeState && providers ? providers.providers[runtimeState.provider] ?? null : null;
+    const bridgeProbeTarget = activeProvider && (0, providers_1.isCopilotBridgeProvider)(activeProvider)
+        ? activeProvider
+        : runtimeStateProvider && (0, providers_1.isCopilotBridgeProvider)(runtimeStateProvider)
+            ? runtimeStateProvider
+            : null;
+    const copilotBridge = bridgeProbeTarget ? await (0, copilot_bridge_1.probeCopilotBridgeRuntime)(bridgeProbeTarget) : runtimeState ? {
+        ok: false,
+        runtime: "copilot-bridge",
+        reason: "failed",
+        cause: "Copilot bridge runtime state exists but no matching managed Copilot provider is active.",
+        details: runtimeState,
+    } : null;
+    const copilotAuth = activeProvider && (0, providers_1.isCopilotBridgeProvider)(activeProvider)
+        ? await (0, copilot_adapter_1.readCopilotAuthState)().catch((error) => ({
+            ready: false,
+            source: "official-sdk",
+            mode: "session",
+            error: error instanceof Error ? error.message : String(error),
+        }))
+        : null;
     if (liveState.canBackfillActiveProvider) {
         // Surface unmanaged live state without mutating anything during a read-only status call.
         warnings.push("Current config profile is not mapped in providers.json. Backfill would be required before treating live state as managed.");
@@ -80,6 +108,16 @@ function getStatus(codexDir, configPath, providersPath, authPath) {
             provider: liveState.mappedProvider,
             activeProviderResolvable: activeProviderCandidates.length === 1,
             activeProviderCandidates,
+            runtimeProvider: activeProvider && (0, providers_1.isCopilotBridgeProvider)(activeProvider) ? activeProvider.runtime?.kind ?? null : null,
+            copilotSdk: {
+                installed: copilotInstall.installed,
+                installDir: copilotInstall.installDir,
+                packageName: copilotInstall.packageName,
+                packageVersion: copilotInstall.packageVersion ?? null,
+            },
+            copilotAuth,
+            copilotBridge,
+            copilotRuntimeState: runtimeState,
             liveState,
             auth: authState,
             configProfiles: configViews,

package/dist/app/run-doctor.js

@@ -43,10 +43,14 @@ const errors_1 = require("../domain/errors");
 const codex_probe_1 = require("../runtime/codex-probe");
 const auth_repo_1 = require("../storage/auth-repo");
 const providers_1 = require("../domain/providers");
+const copilot_installer_1 = require("../runtime/copilot-installer");
+const copilot_bridge_1 = require("../runtime/copilot-bridge");
+const copilot_adapter_1 = require("../runtime/copilot-adapter");
+const runtime_state_repo_1 = require("../storage/runtime-state-repo");
 /**
  * Performs consistency checks across config.toml, providers.json, and the local Codex CLI.
  */
-function runDoctor(args) {
+async function runDoctor(args) {
     const issues = [];
     let currentProfile = null;
     let providers = null;
@@ -99,6 +103,7 @@ function runDoctor(args) {
         }
     }
     const authState = (0, auth_repo_1.readManagedAuthState)(args.authPath);
+    const runtimeState = (0, runtime_state_repo_1.readCopilotBridgeState)();
     if (authState.exists && !authState.valid) {
         issues.push({
             code: "AUTH_JSON_INVALID",
@@ -134,6 +139,56 @@ function runDoctor(args) {
                     provider: matches[0],
                 });
             }
+            if ((0, providers_1.isCopilotBridgeProvider)(activeProvider)) {
+                const installStatus = (0, copilot_installer_1.probeCopilotSdkInstall)();
+                if (!installStatus.installed) {
+                    issues.push({
+                        code: "COPILOT_SDK_MISSING",
+                        message: "The optional Copilot SDK runtime is not installed.",
+                        installDir: installStatus.installDir,
+                        packageName: installStatus.packageName,
+                    });
+                }
+                try {
+                    await (0, copilot_adapter_1.readCopilotAuthState)();
+                }
+                catch (error) {
+                    const normalized = (0, errors_1.normalizeError)(error);
+                    issues.push({
+                        code: normalized.code,
+                        message: normalized.message,
+                        ...(normalized.details ?? {}),
+                    });
+                }
+                const bridge = await (0, copilot_bridge_1.probeCopilotBridgeRuntime)(activeProvider);
+                if (!bridge.ok) {
+                    issues.push({
+                        code: mapBridgeDiagnosticCode(bridge.cause),
+                        message: bridge.cause,
+                        ...(bridge.details ?? {}),
+                    });
+                }
+            }
+        }
+    }
+    if (runtimeState && providers) {
+        const runtimeProvider = providers.providers[runtimeState.provider] ?? null;
+        if (!runtimeProvider || !(0, providers_1.isCopilotBridgeProvider)(runtimeProvider)) {
+            issues.push({
+                code: "BRIDGE_STATE_STALE",
+                message: "Copilot bridge runtime state exists but no matching managed Copilot provider is available.",
+                ...runtimeState,
+            });
+        }
+        else if (!document?.activeProfile || runtimeProvider.profile !== document.activeProfile) {
+            issues.push({
+                code: "BRIDGE_STATE_STALE",
+                message: "Copilot bridge runtime state exists for a provider that is not the current active profile.",
+                activeProfile: document?.activeProfile ?? null,
+                runtimeProvider: runtimeState.provider,
+                runtimeProfile: runtimeProvider.profile,
+                ...runtimeState,
+            });
         }
     }
     // Drift inspection still runs when files are missing so status output can explain partial state.
@@ -167,6 +222,18 @@ function runDoctor(args) {
         warnings: issues.length === 0 ? [] : [`doctor found ${issues.length} issue(s)`],
     };
 }
+function mapBridgeDiagnosticCode(cause) {
+    if (cause === "Copilot bridge state manifest is missing.") {
+        return "BRIDGE_STATE_MISSING";
+    }
+    if (cause === "Copilot bridge runtime state exists but no active Copilot bridge provider is selected.") {
+        return "BRIDGE_STATE_STALE";
+    }
+    if (cause === "Copilot bridge state base URL does not match the provider runtime configuration.") {
+        return "PROVIDER_BASE_URL_MISMATCH";
+    }
+    return "BRIDGE_HEALTHCHECK_FAILED";
+}
 /**
  * Maps structured config consistency issues onto stable human-readable diagnostic text.
  */

package/dist/app/setup-codex.js

@@ -49,7 +49,7 @@ const MIN_CODEX_VERSION = "0.0.1";
 /**
  * Migrates unmanaged Codex config profiles into a managed providers.json registry.
  */
-function migrateCodex(args) {
+async function migrateCodex(args) {
     const available = (0, codex_cli_1.checkCodexAvailable)();
     if (!available.ok) {
         throw (0, errors_1.cliError)("CODEX_NOT_INSTALLED", "codex CLI is not available.", {
@@ -148,7 +148,7 @@ function migrateCodex(args) {
         },
     });
     // Re-run doctor on the final state so migrate returns immediate post-migration diagnostics.
-    const doctor = (0, run_doctor_1.runDoctor)({
+    const doctor = await (0, run_doctor_1.runDoctor)({
         codexDir: args.codexDir,
         configPath: args.configPath,
         providersPath: args.providersPath,