@minniexcode/codex-switch 0.1.1 → 0.1.2

package/dist/runtime/copilot-adapter.js

@@ -1,16 +1,28 @@
 "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 and loadable.
+ * 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 {
@@ -24,6 +36,21 @@ function probeCopilotSdkRuntime(runtimesDir) {
             },
         };
     }
+    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",
@@ -41,55 +68,83 @@ async function requireCopilotSdk(runtimesDir) {
     return (0, copilot_sdk_loader_1.loadCopilotSdk)(runtimesDir);
 }
 /**
- * Probes whether the lazily installed Copilot SDK can create a usable session.
+ * 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)("COPILOT_SDK_MISSING", "The optional Copilot SDK runtime is not installed.", runtime.details);
+        throw (0, errors_1.cliError)(runtime.reason === "unsupported" ? "COPILOT_SDK_VERSION_UNSUPPORTED" : "COPILOT_SDK_MISSING", runtime.cause, runtime.details);
     }
-    const { client, session } = await createCopilotSession(runtimesDir);
-    await stopCopilotClient(client);
-    return {
-        ready: Boolean(session),
-        source: "official-sdk",
-        mode: "session",
-    };
+    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);
 }
 /**
- * Executes a single chat-completions style request through the optional Copilot SDK when available.
+ * 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 { client, session, sdk } = await createCopilotSession(args.runtimesDir);
+    const ownsClient = !args.runtimeClient;
+    const runtimeClient = args.runtimeClient ?? await createCopilotRuntimeClient(args.runtimesDir);
+    if (ownsClient) {
+        await startCopilotRuntimeClient(runtimeClient);
+    }
+    let session = null;
     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);
+        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: args.payload.model ?? "copilot",
+            model: typeof args.payload.model === "string" ? args.payload.model : "copilot",
             choices: [
                 {
                     index: 0,
@@ -103,27 +158,36 @@ async function sendCopilotChatCompletion(args) {
         };
     }
     finally {
-        await stopCopilotClient(client);
+        if (session) {
+            await disconnectCopilotSession(session);
+        }
+        if (ownsClient) {
+            await stopCopilotRuntimeClient(runtimeClient);
+        }
     }
 }
-async function createCopilotSession(runtimesDir) {
-    const sdk = (await requireCopilotSdk(runtimesDir));
-    const client = createCopilotClient(sdk);
-    const createSession = resolveCallable(client ? client : null, "createSession") ?? resolveCallable(sdk, "createSession");
+async function createCopilotSession(runtimeClient, payload) {
+    const createSession = resolveCallable(runtimeClient.client, "createSession");
     if (!createSession) {
-        throw (0, errors_1.cliError)("COPILOT_SDK_UNSUPPORTED", "The installed Copilot SDK does not expose a supported createSession API.", {});
+        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(createSessionOptions(sdk))));
-        return {
-            sdk,
-            client,
-            session,
-        };
+        const session = await Promise.resolve(createSession({
+            model: typeof payload.model === "string" ? payload.model : undefined,
+            ...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_UNSUPPORTED", "The installed Copilot SDK does not expose a compatible permission-handling session API.", {
+            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),
             });
         }
@@ -132,9 +196,61 @@ async function createCopilotSession(runtimesDir) {
         });
     }
 }
-/**
- * Builds the session options used consistently across auth probes and request execution.
- */
+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 });
+        }
+    };
+    if (onStreamEvent && session.on) {
+        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("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) {
@@ -142,35 +258,153 @@ function createSessionOptions(sdk) {
             onPermissionRequest: (request) => approveAll(request),
         };
     }
-    return {
-        onPermissionRequest: () => true,
-    };
+    throw (0, errors_1.cliError)("COPILOT_SDK_API_UNSUPPORTED", "The installed Copilot SDK does not expose an approveAll permission handler.", {});
 }
-function createCopilotClient(sdk) {
+function createCopilotClient(sdk, runtimesDir) {
     const ClientCtor = resolveConstructor(sdk, "CopilotClient");
     if (!ClientCtor) {
-        return null;
+        throw (0, errors_1.cliError)("COPILOT_SDK_API_UNSUPPORTED", "The installed Copilot SDK does not expose CopilotClient.", {});
     }
+    const invocation = (0, copilot_cli_1.resolveCopilotCliInvocation)([], runtimesDir);
+    const clientOptions = {
+        copilotCommand: invocation.command,
+        command: invocation.command,
+        executable: invocation.command,
+    };
     try {
-        return new ClientCtor();
+        return new ClientCtor(clientOptions);
     }
     catch (error) {
-        throw (0, errors_1.cliError)("COPILOT_SDK_UNSUPPORTED", "The installed Copilot SDK CopilotClient could not be constructed.", {
+        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) {
-    if (client && typeof client.stop === "function") {
-        await Promise.resolve(client.stop());
+    const stop = resolveCallable(client, "stop");
+    if (stop) {
+        await Promise.resolve(stop());
     }
 }
-/**
- * Distinguishes true auth failures from SDK API-shape mismatches.
- */
+async function abortCopilotSession(session) {
+    const abort = resolveCallable(session, "abort");
+    if (abort) {
+        await Promise.resolve(abort());
+    }
+}
+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;
+}
+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/i.test(message) || /permission/i.test(message)) {
+    if (/onPermissionRequest|permission|sendAndWait|createSession|unsupported/i.test(message)) {
         return "unsupported";
     }
     return "auth";
@@ -200,17 +434,39 @@ function resolveConstructor(target, name) {
     }
     return null;
 }
-/**
- * Resolves the SDK-provided permission helper when available.
- */
 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 && typeof nestedDefault.approveAll === "function") {
-        return nestedDefault.approveAll;
+    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

@@ -2,19 +2,44 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const copilot_bridge_1 = require("./copilot-bridge");
 const copilot_adapter_1 = require("./copilot-adapter");
+let requestQueue = Promise.resolve();
+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;
+    const runtimeClient = await (0, copilot_adapter_1.createCopilotRuntimeClient)(runtimesDir);
+    await (0, copilot_adapter_1.startCopilotRuntimeClient)(runtimeClient);
+    const stopRuntime = () => {
+        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) => (0, copilot_adapter_1.sendCopilotChatCompletion)({
+        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 {
+                    options?.onTextDone?.(event.text);
+                }
+            },
+        })),
     });
 }
 if (require.main === module) {