@minniexcode/codex-switch 0.0.7 → 0.0.8

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 ?? "4141");
+    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);
+    });
+}

package/dist/runtime/copilot-bridge.js

@@ -0,0 +1,433 @@
+"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.setCopilotBridgeSpawnImplementation = setCopilotBridgeSpawnImplementation;
+exports.resetCopilotBridgeSpawnImplementation = resetCopilotBridgeSpawnImplementation;
+exports.probeCopilotBridgeRuntime = probeCopilotBridgeRuntime;
+exports.ensureCopilotBridge = ensureCopilotBridge;
+exports.createCopilotBridgeRequestHandler = createCopilotBridgeRequestHandler;
+exports.startCopilotBridgeServer = startCopilotBridgeServer;
+exports.waitForCopilotBridgeHealth = waitForCopilotBridgeHealth;
+exports.stopCopilotBridge = stopCopilotBridge;
+const http = __importStar(require("node:http"));
+const net = __importStar(require("node:net"));
+const node_child_process_1 = require("node:child_process");
+const path = __importStar(require("node:path"));
+const providers_1 = require("../domain/providers");
+const errors_1 = require("../domain/errors");
+const runtime_state_repo_1 = require("../storage/runtime-state-repo");
+let spawnImplementation = node_child_process_1.spawn;
+/**
+ * Overrides the spawn implementation for bridge runtime tests.
+ */
+function setCopilotBridgeSpawnImplementation(spawnLike) {
+    spawnImplementation = spawnLike;
+}
+/**
+ * Restores the default spawn implementation for bridge runtime tests.
+ */
+function resetCopilotBridgeSpawnImplementation() {
+    spawnImplementation = node_child_process_1.spawn;
+}
+/**
+ * Returns the last known Copilot bridge runtime status.
+ */
+async function probeCopilotBridgeRuntime(provider) {
+    const state = (0, runtime_state_repo_1.readCopilotBridgeState)();
+    if (!provider || !(0, providers_1.isCopilotBridgeProvider)(provider)) {
+        return {
+            ok: false,
+            runtime: "copilot-bridge",
+            reason: "missing",
+            cause: "No active Copilot bridge provider is selected.",
+        };
+    }
+    const runtime = provider.runtime;
+    if (!runtime) {
+        throw (0, errors_1.cliError)("RUNTIME_PROVIDER_INVALID", "Provider runtime block is missing.", {
+            provider: state?.provider ?? null,
+        });
+    }
+    if (!state) {
+        return {
+            ok: false,
+            runtime: "copilot-bridge",
+            reason: "missing",
+            cause: "Copilot bridge state manifest is missing.",
+            details: {
+                expectedBaseUrl: (0, providers_1.buildCopilotBridgeBaseUrl)(runtime),
+            },
+        };
+    }
+    if (state.baseUrl !== (0, providers_1.buildCopilotBridgeBaseUrl)(runtime)) {
+        return {
+            ok: false,
+            runtime: "copilot-bridge",
+            reason: "failed",
+            cause: "Copilot bridge state base URL does not match the provider runtime configuration.",
+            details: {
+                stateBaseUrl: state.baseUrl,
+                providerBaseUrl: (0, providers_1.buildCopilotBridgeBaseUrl)(runtime),
+            },
+        };
+    }
+    const healthy = await healthcheckCopilotBridge(state.host, state.port);
+    if (!healthy.ok) {
+        return {
+            ok: false,
+            runtime: "copilot-bridge",
+            reason: "failed",
+            cause: healthy.cause,
+            details: state,
+        };
+    }
+    (0, runtime_state_repo_1.writeCopilotBridgeState)({
+        ...state,
+        lastHealthcheckAt: new Date().toISOString(),
+    });
+    return {
+        ok: true,
+        runtime: "copilot-bridge",
+        details: state,
+    };
+}
+/**
+ * Starts or reuses a Copilot bridge worker, then verifies its health before returning.
+ */
+async function ensureCopilotBridge(providerName, provider) {
+    if (!(0, providers_1.isCopilotBridgeProvider)(provider)) {
+        throw (0, errors_1.cliError)("RUNTIME_PROVIDER_INVALID", "Provider is not backed by a Copilot bridge runtime.", {
+            provider: providerName,
+        });
+    }
+    const runtime = provider.runtime;
+    if (!runtime) {
+        throw (0, errors_1.cliError)("RUNTIME_PROVIDER_INVALID", "Provider runtime block is missing.", {
+            provider: providerName,
+        });
+    }
+    const expectedBaseUrl = (0, providers_1.buildCopilotBridgeBaseUrl)(runtime);
+    const current = (0, runtime_state_repo_1.readCopilotBridgeState)();
+    if (current && current.provider === providerName && current.baseUrl === expectedBaseUrl) {
+        const healthy = await healthcheckCopilotBridge(current.host, current.port);
+        if (healthy.ok) {
+            (0, runtime_state_repo_1.writeCopilotBridgeState)({
+                ...current,
+                lastHealthcheckAt: new Date().toISOString(),
+            });
+            return {
+                baseUrl: expectedBaseUrl,
+                reused: true,
+            };
+        }
+    }
+    const portCheck = await checkPortAvailability(runtime.bridgeHost, runtime.bridgePort);
+    if (!portCheck.ok) {
+        throw (0, errors_1.cliError)("BRIDGE_PORT_CONFLICT", "Copilot bridge port is already in use.", {
+            provider: providerName,
+            host: runtime.bridgeHost,
+            port: runtime.bridgePort,
+            cause: portCheck.cause,
+        });
+    }
+    const workerPath = path.join(__dirname, "copilot-bridge-worker.js");
+    let child;
+    try {
+        child = spawnImplementation(process.execPath, [workerPath], {
+            detached: true,
+            stdio: "ignore",
+            env: {
+                ...process.env,
+                CODEX_SWITCH_BRIDGE_PROVIDER: providerName,
+                CODEX_SWITCH_BRIDGE_HOST: runtime.bridgeHost,
+                CODEX_SWITCH_BRIDGE_PORT: String(runtime.bridgePort),
+                CODEX_SWITCH_BRIDGE_API_KEY: provider.apiKey,
+                CODEX_SWITCH_BRIDGE_BASE_URL: expectedBaseUrl,
+            },
+        });
+    }
+    catch (error) {
+        throw (0, errors_1.cliError)("BRIDGE_START_FAILED", "Failed to start the Copilot bridge worker.", {
+            provider: providerName,
+            host: runtime.bridgeHost,
+            port: runtime.bridgePort,
+            cause: error instanceof Error ? error.message : String(error),
+        });
+    }
+    child.unref();
+    const startedAt = new Date().toISOString();
+    const healthy = await waitForCopilotBridgeStartup(child, runtime.bridgeHost, runtime.bridgePort, 15, 200);
+    if (!healthy.ok) {
+        (0, runtime_state_repo_1.clearCopilotBridgeState)();
+        if (healthy.reason === "start-failed") {
+            throw (0, errors_1.cliError)("BRIDGE_START_FAILED", "Copilot bridge worker exited before becoming healthy.", {
+                provider: providerName,
+                host: runtime.bridgeHost,
+                port: runtime.bridgePort,
+                cause: healthy.cause,
+            });
+        }
+        throw (0, errors_1.cliError)("BRIDGE_HEALTHCHECK_FAILED", "Copilot bridge did not become healthy after startup.", {
+            provider: providerName,
+            host: runtime.bridgeHost,
+            port: runtime.bridgePort,
+            cause: healthy.cause,
+        });
+    }
+    const state = {
+        provider: providerName,
+        pid: child.pid ?? null,
+        host: runtime.bridgeHost,
+        port: runtime.bridgePort,
+        baseUrl: expectedBaseUrl,
+        startedAt,
+        lastHealthcheckAt: new Date().toISOString(),
+    };
+    (0, runtime_state_repo_1.writeCopilotBridgeState)(state);
+    return {
+        baseUrl: expectedBaseUrl,
+        reused: false,
+    };
+}
+/**
+ * Creates an HTTP request handler implementing the minimal OpenAI-compatible bridge contract.
+ */
+function createCopilotBridgeRequestHandler(context) {
+    return async (request, response) => {
+        try {
+            const method = request.method ?? "GET";
+            const url = request.url ?? "/";
+            if (method === "GET" && url === "/healthz") {
+                response.writeHead(200, { "content-type": "application/json" });
+                response.end(JSON.stringify({ ok: true }));
+                return;
+            }
+            if (!isAuthorized(request, context.apiKey)) {
+                response.writeHead(401, { "content-type": "application/json" });
+                response.end(JSON.stringify({ error: { message: "Unauthorized" } }));
+                return;
+            }
+            if (method === "GET" && url === "/v1/models") {
+                response.writeHead(200, { "content-type": "application/json" });
+                response.end(JSON.stringify({ object: "list", data: [] }));
+                return;
+            }
+            if (method !== "POST" || url !== "/v1/chat/completions") {
+                response.writeHead(404, { "content-type": "application/json" });
+                response.end(JSON.stringify({ error: { message: "Not found" } }));
+                return;
+            }
+            const body = await readJsonBody(request);
+            const stream = Boolean(body.stream);
+            const payload = await context.executeChatCompletion(body);
+            if (stream) {
+                response.writeHead(200, {
+                    "content-type": "text/event-stream",
+                    "cache-control": "no-cache",
+                    connection: "keep-alive",
+                });
+                response.write(`data: ${JSON.stringify(payload)}\n\n`);
+                response.write("data: [DONE]\n\n");
+                response.end();
+                return;
+            }
+            response.writeHead(200, { "content-type": "application/json" });
+            response.end(JSON.stringify(payload));
+        }
+        catch (error) {
+            response.writeHead(500, { "content-type": "application/json" });
+            response.end(JSON.stringify({ error: { message: error instanceof Error ? error.message : String(error) } }));
+        }
+    };
+}
+/**
+ * Starts an in-process local bridge server. Primarily used by the worker entrypoint and tests.
+ */
+function startCopilotBridgeServer(args) {
+    return new Promise((resolve, reject) => {
+        const server = http.createServer(createCopilotBridgeRequestHandler({
+            apiKey: args.apiKey,
+            executeChatCompletion: args.executeChatCompletion,
+        }));
+        server.once("error", reject);
+        server.listen(args.port, args.host, () => {
+            server.off("error", reject);
+            resolve(server);
+        });
+    });
+}
+/**
+ * Polls the bridge health endpoint until it becomes available or the retry budget is exhausted.
+ */
+async function waitForCopilotBridgeHealth(host, port, attempts = 10, delayMs = 150) {
+    for (let index = 0; index < attempts; index += 1) {
+        const result = await healthcheckCopilotBridge(host, port);
+        if (result.ok) {
+            return result;
+        }
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+    return {
+        ok: false,
+        cause: "Timed out waiting for Copilot bridge health endpoint.",
+    };
+}
+/**
+ * Stops the currently persisted Copilot bridge worker when possible.
+ */
+function stopCopilotBridge() {
+    const state = (0, runtime_state_repo_1.readCopilotBridgeState)();
+    if (state?.pid) {
+        try {
+            process.kill(state.pid);
+        }
+        catch {
+            // Ignore best-effort bridge cleanup failures.
+        }
+    }
+    (0, runtime_state_repo_1.clearCopilotBridgeState)();
+}
+async function checkPortAvailability(host, port) {
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.once("error", (error) => {
+            resolve({
+                ok: false,
+                cause: error.message,
+            });
+        });
+        server.listen(port, host, () => {
+            server.close((error) => {
+                if (error) {
+                    resolve({
+                        ok: false,
+                        cause: error.message,
+                    });
+                    return;
+                }
+                resolve({ ok: true });
+            });
+        });
+    });
+}
+async function waitForCopilotBridgeStartup(child, host, port, attempts, delayMs) {
+    let startupFailure = null;
+    const onError = (error) => {
+        startupFailure = error.message;
+    };
+    const onExit = (code, signal) => {
+        startupFailure = `Worker exited with code ${String(code)} signal ${String(signal)}.`;
+    };
+    child.once("error", onError);
+    child.once("exit", onExit);
+    try {
+        for (let index = 0; index < attempts; index += 1) {
+            if (startupFailure !== null) {
+                return {
+                    ok: false,
+                    reason: "start-failed",
+                    cause: startupFailure,
+                };
+            }
+            const result = await healthcheckCopilotBridge(host, port);
+            if (result.ok) {
+                return result;
+            }
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+        if (startupFailure !== null) {
+            return {
+                ok: false,
+                reason: "start-failed",
+                cause: startupFailure,
+            };
+        }
+        return {
+            ok: false,
+            reason: "healthcheck-failed",
+            cause: "Timed out waiting for Copilot bridge health endpoint.",
+        };
+    }
+    finally {
+        child.off("error", onError);
+        child.off("exit", onExit);
+    }
+}
+async function healthcheckCopilotBridge(host, port) {
+    return new Promise((resolve) => {
+        const request = http.request({
+            host,
+            port,
+            method: "GET",
+            path: "/healthz",
+            timeout: 1000,
+        }, (response) => {
+            response.resume();
+            if (response.statusCode === 200) {
+                resolve({ ok: true });
+                return;
+            }
+            resolve({
+                ok: false,
+                cause: `Health endpoint returned status ${String(response.statusCode ?? 0)}.`,
+            });
+        });
+        request.on("error", (error) => {
+            resolve({
+                ok: false,
+                cause: error.message,
+            });
+        });
+        request.on("timeout", () => {
+            request.destroy(new Error("Health endpoint timed out."));
+        });
+        request.end();
+    });
+}
+async function readJsonBody(request) {
+    const chunks = [];
+    for await (const chunk of request) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+    }
+    const raw = Buffer.concat(chunks).toString("utf8");
+    return raw.trim() === "" ? {} : JSON.parse(raw);
+}
+function isAuthorized(request, expectedApiKey) {
+    const authorization = request.headers.authorization;
+    if (!authorization || !authorization.startsWith("Bearer ")) {
+        return false;
+    }
+    return authorization.slice("Bearer ".length) === expectedApiKey;
+}