@minniexcode/codex-switch 0.0.6 → 0.0.8

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;
+}

package/dist/runtime/copilot-installer.js

@@ -0,0 +1,125 @@
+"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.setCopilotInstallerSpawnImplementation = setCopilotInstallerSpawnImplementation;
+exports.resetCopilotInstallerSpawnImplementation = resetCopilotInstallerSpawnImplementation;
+exports.getCopilotRuntimeInstallDir = getCopilotRuntimeInstallDir;
+exports.getCopilotSdkPackageName = getCopilotSdkPackageName;
+exports.probeCopilotSdkInstall = probeCopilotSdkInstall;
+exports.installCopilotSdk = installCopilotSdk;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const errors_1 = require("../domain/errors");
+const COPILOT_SDK_PACKAGE = "@github/copilot-sdk";
+const COPILOT_SDK_VERSION = "latest";
+let spawnImplementation = node_child_process_1.spawnSync;
+/**
+ * Overrides the spawn implementation for runtime installer tests.
+ */
+function setCopilotInstallerSpawnImplementation(spawnLike) {
+    spawnImplementation = spawnLike;
+}
+/**
+ * Restores the default spawn implementation after tests.
+ */
+function resetCopilotInstallerSpawnImplementation() {
+    spawnImplementation = node_child_process_1.spawnSync;
+}
+/**
+ * Returns the user-level runtime directory used to lazily install the Copilot SDK.
+ */
+function getCopilotRuntimeInstallDir() {
+    const override = process.env.CODEX_SWITCH_COPILOT_RUNTIME_DIR;
+    if (override && override.trim() !== "") {
+        return path.resolve(override);
+    }
+    return path.join(os.homedir(), ".codex-switch", "runtimes", "copilot");
+}
+/**
+ * Returns the package name used by the Copilot runtime installer.
+ */
+function getCopilotSdkPackageName() {
+    return COPILOT_SDK_PACKAGE;
+}
+/**
+ * Reports whether the optional Copilot SDK runtime is currently installed.
+ */
+function probeCopilotSdkInstall() {
+    const installDir = getCopilotRuntimeInstallDir();
+    const packageJsonPath = path.join(installDir, "node_modules", "@github", "copilot-sdk", "package.json");
+    if (!fs.existsSync(packageJsonPath)) {
+        return {
+            installed: false,
+            installDir,
+            packageName: COPILOT_SDK_PACKAGE,
+            packageVersion: null,
+        };
+    }
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    return {
+        installed: true,
+        installDir,
+        packageName: COPILOT_SDK_PACKAGE,
+        packageVersion: packageJson.version ?? null,
+    };
+}
+/**
+ * Installs the optional Copilot SDK into the user-level runtime directory.
+ */
+function installCopilotSdk() {
+    const installDir = getCopilotRuntimeInstallDir();
+    fs.mkdirSync(installDir, { recursive: true });
+    const packageJsonPath = path.join(installDir, "package.json");
+    if (!fs.existsSync(packageJsonPath)) {
+        fs.writeFileSync(packageJsonPath, `${JSON.stringify({ name: "codex-switch-copilot-runtime", private: true, version: "0.0.0" }, null, 2)}\n`, "utf8");
+    }
+    const command = process.platform === "win32" ? "npm.cmd" : "npm";
+    const result = spawnImplementation(command, ["install", "--no-save", `${COPILOT_SDK_PACKAGE}@${COPILOT_SDK_VERSION}`], {
+        cwd: installDir,
+        stdio: "pipe",
+        encoding: "utf8",
+        shell: false,
+    });
+    if (result.status !== 0) {
+        throw (0, errors_1.cliError)("COPILOT_SDK_INSTALL_FAILED", "Failed to install the optional Copilot SDK runtime.", {
+            installDir,
+            packageName: COPILOT_SDK_PACKAGE,
+            cause: result.stderr || result.stdout || `npm exited with status ${String(result.status)}`,
+        });
+    }
+    return probeCopilotSdkInstall();
+}

package/dist/runtime/copilot-sdk-loader.js

@@ -0,0 +1,59 @@
+"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.getCopilotSdkEntrypoint = getCopilotSdkEntrypoint;
+exports.loadCopilotSdk = loadCopilotSdk;
+const path = __importStar(require("node:path"));
+const errors_1 = require("../domain/errors");
+const copilot_installer_1 = require("./copilot-installer");
+/**
+ * Dynamically resolves the lazily installed Copilot SDK entrypoint.
+ */
+function getCopilotSdkEntrypoint() {
+    return path.join((0, copilot_installer_1.getCopilotRuntimeInstallDir)(), "node_modules", "@github", "copilot-sdk");
+}
+/**
+ * Loads the Copilot SDK only when a Copilot runtime path is exercised.
+ */
+async function loadCopilotSdk() {
+    const status = (0, copilot_installer_1.probeCopilotSdkInstall)();
+    if (!status.installed) {
+        throw (0, errors_1.cliError)("COPILOT_SDK_MISSING", "The optional Copilot SDK runtime is not installed.", {
+            installDir: status.installDir,
+            packageName: status.packageName,
+        });
+    }
+    return Promise.resolve(`${getCopilotSdkEntrypoint()}`).then(s => __importStar(require(s)));
+}