@minniexcode/codex-switch 0.0.8 → 0.0.9

package/dist/app/add-provider.js

@@ -54,7 +54,7 @@ function addProvider(args) {
         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 ?? 4141;
+    const bridgePort = args.bridgePort ?? 41415;
     const runtime = args.copilot
         ? {
             kind: "copilot-sdk-bridge",

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

@@ -44,6 +44,7 @@ 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.
  */
@@ -69,7 +70,20 @@ async function getStatus(codexDir, configPath, providersPath, authPath) {
     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 copilotBridge = activeProvider && (0, providers_1.isCopilotBridgeProvider)(activeProvider) ? await (0, copilot_bridge_1.probeCopilotBridgeRuntime)(activeProvider) : null;
+    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,
@@ -103,6 +117,7 @@ async function getStatus(codexDir, configPath, providersPath, authPath) {
             },
             copilotAuth,
             copilotBridge,
+            copilotRuntimeState: runtimeState,
             liveState,
             auth: authState,
             configProfiles: configViews,

package/dist/app/run-doctor.js

@@ -46,6 +46,7 @@ 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.
  */
@@ -102,6 +103,7 @@ async 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",
@@ -161,9 +163,7 @@ async function runDoctor(args) {
                 const bridge = await (0, copilot_bridge_1.probeCopilotBridgeRuntime)(activeProvider);
                 if (!bridge.ok) {
                     issues.push({
-                        code: bridge.cause === "Copilot bridge state base URL does not match the provider runtime configuration."
-                            ? "PROVIDER_BASE_URL_MISMATCH"
-                            : "BRIDGE_HEALTHCHECK_FAILED",
+                        code: mapBridgeDiagnosticCode(bridge.cause),
                         message: bridge.cause,
                         ...(bridge.details ?? {}),
                     });
@@ -171,6 +171,26 @@ async function runDoctor(args) {
             }
         }
     }
+    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.
     const drift = (0, runtime_state_1.inspectLiveStateDrift)(currentProfile, providers);
     const codexCheck = (0, codex_probe_1.probeCodexRuntime)();
@@ -202,6 +222,18 @@ async 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/switch-provider.js

@@ -41,6 +41,16 @@ async function switchProvider(args) {
         }
         await (0, copilot_adapter_1.readCopilotAuthState)();
         const bridge = await (0, copilot_bridge_1.ensureCopilotBridge)(args.providerName, provider);
+        const nextProvider = bridge.portChanged
+            ? (0, providers_1.cleanProviderRecord)({
+                ...provider,
+                baseUrl: bridge.baseUrl,
+                runtime: {
+                    ...provider.runtime,
+                    bridgePort: bridge.port,
+                },
+            })
+            : provider;
         try {
             return (0, run_mutation_1.runMutation)({
                 codexDir: args.codexDir,
@@ -54,14 +64,32 @@ async function switchProvider(args) {
                 mutate: () => {
                     const configPlan = (0, config_repo_1.createConfigMutationPlan)(document, {
                         setActiveProfile: provider.profile,
+                        upsertModelProviders: bridge.portChanged
+                            ? {
+                                [provider.profile]: {
+                                    baseUrl: (0, providers_1.buildCopilotBridgeBaseUrl)(nextProvider.runtime),
+                                    envKey,
+                                },
+                            }
+                            : undefined,
                     });
+                    if (bridge.portChanged) {
+                        (0, providers_repo_1.writeProvidersFile)(args.providersPath, {
+                            providers: {
+                                ...providers.providers,
+                                [args.providerName]: nextProvider,
+                            },
+                        });
+                    }
                     (0, config_repo_1.applyConfigMutation)(args.configPath, document, configPlan);
                     const existingAuth = (0, auth_repo_1.readAuthFileIfExists)(args.authPath);
-                    (0, auth_repo_1.writeAuthFile)(args.authPath, provider, existingAuth ?? undefined);
+                    (0, auth_repo_1.writeAuthFile)(args.authPath, nextProvider, existingAuth ?? undefined);
                     return {
                         provider: args.providerName,
-                        profile: provider.profile,
-                        envKey: provider.envKey,
+                        profile: nextProvider.profile,
+                        envKey: nextProvider.envKey,
+                        portChanged: bridge.portChanged,
+                        bridgePort: bridge.port,
                     };
                 },
             });

package/dist/commands/handlers.js

@@ -48,6 +48,7 @@ const list_providers_1 = require("../app/list-providers");
 const remove_provider_1 = require("../app/remove-provider");
 const rollback_backup_1 = require("../app/rollback-backup");
 const run_doctor_1 = require("../app/run-doctor");
+const bridge_1 = require("../app/bridge");
 const setup_codex_1 = require("../app/setup-codex");
 const show_config_1 = require("../app/show-config");
 const show_provider_1 = require("../app/show-provider");
@@ -90,6 +91,36 @@ async function handleRegisteredCommand(ctx, parsed, runtime = (0, prompt_1.creat
             return (0, get_current_profile_1.getCurrentProfile)(paths.configPath);
         case "status":
             return (0, get_status_1.getStatus)(paths.codexDir, paths.configPath, paths.providersPath, paths.authPath);
+        case "bridge-start": {
+            const providerName = parsed.positionals[0] ?? null;
+            return (0, bridge_1.startBridge)({
+                providersPath: paths.providersPath,
+                configPath: paths.configPath,
+                providerName,
+                runtime,
+                json: ctx.options.json,
+            });
+        }
+        case "bridge-stop": {
+            const providerName = parsed.positionals[0] ?? null;
+            return (0, bridge_1.stopBridge)({
+                providersPath: paths.providersPath,
+                configPath: paths.configPath,
+                providerName,
+                runtime,
+                json: ctx.options.json,
+            });
+        }
+        case "bridge-status": {
+            const providerName = parsed.positionals[0] ?? null;
+            return (0, bridge_1.statusBridge)({
+                providersPath: paths.providersPath,
+                configPath: paths.configPath,
+                providerName,
+                runtime,
+                json: ctx.options.json,
+            });
+        }
         case "init": {
             let codexDir = ctx.options.codexDir;
             const candidates = (0, config_repo_1.findCodexDirCandidates)(ctx.options.codexDirExplicit ? ctx.options.codexDir : null);

package/dist/commands/help.js

@@ -63,6 +63,7 @@ function buildHelpText(commandName) {
             "  codexs migrate",
             "  codexs list",
             "  codexs switch",
+            "  codexs bridge start",
             "  codexs add packycode --profile packycode --api-key sk-xxx",
             "  codexs config show",
             "  codexs remove freemodel",

package/dist/commands/registry.js

@@ -41,6 +41,48 @@ exports.COMMANDS = [
         ],
         examples: ["codexs config list-profiles", "codexs config list-profiles --json"],
     },
+    {
+        id: "bridge-start",
+        tokens: ["bridge", "start"],
+        handler: handlers_1.handleRegisteredCommand,
+        group: "write",
+        summary: "Start or reuse the managed Copilot bridge.",
+        usage: ["codexs bridge start [provider] [--json] [--codex-dir <path>]"],
+        details: [
+            "Resolves a Copilot bridge provider by explicit name, active provider, sole provider, or TTY selection.",
+            "Reuses a healthy bridge for the same provider and replaces a different managed provider when needed.",
+            "If the preferred port is occupied, automatically selects another free 5-digit port and persists it.",
+        ],
+        examples: ["codexs bridge start", "codexs bridge start copilot-main"],
+    },
+    {
+        id: "bridge-stop",
+        tokens: ["bridge", "stop"],
+        handler: handlers_1.handleRegisteredCommand,
+        group: "recovery",
+        summary: "Stop the managed Copilot bridge.",
+        usage: ["codexs bridge stop [provider] [--json] [--codex-dir <path>]"],
+        details: [
+            "Prefers the runtime-state instance when present and uses an explicit provider as a guard.",
+            "Clears the runtime-state manifest without mutating providers.json or auth.json.",
+            "Is idempotent when no managed bridge is currently running.",
+        ],
+        examples: ["codexs bridge stop", "codexs bridge stop copilot-main"],
+    },
+    {
+        id: "bridge-status",
+        tokens: ["bridge", "status"],
+        handler: handlers_1.handleRegisteredCommand,
+        group: "read",
+        summary: "Inspect the managed Copilot bridge.",
+        usage: ["codexs bridge status [provider] [--json] [--codex-dir <path>]"],
+        details: [
+            "Reports runtime-state, provider binding, and whether the live worker matches the expected provider.",
+            "Prefers the runtime-state instance when one is present.",
+            "Uses an explicit provider as a guard instead of silently switching targets.",
+        ],
+        examples: ["codexs bridge status", "codexs bridge status copilot-main"],
+    },
     {
         id: "init",
         tokens: ["init"],

package/dist/runtime/copilot-bridge-worker.js

@@ -5,7 +5,7 @@ const copilot_adapter_1 = require("./copilot-adapter");
 async function main() {
     const provider = process.env.CODEX_SWITCH_BRIDGE_PROVIDER ?? "copilot";
     const host = process.env.CODEX_SWITCH_BRIDGE_HOST ?? "127.0.0.1";
-    const port = Number(process.env.CODEX_SWITCH_BRIDGE_PORT ?? "4141");
+    const port = Number(process.env.CODEX_SWITCH_BRIDGE_PORT ?? "41415");
     const apiKey = process.env.CODEX_SWITCH_BRIDGE_API_KEY ?? "";
     await (0, copilot_bridge_1.startCopilotBridgeServer)({
         host,