@minniexcode/codex-switch 0.2.0 → 0.2.2

package/dist/runtime/copilot-adapter.js

@@ -1,617 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventEmitter = void 0;
-exports.probeCopilotSdkRuntime = probeCopilotSdkRuntime;
-exports.requireCopilotSdk = requireCopilotSdk;
-exports.readCopilotAuthState = readCopilotAuthState;
-exports.createCopilotRuntimeClient = createCopilotRuntimeClient;
-exports.startCopilotRuntimeClient = startCopilotRuntimeClient;
-exports.stopCopilotRuntimeClient = stopCopilotRuntimeClient;
-exports.sendCopilotChatCompletion = sendCopilotChatCompletion;
-const node_events_1 = require("node:events");
-Object.defineProperty(exports, "EventEmitter", { enumerable: true, get: function () { return node_events_1.EventEmitter; } });
-const errors_1 = require("../domain/errors");
-const copilot_sdk_loader_1 = require("./copilot-sdk-loader");
-const copilot_installer_1 = require("./copilot-installer");
-const copilot_cli_1 = require("./copilot-cli");
-const DEFAULT_UPSTREAM_TIMEOUT_MS = 300000;
-/**
- * Probes whether the optional Copilot SDK runtime is installed, supported, and shaped correctly.
- */
-function probeCopilotSdkRuntime(runtimesDir) {
-    const nodeStatus = safeCopilotNodeRuntimeStatus();
-    if (!nodeStatus.ok) {
-        return nodeStatus.availability;
-    }
-    const status = (0, copilot_installer_1.probeCopilotSdkInstall)(runtimesDir);
-    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,
-            },
-        };
-    }
-    if (!(0, copilot_installer_1.isSupportedCopilotSdkVersion)(status.packageVersion)) {
-        return {
-            ok: false,
-            runtime: "copilot-sdk",
-            reason: "unsupported",
-            version: status.packageVersion ?? undefined,
-            cause: `The installed Copilot SDK version is unsupported. Install ${status.packageName}@${(0, copilot_installer_1.getSupportedCopilotSdkVersion)()}.`,
-            details: {
-                installDir: status.installDir,
-                packageName: status.packageName,
-                packageVersion: status.packageVersion,
-                supportedVersion: (0, copilot_installer_1.getSupportedCopilotSdkVersion)(),
-            },
-        };
-    }
-    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(runtimesDir) {
-    return (0, copilot_sdk_loader_1.loadCopilotSdk)(runtimesDir);
-}
-/**
- * Probes Copilot auth readiness through the SDK client status endpoint.
- */
-async function readCopilotAuthState(runtimesDir) {
-    const runtime = probeCopilotSdkRuntime(runtimesDir);
-    if (!runtime.ok) {
-        throw (0, errors_1.cliError)(runtime.reason === "unsupported" ? "COPILOT_SDK_VERSION_UNSUPPORTED" : "COPILOT_SDK_MISSING", runtime.cause, runtime.details);
-    }
-    const runtimeClient = await createCopilotRuntimeClient(runtimesDir);
-    try {
-        await startCopilotClient(runtimeClient.client);
-        const getAuthStatus = resolveCallable(runtimeClient.client, "getAuthStatus");
-        if (!getAuthStatus) {
-            throw (0, errors_1.cliError)("COPILOT_SDK_API_UNSUPPORTED", "The installed Copilot SDK does not expose CopilotClient.getAuthStatus().", {});
-        }
-        const status = await Promise.resolve(getAuthStatus());
-        if (!isAuthReady(status)) {
-            throw (0, errors_1.cliError)("COPILOT_AUTH_REQUIRED", "Copilot authentication is required before the local bridge can be used.", {
-                status,
-            });
-        }
-        return {
-            ready: true,
-            source: "official-sdk",
-            mode: "auth-status",
-        };
-    }
-    finally {
-        await stopCopilotClient(runtimeClient.client);
-    }
-}
-/**
- * Creates one long-lived Copilot SDK client for bridge workers.
- */
-async function createCopilotRuntimeClient(runtimesDir) {
-    (0, copilot_installer_1.assertCopilotNodeRuntimeSupported)();
-    const runtime = probeCopilotSdkRuntime(runtimesDir);
-    if (!runtime.ok) {
-        throw (0, errors_1.cliError)(runtime.reason === "unsupported" ? "COPILOT_SDK_VERSION_UNSUPPORTED" : "COPILOT_SDK_MISSING", runtime.cause, runtime.details);
-    }
-    const sdk = (await requireCopilotSdk(runtimesDir));
-    const client = createCopilotClient(sdk, runtimesDir);
-    assertCopilotSdkApiContract(sdk, client);
-    return { sdk, client };
-}
-/**
- * Starts a Copilot SDK client if the installed SDK exposes an explicit start hook.
- */
-async function startCopilotRuntimeClient(runtimeClient) {
-    await startCopilotClient(runtimeClient.client);
-}
-/**
- * Stops a Copilot SDK client.
- */
-async function stopCopilotRuntimeClient(runtimeClient) {
-    await stopCopilotClient(runtimeClient.client);
-}
-/**
- * Executes one OpenAI-compatible request through a fresh Copilot session.
- */
-async function sendCopilotChatCompletion(args) {
-    const ownsClient = !args.runtimeClient;
-    const runtimeClient = args.runtimeClient ?? await createCopilotRuntimeClient(args.runtimesDir);
-    if (ownsClient) {
-        await startCopilotRuntimeClient(runtimeClient);
-    }
-    let session = null;
-    try {
-        session = await createCopilotSession(runtimeClient, args.payload);
-        const prompt = buildPrompt(args.payload);
-        const timeoutMs = args.timeoutMs ?? DEFAULT_UPSTREAM_TIMEOUT_MS;
-        const result = await sendSessionRequest(session, prompt, timeoutMs, args.onStreamEvent);
-        const content = extractCopilotContent(result);
-        return {
-            id: `copilot-${Date.now()}`,
-            object: "chat.completion",
-            created: Math.floor(Date.now() / 1000),
-            model: typeof args.payload.model === "string" ? args.payload.model : "copilot",
-            choices: [
-                {
-                    index: 0,
-                    message: {
-                        role: "assistant",
-                        content,
-                    },
-                    finish_reason: "stop",
-                },
-            ],
-        };
-    }
-    finally {
-        if (session) {
-            await disconnectCopilotSession(session);
-        }
-        if (ownsClient) {
-            await stopCopilotRuntimeClient(runtimeClient);
-        }
-    }
-}
-async function createCopilotSession(runtimeClient, payload) {
-    const createSession = resolveCallable(runtimeClient.client, "createSession");
-    if (!createSession) {
-        throw (0, errors_1.cliError)("COPILOT_SDK_API_UNSUPPORTED", "The installed Copilot SDK does not expose CopilotClient.createSession().", {});
-    }
-    try {
-        const session = await Promise.resolve(createSession({
-            model: typeof payload.model === "string" ? payload.model : undefined,
-            streaming: true,
-            ...createSessionOptions(runtimeClient.sdk),
-        }));
-        if (!session || typeof session !== "object") {
-            throw (0, errors_1.cliError)("COPILOT_SDK_API_UNSUPPORTED", "The installed Copilot SDK returned an invalid CopilotSession.", {});
-        }
-        assertCopilotSessionContract(session);
-        return session;
-    }
-    catch (error) {
-        if (isCliError(error)) {
-            throw error;
-        }
-        if (classifyCopilotSessionError(error) === "unsupported") {
-            throw (0, errors_1.cliError)("COPILOT_SDK_API_UNSUPPORTED", "The installed Copilot SDK does not expose a compatible session API.", {
-                cause: error instanceof Error ? error.message : String(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),
-        });
-    }
-}
-async function sendSessionRequest(session, prompt, timeoutMs, onStreamEvent) {
-    const sendAndWait = resolveCallable(session, "sendAndWait");
-    const send = resolveCallable(session, "send");
-    if (!sendAndWait && !send) {
-        throw (0, errors_1.cliError)("COPILOT_SDK_API_UNSUPPORTED", "The installed Copilot SDK session does not expose sendAndWait() or send().", {});
-    }
-    const deltaHandler = (event) => {
-        const delta = extractDelta(event);
-        if (delta) {
-            onStreamEvent?.({ type: "delta", delta });
-        }
-    };
-    const runtimeHandler = (event) => {
-        for (const runtimeEvent of mapCopilotRuntimeEvent(event)) {
-            onStreamEvent?.({ type: "runtime", event: runtimeEvent });
-            if (runtimeEvent.type === "assistant.message_delta" && runtimeEvent.text.length > 0) {
-                onStreamEvent?.({ type: "delta", delta: runtimeEvent.text });
-            }
-        }
-    };
-    if (onStreamEvent && session.on) {
-        session.on("event", runtimeHandler);
-        session.on("data", deltaHandler);
-        session.on("message", deltaHandler);
-        session.on("delta", deltaHandler);
-    }
-    try {
-        const sendPromise = Promise.resolve(sendAndWait ? sendAndWait({ prompt }, timeoutMs) : send({ prompt }));
-        const result = await withTimeout(sendPromise, timeoutMs, async () => {
-            await abortCopilotSession(session);
-        });
-        if (onStreamEvent) {
-            onStreamEvent({ type: "done", text: extractCopilotContent(result) });
-        }
-        return result;
-    }
-    finally {
-        if (onStreamEvent && session.off) {
-            session.off("event", runtimeHandler);
-            session.off("data", deltaHandler);
-            session.off("message", deltaHandler);
-            session.off("delta", deltaHandler);
-        }
-    }
-}
-async function withTimeout(promise, timeoutMs, onTimeout) {
-    let timeout = null;
-    try {
-        return await Promise.race([
-            promise,
-            new Promise((_resolve, reject) => {
-                timeout = setTimeout(() => {
-                    void onTimeout().finally(() => {
-                        reject((0, errors_1.cliError)("BRIDGE_UPSTREAM_TIMEOUT", "Copilot upstream request timed out.", { timeoutMs }));
-                    });
-                }, timeoutMs);
-            }),
-        ]);
-    }
-    finally {
-        if (timeout) {
-            clearTimeout(timeout);
-        }
-    }
-}
-function createSessionOptions(sdk) {
-    const approveAll = resolveApproveAll(sdk);
-    if (approveAll) {
-        return {
-            onPermissionRequest: (request) => approveAll(request),
-        };
-    }
-    throw (0, errors_1.cliError)("COPILOT_SDK_API_UNSUPPORTED", "The installed Copilot SDK does not expose an approveAll permission handler.", {});
-}
-function createCopilotClient(sdk, runtimesDir) {
-    const ClientCtor = resolveConstructor(sdk, "CopilotClient");
-    if (!ClientCtor) {
-        throw (0, errors_1.cliError)("COPILOT_SDK_API_UNSUPPORTED", "The installed Copilot SDK does not expose CopilotClient.", {});
-    }
-    const runtimeConnection = resolveRuntimeConnectionFactory(sdk);
-    if (!runtimeConnection?.forStdio) {
-        throw (0, errors_1.cliError)("COPILOT_SDK_API_UNSUPPORTED", "The installed Copilot SDK does not expose RuntimeConnection.forStdio().", {});
-    }
-    const runtimeInvocation = (0, copilot_cli_1.resolveCopilotSdkRuntimeInvocation)(runtimesDir);
-    if (!runtimeInvocation) {
-        throw (0, errors_1.cliError)("COPILOT_SDK_API_UNSUPPORTED", "The installed Copilot runtime is missing the @github/copilot npm loader required by the SDK.", {
-            expectedRuntimeFile: "node_modules/@github/copilot/npm-loader.js",
-        });
-    }
-    try {
-        return new ClientCtor({
-            connection: runtimeConnection.forStdio({
-                path: runtimeInvocation.path,
-                args: runtimeInvocation.args,
-            }),
-        });
-    }
-    catch (error) {
-        throw (0, errors_1.cliError)("COPILOT_SDK_API_UNSUPPORTED", "The installed Copilot SDK CopilotClient could not be constructed.", {
-            cause: error instanceof Error ? error.message : String(error),
-        });
-    }
-}
-function assertCopilotSdkApiContract(sdk, client) {
-    const createSession = resolveCallable(client, "createSession");
-    const getAuthStatus = resolveCallable(client, "getAuthStatus");
-    if (!createSession || !getAuthStatus) {
-        throw (0, errors_1.cliError)("COPILOT_SDK_API_UNSUPPORTED", "The installed Copilot SDK does not expose the required CopilotClient API.", {
-            hasCreateSession: Boolean(createSession),
-            hasGetAuthStatus: Boolean(getAuthStatus),
-        });
-    }
-    if (!resolveApproveAll(sdk)) {
-        throw (0, errors_1.cliError)("COPILOT_SDK_API_UNSUPPORTED", "The installed Copilot SDK does not expose a supported permission handler.", {});
-    }
-}
-function assertCopilotSessionContract(session) {
-    const hasSendAndWait = typeof session.sendAndWait === "function";
-    const hasSend = typeof session.send === "function";
-    const hasAbort = typeof session.abort === "function";
-    if ((!hasSendAndWait && !hasSend) || !hasAbort) {
-        throw (0, errors_1.cliError)("COPILOT_SDK_API_UNSUPPORTED", "The installed Copilot SDK session does not expose the required request API.", {
-            hasSendAndWait,
-            hasSend,
-            hasAbort,
-        });
-    }
-}
-async function startCopilotClient(client) {
-    const start = resolveCallable(client, "start");
-    if (start) {
-        await Promise.resolve(start());
-    }
-}
-async function stopCopilotClient(client) {
-    const stop = resolveCallable(client, "stop");
-    if (stop) {
-        await Promise.resolve(stop());
-    }
-}
-async function abortCopilotSession(session) {
-    const abort = resolveCallable(session, "abort");
-    if (abort) {
-        try {
-            await Promise.resolve(abort());
-        }
-        catch {
-            // Session may already be closed or unknown — safe to ignore
-        }
-    }
-}
-async function disconnectCopilotSession(session) {
-    const disconnect = resolveCallable(session, "disconnect");
-    if (disconnect) {
-        await Promise.resolve(disconnect());
-    }
-}
-function buildPrompt(payload) {
-    if (Array.isArray(payload.messages)) {
-        return payload.messages
-            .map((entry) => {
-            const message = entry;
-            return `${String(message.role ?? "user")}: ${String(message.content ?? "")}`;
-        })
-            .join("\n");
-    }
-    if (typeof payload.prompt === "string") {
-        return payload.prompt;
-    }
-    return "";
-}
-function extractCopilotContent(result) {
-    if (typeof result === "string") {
-        return result;
-    }
-    if (!result || typeof result !== "object") {
-        return JSON.stringify(result);
-    }
-    const record = result;
-    if (typeof record.content === "string") {
-        return record.content;
-    }
-    if (typeof record.text === "string") {
-        return record.text;
-    }
-    if (typeof record.message === "string") {
-        return record.message;
-    }
-    if (record.data && typeof record.data === "object") {
-        const data = record.data;
-        if (typeof data.content === "string") {
-            return data.content;
-        }
-        if (typeof data.text === "string") {
-            return data.text;
-        }
-    }
-    return JSON.stringify(result);
-}
-function extractDelta(event) {
-    if (typeof event === "string") {
-        return event;
-    }
-    if (!event || typeof event !== "object") {
-        return null;
-    }
-    const record = event;
-    for (const key of ["delta", "text", "content"]) {
-        if (typeof record[key] === "string") {
-            return record[key];
-        }
-    }
-    return null;
-}
-/**
- * Maps SDK session events into the bridge's stable process-event contract.
- */
-function mapCopilotRuntimeEvent(event) {
-    if (!event || typeof event !== "object") {
-        return [];
-    }
-    const record = event;
-    const sdkType = readString(record, ["type", "event", "name", "eventName"]) ?? "unknown";
-    const normalizedType = sdkType.replace(/_/g, ".").toLowerCase();
-    const text = readString(record, ["text", "delta", "content", "message", "summary", "description"]);
-    const name = readString(record, ["toolName", "tool", "name"]);
-    const requestId = readString(record, ["requestId", "id", "callId"]);
-    const kind = readString(record, ["kind", "permission", "permissionKind"]);
-    const success = readBoolean(record, ["success", "ok"]);
-    const approved = readBoolean(record, ["approved", "allowed", "accepted"]);
-    const summary = truncateForBridgeLog(text ?? summarizeUnknownObject(record), 600);
-    if (normalizedType === "assistant.intent") {
-        return [{ type: "assistant.intent", text: summary }];
-    }
-    if (normalizedType === "assistant.message.delta" || normalizedType === "assistant.message_delta") {
-        return [{ type: "assistant.message_delta", text: text ?? "" }];
-    }
-    if (normalizedType === "assistant.reasoning.delta" || normalizedType === "assistant.reasoning_delta" || normalizedType === "reasoning.delta") {
-        return [{ type: "assistant.reasoning_delta", text: summary }];
-    }
-    if (normalizedType === "tool.execution.start" || normalizedType === "tool.execution_start") {
-        return [{ type: "tool.execution_start", name, requestId, summary: summary || `Tool started: ${name ?? "unknown"}` }];
-    }
-    if (normalizedType === "tool.execution.progress" || normalizedType === "tool.execution_progress") {
-        return [{ type: "tool.execution_progress", name, requestId, summary }];
-    }
-    if (normalizedType === "tool.execution.partial.result" || normalizedType === "tool.execution.partial_result") {
-        return [{ type: "tool.execution_partial_result", name, requestId, summary }];
-    }
-    if (normalizedType === "tool.execution.complete" || normalizedType === "tool.execution_complete") {
-        return [{ type: "tool.execution_complete", name, requestId, success, summary: summary || `Tool completed: ${name ?? "unknown"}` }];
-    }
-    if (normalizedType === "permission.requested" || normalizedType === "permission.request") {
-        return [{ type: "permission.requested", kind, requestId, summary: summary || `Copilot requested permission: ${kind ?? "unknown"}` }];
-    }
-    if (normalizedType === "permission.completed" || normalizedType === "permission.complete") {
-        return [{ type: "permission.completed", kind, requestId, approved, summary }];
-    }
-    if (normalizedType === "user.input.requested" || normalizedType === "user.input_request" || normalizedType === "user_input.requested") {
-        return [{ type: "user_input.requested", requestId, summary }];
-    }
-    if (normalizedType === "exit.plan.mode.requested" || normalizedType === "exit_plan_mode.requested") {
-        return [{ type: "exit_plan_mode.requested", requestId, summary }];
-    }
-    if (normalizedType === "session.error" || normalizedType === "error") {
-        return [{ type: "session.error", summary }];
-    }
-    if (normalizedType === "session.idle" || normalizedType === "idle") {
-        return [{ type: "session.idle", summary: summary || "Copilot session is idle." }];
-    }
-    return [{ type: "session.unknown", sdkType, summary }];
-}
-function readString(record, keys) {
-    for (const key of keys) {
-        const value = record[key];
-        if (typeof value === "string" && value.length > 0) {
-            return value;
-        }
-        if (value && typeof value === "object") {
-            const nested = value;
-            for (const nestedKey of ["name", "id", "text", "content", "message", "summary"]) {
-                if (typeof nested[nestedKey] === "string" && nested[nestedKey].length > 0) {
-                    return nested[nestedKey];
-                }
-            }
-        }
-    }
-    return undefined;
-}
-function readBoolean(record, keys) {
-    for (const key of keys) {
-        if (typeof record[key] === "boolean") {
-            return record[key];
-        }
-    }
-    return undefined;
-}
-function summarizeUnknownObject(record) {
-    return JSON.stringify(record, (key, value) => {
-        if (isSensitiveKey(key)) {
-            return "[redacted]";
-        }
-        if (typeof value === "string") {
-            return redactSensitiveText(value);
-        }
-        return value;
-    });
-}
-function redactSensitiveText(value) {
-    if (/api[_-]?key|token|authorization|bearer\s+|sk-[a-z0-9_-]+/i.test(value)) {
-        return "[redacted]";
-    }
-    return value;
-}
-function isSensitiveKey(key) {
-    return /^(api[_-]?key|token|access[_-]?token|refresh[_-]?token|authorization|secret|password)$/i.test(key);
-}
-function truncateForBridgeLog(value, maxLength) {
-    if (value.length <= maxLength) {
-        return value;
-    }
-    return `${value.slice(0, maxLength)}... [truncated]`;
-}
-function isAuthReady(status) {
-    if (status === true) {
-        return true;
-    }
-    if (!status || typeof status !== "object") {
-        return false;
-    }
-    const record = status;
-    if (record.ready === true || record.isAuthenticated === true || record.authenticated === true) {
-        return true;
-    }
-    if (typeof record.status === "string" && /^(ok|ready|authenticated|logged_in)$/i.test(record.status)) {
-        return true;
-    }
-    return false;
-}
-function classifyCopilotSessionError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (/onPermissionRequest|permission|sendAndWait|createSession|unsupported/i.test(message)) {
-        return "unsupported";
-    }
-    return "auth";
-}
-function resolveCallable(target, name) {
-    if (!target) {
-        return null;
-    }
-    const direct = target[name];
-    if (typeof direct === "function") {
-        return direct.bind(target);
-    }
-    const nestedDefault = target.default;
-    if (nestedDefault && typeof nestedDefault[name] === "function") {
-        return nestedDefault[name].bind(nestedDefault);
-    }
-    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;
-}
-function resolveRuntimeConnectionFactory(target) {
-    const direct = target.RuntimeConnection;
-    if (direct && typeof direct === "object") {
-        return direct;
-    }
-    const nestedDefault = target.default;
-    if (nestedDefault) {
-        return resolveRuntimeConnectionFactory(nestedDefault);
-    }
-    return null;
-}
-function resolveApproveAll(target) {
-    const direct = target.approveAll;
-    if (typeof direct === "function") {
-        return direct;
-    }
-    const permissionHandler = target.PermissionHandler;
-    if (permissionHandler && typeof permissionHandler === "object" && typeof permissionHandler.approveAll === "function") {
-        return permissionHandler.approveAll;
-    }
-    const nestedDefault = target.default;
-    if (nestedDefault) {
-        return resolveApproveAll(nestedDefault);
-    }
-    return null;
-}
-function isCliError(error) {
-    return Boolean(error && typeof error === "object" && typeof error.code === "string");
-}
-function safeCopilotNodeRuntimeStatus() {
-    try {
-        (0, copilot_installer_1.assertCopilotNodeRuntimeSupported)();
-        return { ok: true };
-    }
-    catch (error) {
-        return {
-            ok: false,
-            availability: {
-                ok: false,
-                runtime: "copilot-sdk",
-                reason: "unsupported",
-                cause: error instanceof Error ? error.message : String(error),
-                details: isCliError(error) ? error.details : undefined,
-            },
-        };
-    }
-}

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

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const copilot_bridge_1 = require("./copilot-bridge");
-const copilot_adapter_1 = require("./copilot-adapter");
-let requestQueue = Promise.resolve();
-/**
- * Writes one worker lifecycle entry to stderr so the detached parent log capture persists it.
- */
-function logWorkerEvent(message) {
-    process.stderr.write(`[${new Date().toISOString()}] ${message}\n`);
-}
-function enqueueRequest(task) {
-    const run = requestQueue.then(task, task);
-    requestQueue = run.catch(() => undefined);
-    return run;
-}
-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 ?? "";
-    const runtimesDir = process.env.CODEX_SWITCH_RUNTIMES_DIR || undefined;
-    logWorkerEvent(`worker startup provider=${provider} host=${host} port=${String(port)}`);
-    const runtimeClient = await (0, copilot_adapter_1.createCopilotRuntimeClient)(runtimesDir);
-    await (0, copilot_adapter_1.startCopilotRuntimeClient)(runtimeClient);
-    const stopRuntime = () => {
-        logWorkerEvent(`worker shutdown provider=${provider}`);
-        void (0, copilot_adapter_1.stopCopilotRuntimeClient)(runtimeClient).finally(() => process.exit(0));
-    };
-    process.once("SIGINT", stopRuntime);
-    process.once("SIGTERM", stopRuntime);
-    await (0, copilot_bridge_1.startCopilotBridgeServer)({
-        host,
-        port,
-        apiKey,
-        executeChatCompletion: async (payload, options) => enqueueRequest(() => (0, copilot_adapter_1.sendCopilotChatCompletion)({
-            provider,
-            payload,
-            runtimesDir,
-            runtimeClient,
-            timeoutMs: options?.timeoutMs,
-            onStreamEvent: (event) => {
-                if (event.type === "delta") {
-                    options?.onTextDelta?.(event.delta);
-                }
-                else if (event.type === "runtime") {
-                    options?.onRuntimeEvent?.(event.event);
-                }
-                else {
-                    options?.onTextDone?.(event.text);
-                }
-            },
-        })),
-    });
-    logWorkerEvent(`worker ready provider=${provider} host=${host} port=${String(port)}`);
-}
-if (require.main === module) {
-    process.on("uncaughtException", (error) => {
-        logWorkerEvent(`worker uncaught exception: ${error.message}`);
-    });
-    process.on("unhandledRejection", (reason) => {
-        logWorkerEvent(`worker unhandled rejection: ${reason instanceof Error ? reason.message : String(reason)}`);
-    });
-    void main().catch((error) => {
-        logWorkerEvent(`worker startup failure: ${error instanceof Error ? error.message : String(error)}`);
-        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-        process.exit(1);
-    });
-}