@minniexcode/codex-switch 0.0.7 → 0.0.9

package/dist/app/switch-provider.js

@@ -2,14 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.switchProvider = switchProvider;
 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 auth_repo_1 = require("../storage/auth-repo");
+const copilot_bridge_1 = require("../runtime/copilot-bridge");
+const copilot_installer_1 = require("../runtime/copilot-installer");
+const copilot_adapter_1 = require("../runtime/copilot-adapter");
 const run_mutation_1 = require("./run-mutation");
 /**
  * Switches the active Codex profile and rewrites auth.json for the target provider.
  */
-function switchProvider(args) {
+async function switchProvider(args) {
     const providers = (0, providers_repo_1.readProvidersFile)(args.providersPath);
     const provider = providers.providers[args.providerName];
     if (!provider) {
@@ -27,6 +31,76 @@ function switchProvider(args) {
             runtimeEnvKey: envKey,
         });
     }
+    if ((0, providers_1.isCopilotBridgeProvider)(provider)) {
+        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)();
+        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,
+                backupsDir: args.backupsDir,
+                latestBackupPath: args.latestBackupPath,
+                operation: "switch",
+                files: [
+                    { absolutePath: args.configPath, relativePath: "config.toml" },
+                    { absolutePath: args.authPath, relativePath: "auth.json" },
+                ],
+                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, nextProvider, existingAuth ?? undefined);
+                    return {
+                        provider: args.providerName,
+                        profile: nextProvider.profile,
+                        envKey: nextProvider.envKey,
+                        portChanged: bridge.portChanged,
+                        bridgePort: bridge.port,
+                    };
+                },
+            });
+        }
+        catch (error) {
+            if (!bridge.reused) {
+                (0, copilot_bridge_1.stopCopilotBridge)();
+            }
+            throw error;
+        }
+    }
     return (0, run_mutation_1.runMutation)({
         codexDir: args.codexDir,
         backupsDir: args.backupsDir,

package/dist/cli.js

@@ -9,7 +9,7 @@ const args_1 = require("./commands/args");
 const help_1 = require("./commands/help");
 const errors_1 = require("./domain/errors");
 const output_1 = require("./cli/output");
-const VERSION = "0.0.7";
+const VERSION = "0.0.8";
 /**
  * Prints the command help text to stdout.
  */

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");
@@ -58,6 +59,7 @@ const providers_1 = require("../domain/providers");
 const add_interactive_1 = require("../interaction/add-interactive");
 const interactive_1 = require("../interaction/interactive");
 const prompt_1 = require("../interaction/prompt");
+const copilot_installer_1 = require("../runtime/copilot-installer");
 const config_repo_1 = require("../storage/config-repo");
 const codex_paths_1 = require("../storage/codex-paths");
 const providers_repo_1 = require("../storage/providers-repo");
@@ -89,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);
@@ -155,6 +187,9 @@ async function handleRegisteredCommand(ctx, parsed, runtime = (0, prompt_1.creat
             if (!providerName) {
                 throw (0, errors_1.cliError)("PROVIDER_NOT_FOUND", "Missing provider name for switch command.");
             }
+            if ((0, args_1.hasFlag)(parsed.commandOptions, "--install-copilot-sdk")) {
+                throw (0, errors_1.cliError)("INVALID_ARGUMENT", "--install-copilot-sdk is only supported with add --copilot.");
+            }
             return (0, switch_provider_1.switchProvider)({
                 codexDir: paths.codexDir,
                 backupsDir: paths.backupsDir,
@@ -221,7 +256,22 @@ async function handleRegisteredCommand(ctx, parsed, runtime = (0, prompt_1.creat
             let note = (0, args_1.getSingleOption)(parsed.commandOptions, "--note", false);
             let tags = parsed.commandOptions.get("--tag") ?? [];
             let createProfile = (0, args_1.hasFlag)(parsed.commandOptions, "--create-profile");
-            if (!providerName || !profile || !apiKey) {
+            const copilot = (0, args_1.hasFlag)(parsed.commandOptions, "--copilot");
+            const bridgeHost = (0, args_1.getSingleOption)(parsed.commandOptions, "--bridge-host", false);
+            const bridgePortValue = (0, args_1.getSingleOption)(parsed.commandOptions, "--bridge-port", false);
+            const bridgeApiKey = (0, args_1.getSingleOption)(parsed.commandOptions, "--bridge-api-key", false);
+            let installCopilotSdk = (0, args_1.hasFlag)(parsed.commandOptions, "--install-copilot-sdk");
+            const bridgePort = bridgePortValue ? Number(bridgePortValue) : null;
+            if (copilot && apiKey) {
+                throw (0, errors_1.cliError)("INVALID_ARGUMENT", "--copilot does not allow --api-key. Use --bridge-api-key for the local bridge secret.");
+            }
+            if (bridgePortValue && (!Number.isInteger(bridgePort) || bridgePort === null || bridgePort <= 0)) {
+                throw (0, errors_1.cliError)("INVALID_ARGUMENT", "--bridge-port must be a positive integer.");
+            }
+            if (copilot && !installCopilotSdk && (0, interactive_1.canPrompt)(runtime, ctx.options.json) && !(0, copilot_installer_1.probeCopilotSdkInstall)().installed) {
+                installCopilotSdk = await runtime.confirmAction("The optional Copilot SDK runtime is not installed. Install it now?");
+            }
+            if (!providerName || !profile || (!apiKey && !copilot)) {
                 if (ctx.options.json || !runtime.isInteractive()) {
                     throw (0, add_interactive_1.createNonInteractiveAddError)();
                 }
@@ -251,12 +301,18 @@ async function handleRegisteredCommand(ctx, parsed, runtime = (0, prompt_1.creat
                 authPath: paths.authPath,
                 providerName,
                 profile,
-                apiKey,
+                apiKey: apiKey ?? "",
                 baseUrl,
                 model,
                 note,
                 tags,
                 createProfile,
+                copilot,
+                bridgeHost,
+                bridgePort,
+                bridgeApiKey,
+                installCopilotSdk,
+                interactive: (0, interactive_1.canPrompt)(runtime, ctx.options.json),
             });
         }
         case "edit": {

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"],
@@ -128,6 +170,7 @@ exports.COMMANDS = [
         usage: ["codexs status [--json] [--codex-dir <path>]"],
         details: [
             "Reports file presence, current profile, and whether the live profile is mapped.",
+            "When the active provider uses a local runtime bridge, status also reports bridge and SDK state.",
             "Surfaces config consistency signals without mutating any files.",
             "Use doctor for deeper diagnostics.",
         ],
@@ -160,6 +203,7 @@ exports.COMMANDS = [
         summary: "Add a provider with explicit flags or progressive TTY prompts.",
         usage: [
             "codexs add <provider> --profile <name> --api-key <key> [--base-url <url>] [--note <text>] [--tag <tag> ...]",
+            "codexs add <provider> --copilot --profile <name> [--bridge-host <host>] [--bridge-port <port>] [--bridge-api-key <secret>] [--install-copilot-sdk]",
             "codexs add <provider> --profile <name> --api-key <key> --create-profile --model <name> --base-url <url>",
             "codexs add [--profile <name>] [--api-key <key>] [--base-url <url>] [--note <text>] [--tag <tag> ...]",
         ],
@@ -170,8 +214,13 @@ exports.COMMANDS = [
             "Interactive tags use preset multi-select only.",
             "Automation and non-TTY environments must pass all required values explicitly.",
             "Creating a missing profile section requires --create-profile together with --model and --base-url.",
+            "Use --copilot to create a GitHub Copilot bridge provider backed by the official SDK.",
+        ],
+        examples: [
+            "codexs add packycode --profile packycode --api-key sk-xxx",
+            "codexs add copilot-main --copilot --profile copilot-main --install-copilot-sdk",
+            "codexs add",
         ],
-        examples: ["codexs add packycode --profile packycode --api-key sk-xxx", "codexs add packycode --profile packycode", "codexs add"],
     },
     {
         id: "switch",
@@ -184,6 +233,7 @@ exports.COMMANDS = [
             "When <provider> is omitted in a TTY, an interactive provider selector is shown.",
             "When <provider> is passed explicitly, switch proceeds directly without extra confirmation.",
             "Switch updates the active config profile and rewrites auth.json from the provider envKey/apiKey pair.",
+            "Copilot bridge providers probe the optional official SDK before switching and fail fast if it is missing.",
             "Backs up config.toml and auth.json, then rolls back on failure.",
         ],
         examples: ["codexs switch freemodel", "codexs switch packycode --json"],
@@ -252,7 +302,11 @@ exports.COMMANDS = [
         group: "recovery",
         summary: "Run configuration and environment diagnostics.",
         usage: ["codexs doctor [--json] [--codex-dir <path>]"],
-        details: ["Checks the expected config files, provider/profile consistency, and Codex CLI availability.", "Returns structured issues so users and AI agents can act on them."],
+        details: [
+            "Checks the expected config files, provider/profile consistency, and Codex CLI availability.",
+            "Copilot bridge providers add runtime dependency, auth, and bridge health diagnostics.",
+            "Returns structured issues so users and AI agents can act on them.",
+        ],
         examples: ["codexs doctor", "codexs doctor --json"],
     },
     {

package/dist/domain/providers.js

@@ -6,6 +6,9 @@ exports.sortProviders = sortProviders;
 exports.findProviderByProfile = findProviderByProfile;
 exports.findProvidersByProfile = findProvidersByProfile;
 exports.maskSecret = maskSecret;
+exports.isRuntimeBackedProvider = isRuntimeBackedProvider;
+exports.isCopilotBridgeProvider = isCopilotBridgeProvider;
+exports.buildCopilotBridgeBaseUrl = buildCopilotBridgeBaseUrl;
 /**
  * Validates and normalizes unknown JSON into the providers.json domain model.
  */
@@ -42,6 +45,13 @@ function validateProvidersShape(input) {
             (!Array.isArray(provider.tags) || provider.tags.some((tag) => typeof tag !== "string"))) {
             throw new Error(`Provider "${name}" has invalid tags.`);
         }
+        if (provider.runtime !== undefined) {
+            validateProviderRuntime(name, provider.runtime);
+            const expectedBaseUrl = buildCopilotBridgeBaseUrl(provider.runtime);
+            if (typeof provider.baseUrl !== "string" || provider.baseUrl.trim() !== expectedBaseUrl) {
+                throw new Error(`Provider "${name}" baseUrl must match runtime bridge base URL "${expectedBaseUrl}".`);
+            }
+        }
         // Normalize provider fields during validation so the persisted format stays clean.
         providers[name] = cleanProviderRecord({
             profile: provider.profile,
@@ -50,6 +60,7 @@ function validateProvidersShape(input) {
             baseUrl: provider.baseUrl,
             note: provider.note,
             tags: provider.tags,
+            runtime: provider.runtime,
         });
     }
     return { providers };
@@ -72,6 +83,18 @@ function cleanProviderRecord(record) {
     if (record.tags && record.tags.length > 0) {
         next.tags = record.tags.map((tag) => tag.trim()).filter((tag) => tag.length > 0);
     }
+    if (record.runtime) {
+        next.runtime = {
+            kind: record.runtime.kind,
+            upstream: record.runtime.upstream,
+            bridgeHost: record.runtime.bridgeHost.trim(),
+            bridgePort: record.runtime.bridgePort,
+            bridgePath: record.runtime.bridgePath,
+            premiumRequests: record.runtime.premiumRequests,
+            authSource: record.runtime.authSource,
+            sdkInstallMode: record.runtime.sdkInstallMode,
+        };
+    }
     return next;
 }
 /**
@@ -114,3 +137,54 @@ function maskSecret(value) {
     }
     return `${value.slice(0, 3)}***${value.slice(-2)}`;
 }
+/**
+ * Returns whether one provider record relies on an auxiliary runtime component.
+ */
+function isRuntimeBackedProvider(provider) {
+    return Boolean(provider.runtime);
+}
+/**
+ * Returns whether one provider uses the GitHub Copilot SDK bridge runtime.
+ */
+function isCopilotBridgeProvider(provider) {
+    return provider.runtime?.kind === "copilot-sdk-bridge";
+}
+/**
+ * Builds the canonical local bridge URL for one Copilot runtime provider.
+ */
+function buildCopilotBridgeBaseUrl(runtime) {
+    return `http://${runtime.bridgeHost}:${runtime.bridgePort}${runtime.bridgePath}`;
+}
+/**
+ * Validates one runtime-backed provider block.
+ */
+function validateProviderRuntime(name, runtime) {
+    if (!runtime || typeof runtime !== "object" || Array.isArray(runtime)) {
+        throw new Error(`Provider "${name}" has an invalid runtime block.`);
+    }
+    const record = runtime;
+    if (record.kind !== "copilot-sdk-bridge") {
+        throw new Error(`Provider "${name}" has an unsupported runtime kind.`);
+    }
+    if (record.upstream !== "github-copilot") {
+        throw new Error(`Provider "${name}" has an invalid runtime upstream.`);
+    }
+    if (typeof record.bridgeHost !== "string" || record.bridgeHost.trim() === "") {
+        throw new Error(`Provider "${name}" has an invalid runtime bridgeHost.`);
+    }
+    if (typeof record.bridgePort !== "number" || !Number.isInteger(record.bridgePort) || record.bridgePort <= 0) {
+        throw new Error(`Provider "${name}" has an invalid runtime bridgePort.`);
+    }
+    if (record.bridgePath !== "/v1") {
+        throw new Error(`Provider "${name}" has an invalid runtime bridgePath.`);
+    }
+    if (record.premiumRequests !== true) {
+        throw new Error(`Provider "${name}" must enable runtime premiumRequests.`);
+    }
+    if (record.authSource !== "official-sdk") {
+        throw new Error(`Provider "${name}" has an invalid runtime authSource.`);
+    }
+    if (record.sdkInstallMode !== "lazy") {
+        throw new Error(`Provider "${name}" has an invalid runtime sdkInstallMode.`);
+    }
+}

package/dist/runtime/copilot-adapter.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.probeCopilotSdkRuntime = probeCopilotSdkRuntime;
+exports.requireCopilotSdk = requireCopilotSdk;
+exports.readCopilotAuthState = readCopilotAuthState;
+exports.sendCopilotChatCompletion = sendCopilotChatCompletion;
+const errors_1 = require("../domain/errors");
+const copilot_sdk_loader_1 = require("./copilot-sdk-loader");
+const copilot_installer_1 = require("./copilot-installer");
+/**
+ * Probes whether the optional Copilot SDK runtime is installed and loadable.
+ */
+function probeCopilotSdkRuntime() {
+    const status = (0, copilot_installer_1.probeCopilotSdkInstall)();
+    if (!status.installed) {
+        return {
+            ok: false,
+            runtime: "copilot-sdk",
+            reason: "missing",
+            cause: "The optional Copilot SDK runtime is not installed.",
+            details: {
+                installDir: status.installDir,
+                packageName: status.packageName,
+            },
+        };
+    }
+    return {
+        ok: true,
+        runtime: "copilot-sdk",
+        version: status.packageVersion ?? undefined,
+        details: {
+            installDir: status.installDir,
+            packageName: status.packageName,
+        },
+    };
+}
+/**
+ * Loads the lazily installed Copilot SDK and returns the module.
+ */
+async function requireCopilotSdk() {
+    return (0, copilot_sdk_loader_1.loadCopilotSdk)();
+}
+/**
+ * Probes whether the lazily installed Copilot SDK can create a usable session.
+ */
+async function readCopilotAuthState() {
+    const runtime = probeCopilotSdkRuntime();
+    if (!runtime.ok) {
+        throw (0, errors_1.cliError)("COPILOT_SDK_MISSING", "The optional Copilot SDK runtime is not installed.", runtime.details);
+    }
+    const { client, session } = await createCopilotSession();
+    await stopCopilotClient(client);
+    return {
+        ready: Boolean(session),
+        source: "official-sdk",
+        mode: "session",
+    };
+}
+/**
+ * Executes a single chat-completions style request through the optional Copilot SDK when available.
+ */
+async function sendCopilotChatCompletion(args) {
+    const { client, session, sdk } = await createCopilotSession();
+    try {
+        const sendAndWait = resolveCallable(session, "sendAndWait") ?? resolveCallable(sdk, "sendAndWait");
+        if (!sendAndWait) {
+            throw (0, errors_1.cliError)("COPILOT_SDK_UNSUPPORTED", "The installed Copilot SDK does not expose a supported sendAndWait API.", {
+                provider: args.provider,
+            });
+        }
+        const prompt = Array.isArray(args.payload.messages)
+            ? args.payload.messages
+                .map((entry) => {
+                const message = entry;
+                return `${String(message.role ?? "user")}: ${String(message.content ?? "")}`;
+            })
+                .join("\n")
+            : "";
+        const result = await Promise.resolve(sendAndWait({ model: args.payload.model, prompt }));
+        const content = typeof result === "string"
+            ? result
+            : typeof result?.content === "string"
+                ? String(result.content)
+                : typeof result?.data === "object" &&
+                    typeof result.data.content === "string"
+                    ? String(result.data.content)
+                    : JSON.stringify(result);
+        return {
+            id: `copilot-${Date.now()}`,
+            object: "chat.completion",
+            created: Math.floor(Date.now() / 1000),
+            model: args.payload.model ?? "copilot",
+            choices: [
+                {
+                    index: 0,
+                    message: {
+                        role: "assistant",
+                        content,
+                    },
+                    finish_reason: "stop",
+                },
+            ],
+        };
+    }
+    finally {
+        await stopCopilotClient(client);
+    }
+}
+async function createCopilotSession() {
+    const sdk = (await requireCopilotSdk());
+    const client = createCopilotClient(sdk);
+    const createSession = resolveCallable(client ? client : null, "createSession") ?? resolveCallable(sdk, "createSession");
+    if (!createSession) {
+        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({})));
+        return {
+            sdk,
+            client,
+            session,
+        };
+    }
+    catch (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),
+        });
+    }
+}
+function createCopilotClient(sdk) {
+    const ClientCtor = resolveConstructor(sdk, "CopilotClient");
+    if (!ClientCtor) {
+        return null;
+    }
+    try {
+        return new ClientCtor();
+    }
+    catch (error) {
+        throw (0, errors_1.cliError)("COPILOT_SDK_UNSUPPORTED", "The installed Copilot SDK CopilotClient could not be constructed.", {
+            cause: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+async function stopCopilotClient(client) {
+    if (client && typeof client.stop === "function") {
+        await Promise.resolve(client.stop());
+    }
+}
+function resolveCallable(target, name) {
+    if (!target) {
+        return null;
+    }
+    const direct = target[name];
+    if (typeof direct === "function") {
+        return direct;
+    }
+    const nestedDefault = target.default;
+    if (nestedDefault && typeof nestedDefault[name] === "function") {
+        return nestedDefault[name];
+    }
+    return null;
+}
+function resolveConstructor(target, name) {
+    const direct = target[name];
+    if (typeof direct === "function") {
+        return direct;
+    }
+    const nestedDefault = target.default;
+    if (nestedDefault && typeof nestedDefault[name] === "function") {
+        return nestedDefault[name];
+    }
+    return null;
+}

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const copilot_bridge_1 = require("./copilot-bridge");
+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 ?? "41415");
+    const apiKey = process.env.CODEX_SWITCH_BRIDGE_API_KEY ?? "";
+    await (0, copilot_bridge_1.startCopilotBridgeServer)({
+        host,
+        port,
+        apiKey,
+        executeChatCompletion: async (payload) => (0, copilot_adapter_1.sendCopilotChatCompletion)({
+            provider,
+            payload,
+        }),
+    });
+}
+if (require.main === module) {
+    void main().catch((error) => {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exit(1);
+    });
+}