@minniexcode/codex-switch 0.0.10 → 0.0.11

package/dist/runtime/copilot-bridge.js

@@ -45,11 +45,13 @@ 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 fs = __importStar(require("node:fs"));
 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;
+let cachedBridgeWorkerBuildId = null;
 /**
  * Overrides the spawn implementation for bridge runtime tests.
  */
@@ -65,8 +67,8 @@ function resetCopilotBridgeSpawnImplementation() {
 /**
  * Returns the last known Copilot bridge runtime status.
  */
-async function probeCopilotBridgeRuntime(provider, persistedState) {
-    const state = persistedState === undefined ? (0, runtime_state_repo_1.readCopilotBridgeState)() : persistedState;
+async function probeCopilotBridgeRuntime(provider, persistedState, runtimeDir) {
+    const state = persistedState === undefined ? (0, runtime_state_repo_1.readCopilotBridgeState)(runtimeDir) : persistedState;
     if (state && (!provider || !(0, providers_1.isCopilotBridgeProvider)(provider))) {
         return {
             ok: false,
@@ -126,7 +128,7 @@ async function probeCopilotBridgeRuntime(provider, persistedState) {
     (0, runtime_state_repo_1.writeCopilotBridgeState)({
         ...state,
         lastHealthcheckAt: new Date().toISOString(),
-    });
+    }, runtimeDir);
     return {
         ok: true,
         runtime: "copilot-bridge",
@@ -136,13 +138,13 @@ async function probeCopilotBridgeRuntime(provider, persistedState) {
 /**
  * Starts or reuses a Copilot bridge worker, then verifies its health before returning.
  */
-async function ensureCopilotBridge(providerName, provider) {
-    return startOrReuseCopilotBridge(providerName, provider);
+async function ensureCopilotBridge(providerName, provider, runtimeDir) {
+    return startOrReuseCopilotBridge(providerName, provider, runtimeDir);
 }
 /**
  * Starts or reuses a Copilot bridge worker and reports the chosen port.
  */
-async function startOrReuseCopilotBridge(providerName, provider) {
+async function startOrReuseCopilotBridge(providerName, provider, runtimeDir) {
     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,
@@ -155,27 +157,40 @@ async function startOrReuseCopilotBridge(providerName, provider) {
         });
     }
     const expectedBaseUrl = (0, providers_1.buildCopilotBridgeBaseUrl)(runtime);
-    const current = (0, runtime_state_repo_1.readCopilotBridgeState)();
+    const current = (0, runtime_state_repo_1.readCopilotBridgeState)(runtimeDir);
+    const workerBuildId = getCopilotBridgeWorkerBuildId();
     let replaced = false;
     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,
-                host: current.host,
-                port: current.port,
-                reused: true,
-                portChanged: false,
-                replaced: false,
-            };
+        if (current.workerBuildId === workerBuildId) {
+            const healthy = await healthcheckCopilotBridge(current.host, current.port);
+            if (healthy.ok) {
+                const compatible = await verifyCopilotBridgeAuthorization(current.host, current.port, provider.apiKey);
+                if (compatible.ok) {
+                    (0, runtime_state_repo_1.writeCopilotBridgeState)({
+                        ...current,
+                        lastHealthcheckAt: new Date().toISOString(),
+                        workerBuildId,
+                    }, runtimeDir);
+                    return {
+                        baseUrl: expectedBaseUrl,
+                        host: current.host,
+                        port: current.port,
+                        reused: true,
+                        portChanged: false,
+                        replaced: false,
+                    };
+                }
+            }
+            stopCopilotBridge(runtimeDir);
+            replaced = true;
+        }
+        else {
+            stopCopilotBridge(runtimeDir);
+            replaced = true;
         }
     }
     if (current && current.provider !== providerName) {
-        stopCopilotBridge();
+        stopCopilotBridge(runtimeDir);
         replaced = true;
     }
     const selectedPort = await selectBridgePort(runtime.bridgeHost, runtime.bridgePort);
@@ -208,7 +223,7 @@ async function startOrReuseCopilotBridge(providerName, provider) {
     const startedAt = new Date().toISOString();
     const healthy = await waitForCopilotBridgeStartup(child, runtime.bridgeHost, selectedPort, 15, 200);
     if (!healthy.ok) {
-        (0, runtime_state_repo_1.clearCopilotBridgeState)();
+        (0, runtime_state_repo_1.clearCopilotBridgeState)(runtimeDir);
         if (healthy.reason === "start-failed") {
             throw (0, errors_1.cliError)("BRIDGE_START_FAILED", "Copilot bridge worker exited before becoming healthy.", {
                 provider: providerName,
@@ -232,8 +247,9 @@ async function startOrReuseCopilotBridge(providerName, provider) {
         baseUrl: selectedBaseUrl,
         startedAt,
         lastHealthcheckAt: new Date().toISOString(),
+        workerBuildId,
     };
-    (0, runtime_state_repo_1.writeCopilotBridgeState)(state);
+    (0, runtime_state_repo_1.writeCopilotBridgeState)(state, runtimeDir);
     return {
         baseUrl: selectedBaseUrl,
         host: runtime.bridgeHost,
@@ -266,34 +282,329 @@ function createCopilotBridgeRequestHandler(context) {
                 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" } }));
+            if (method === "POST" && url === "/v1/chat/completions") {
+                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));
                 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",
+            if (method === "POST" && url === "/v1/responses") {
+                const body = await readJsonBody(request);
+                const normalized = normalizeResponsesRequest(body);
+                const payload = await context.executeChatCompletion({
+                    model: normalized.model,
+                    messages: normalized.messages,
                 });
-                response.write(`data: ${JSON.stringify(payload)}\n\n`);
-                response.write("data: [DONE]\n\n");
-                response.end();
+                if (normalized.stream) {
+                    response.writeHead(200, {
+                        "content-type": "text/event-stream",
+                        "cache-control": "no-cache",
+                        connection: "keep-alive",
+                    });
+                    writeResponsesStream(response, payload);
+                    response.end();
+                    return;
+                }
+                response.writeHead(200, { "content-type": "application/json" });
+                response.end(JSON.stringify(buildResponsesPayload(payload)));
+                return;
+            }
+            if (method !== "POST") {
+                response.writeHead(404, { "content-type": "application/json" });
+                response.end(JSON.stringify({ error: { message: "Not found" } }));
                 return;
             }
-            response.writeHead(200, { "content-type": "application/json" });
-            response.end(JSON.stringify(payload));
+            response.writeHead(404, { "content-type": "application/json" });
+            response.end(JSON.stringify({ error: { message: "Not found" } }));
         }
         catch (error) {
-            response.writeHead(500, { "content-type": "application/json" });
+            const statusCode = isCliError(error) && error.code === "BRIDGE_UNSUPPORTED_REQUEST" ? 400 : 500;
+            response.writeHead(statusCode, { "content-type": "application/json" });
             response.end(JSON.stringify({ error: { message: error instanceof Error ? error.message : String(error) } }));
         }
     };
 }
+/**
+ * Converts one minimal Responses API payload into the existing chat-completions bridge call shape.
+ */
+function normalizeResponsesRequest(body) {
+    const payload = body;
+    if (typeof payload.model !== "string" || payload.model.trim() === "") {
+        throw (0, errors_1.cliError)("BRIDGE_UNSUPPORTED_REQUEST", "Copilot bridge /v1/responses requires a non-empty string model.");
+    }
+    const messages = normalizeResponsesInput(payload.input);
+    if (messages.length === 0) {
+        throw (0, errors_1.cliError)("BRIDGE_UNSUPPORTED_REQUEST", "Copilot bridge /v1/responses requires at least one input message.");
+    }
+    return {
+        model: payload.model,
+        messages,
+        stream: payload.stream === true,
+    };
+}
+function normalizeResponsesInput(input) {
+    if (typeof input === "string") {
+        return [{ role: "user", content: input }];
+    }
+    if (!Array.isArray(input)) {
+        throw (0, errors_1.cliError)("BRIDGE_UNSUPPORTED_REQUEST", "Copilot bridge /v1/responses expects input as a string or message array.");
+    }
+    if (input.length === 0) {
+        return [];
+    }
+    const entryKinds = input.map(classifyResponsesInputEntry);
+    const hasMessages = entryKinds.includes("message");
+    const hasContentItems = entryKinds.includes("content-item");
+    if (hasMessages && hasContentItems) {
+        throw (0, errors_1.cliError)("BRIDGE_UNSUPPORTED_REQUEST", "Copilot bridge /v1/responses input array must contain either message objects or content items, not both.");
+    }
+    if (hasContentItems) {
+        return [
+            {
+                role: "user",
+                content: extractResponsesTextContent(input, 0),
+            },
+        ];
+    }
+    return input.map((entry, index) => normalizeResponsesMessage(entry, index));
+}
+function normalizeResponsesMessage(entry, index) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+        throw (0, errors_1.cliError)("BRIDGE_UNSUPPORTED_REQUEST", `Copilot bridge /v1/responses input[${String(index)}] must be an object message.`);
+    }
+    const message = entry;
+    const role = typeof message.role === "string" && message.role.trim() !== "" ? message.role : "user";
+    const content = extractResponsesTextContent(message.content, index);
+    return { role, content };
+}
+/**
+ * Classifies one top-level Responses input entry so mixed array shapes can be rejected clearly.
+ */
+function classifyResponsesInputEntry(entry) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+        throw (0, errors_1.cliError)("BRIDGE_UNSUPPORTED_REQUEST", "Copilot bridge /v1/responses input entries must be objects.");
+    }
+    const record = entry;
+    if ("content" in record || "role" in record) {
+        return "message";
+    }
+    if (typeof record.type === "string") {
+        return "content-item";
+    }
+    throw (0, errors_1.cliError)("BRIDGE_UNSUPPORTED_REQUEST", "Copilot bridge /v1/responses input entries must be message objects or typed content items.");
+}
+function extractResponsesTextContent(content, index) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        throw (0, errors_1.cliError)("BRIDGE_UNSUPPORTED_REQUEST", `Copilot bridge /v1/responses input[${String(index)}].content must be a string or content item array.`);
+    }
+    const parts = content.map((item, itemIndex) => {
+        if (!item || typeof item !== "object" || Array.isArray(item)) {
+            throw (0, errors_1.cliError)("BRIDGE_UNSUPPORTED_REQUEST", `Copilot bridge /v1/responses input[${String(index)}].content[${String(itemIndex)}] must be an object item.`);
+        }
+        return renderResponsesContentItem(item);
+    });
+    return parts.join("\n");
+}
+/**
+ * Converts one Responses content item into the text-only prompt representation required by the Copilot SDK bridge.
+ */
+function renderResponsesContentItem(item) {
+    const type = typeof item.type === "string" ? item.type : null;
+    const text = typeof item.text === "string" ? item.text : null;
+    if ((type === "input_text" || type === "text" || type === "output_text") && text !== null) {
+        return text;
+    }
+    if (type === "input_image") {
+        return buildResponsesPlaceholder("input_image", item.image_url, item.file_id);
+    }
+    if (type === "input_file") {
+        return buildResponsesPlaceholder("input_file", item.filename, item.file_id);
+    }
+    if (type !== null) {
+        return `[unsupported content type: ${type}]`;
+    }
+    throw (0, errors_1.cliError)("BRIDGE_UNSUPPORTED_REQUEST", "Copilot bridge /v1/responses content items must declare a string type.");
+}
+/**
+ * Builds a readable placeholder for non-text Responses content items preserved as text-only context.
+ */
+function buildResponsesPlaceholder(type, ...candidates) {
+    for (const candidate of candidates) {
+        if (typeof candidate === "string" && candidate.trim() !== "") {
+            return `[${type}: ${candidate}]`;
+        }
+    }
+    return `[${type} omitted]`;
+}
+/**
+ * Converts the existing chat-completions response into a minimal Responses API payload.
+ */
+function buildResponsesPayload(payload) {
+    const firstChoice = Array.isArray(payload.choices) ? payload.choices[0] : null;
+    const outputText = firstChoice?.message?.content ?? "";
+    return {
+        id: payload.id ?? `resp_${Date.now()}`,
+        object: "response",
+        created_at: payload.created ?? Math.floor(Date.now() / 1000),
+        model: payload.model ?? "copilot",
+        status: "completed",
+        output: [
+            {
+                type: "message",
+                id: `${payload.id ?? "resp"}_msg_0`,
+                role: "assistant",
+                content: [
+                    {
+                        type: "output_text",
+                        text: outputText,
+                    },
+                ],
+            },
+        ],
+        output_text: outputText,
+    };
+}
+/**
+ * Emits a minimal OpenAI-compatible Responses API event stream.
+ */
+function writeResponsesStream(response, payload) {
+    const responsePayload = buildResponsesPayload(payload);
+    const responseId = typeof responsePayload.id === "string" ? responsePayload.id : `resp_${Date.now()}`;
+    const messageId = buildResponsesMessageId(responseId);
+    const outputText = typeof responsePayload.output_text === "string" ? responsePayload.output_text : "";
+    const inProgressResponse = {
+        ...responsePayload,
+        status: "in_progress",
+        output: [],
+    };
+    const completedMessage = {
+        id: messageId,
+        type: "message",
+        status: "completed",
+        role: "assistant",
+        content: [
+            {
+                type: "output_text",
+                text: outputText,
+                annotations: [],
+            },
+        ],
+    };
+    writeSseEvent(response, "response.created", {
+        type: "response.created",
+        response: inProgressResponse,
+    });
+    writeSseEvent(response, "response.in_progress", {
+        type: "response.in_progress",
+        response: inProgressResponse,
+    });
+    writeSseEvent(response, "response.output_item.added", {
+        type: "response.output_item.added",
+        output_index: 0,
+        item: {
+            id: messageId,
+            type: "message",
+            status: "in_progress",
+            role: "assistant",
+            content: [],
+        },
+    });
+    writeSseEvent(response, "response.content_part.added", {
+        type: "response.content_part.added",
+        item_id: messageId,
+        output_index: 0,
+        content_index: 0,
+        part: {
+            type: "output_text",
+            text: "",
+            annotations: [],
+        },
+    });
+    writeSseEvent(response, "response.output_text.delta", {
+        type: "response.output_text.delta",
+        item_id: messageId,
+        output_index: 0,
+        content_index: 0,
+        delta: outputText,
+    });
+    writeSseEvent(response, "response.output_text.done", {
+        type: "response.output_text.done",
+        item_id: messageId,
+        output_index: 0,
+        content_index: 0,
+        text: outputText,
+    });
+    writeSseEvent(response, "response.content_part.done", {
+        type: "response.content_part.done",
+        item_id: messageId,
+        output_index: 0,
+        content_index: 0,
+        part: {
+            type: "output_text",
+            text: outputText,
+            annotations: [],
+        },
+    });
+    writeSseEvent(response, "response.output_item.done", {
+        type: "response.output_item.done",
+        output_index: 0,
+        item: completedMessage,
+    });
+    writeSseEvent(response, "response.completed", {
+        type: "response.completed",
+        response: {
+            ...responsePayload,
+            output: [completedMessage],
+        },
+    });
+}
+/**
+ * Formats and writes one server-sent event frame.
+ */
+function writeSseEvent(response, eventName, data) {
+    response.write(`event: ${eventName}\n`);
+    response.write(`data: ${JSON.stringify(data)}\n\n`);
+}
+/**
+ * Derives a stable message identifier for synthesized Responses output items.
+ */
+function buildResponsesMessageId(responseId) {
+    if (responseId.startsWith("resp_")) {
+        return `msg_${responseId.slice("resp_".length)}_0`;
+    }
+    return `${responseId}_msg_0`;
+}
+function isCliError(error) {
+    return Boolean(error && typeof error === "object" && typeof error.code === "string");
+}
+/**
+ * Returns a stable build identifier for the compiled bridge worker bundle.
+ */
+function getCopilotBridgeWorkerBuildId() {
+    if (cachedBridgeWorkerBuildId) {
+        return cachedBridgeWorkerBuildId;
+    }
+    const workerPath = path.join(__dirname, "copilot-bridge-worker.js");
+    const stats = fs.statSync(workerPath);
+    cachedBridgeWorkerBuildId = `${stats.size}:${stats.mtimeMs}`;
+    return cachedBridgeWorkerBuildId;
+}
 /**
  * Starts an in-process local bridge server. Primarily used by the worker entrypoint and tests.
  */
@@ -329,8 +640,8 @@ async function waitForCopilotBridgeHealth(host, port, attempts = 10, delayMs = 1
 /**
  * Stops the currently persisted Copilot bridge worker when possible.
  */
-function stopCopilotBridge() {
-    const state = (0, runtime_state_repo_1.readCopilotBridgeState)();
+function stopCopilotBridge(runtimeDir) {
+    const state = (0, runtime_state_repo_1.readCopilotBridgeState)(runtimeDir);
     if (state?.pid) {
         try {
             process.kill(state.pid);
@@ -339,7 +650,7 @@ function stopCopilotBridge() {
             // Ignore best-effort bridge cleanup failures.
         }
     }
-    (0, runtime_state_repo_1.clearCopilotBridgeState)();
+    (0, runtime_state_repo_1.clearCopilotBridgeState)(runtimeDir);
 }
 async function checkPortAvailability(host, port) {
     return new Promise((resolve) => {
@@ -457,6 +768,43 @@ async function healthcheckCopilotBridge(host, port) {
         request.end();
     });
 }
+/**
+ * Checks whether a healthy bridge still accepts the provider's current bearer secret.
+ */
+async function verifyCopilotBridgeAuthorization(host, port, apiKey) {
+    return new Promise((resolve) => {
+        const request = http.request({
+            host,
+            port,
+            method: "GET",
+            path: "/v1/models",
+            timeout: 1000,
+            headers: {
+                authorization: `Bearer ${apiKey}`,
+            },
+        }, (response) => {
+            response.resume();
+            if (response.statusCode === 200) {
+                resolve({ ok: true });
+                return;
+            }
+            resolve({
+                ok: false,
+                cause: `Authorization probe returned status ${String(response.statusCode ?? 0)}.`,
+            });
+        });
+        request.on("error", (error) => {
+            resolve({
+                ok: false,
+                cause: error.message,
+            });
+        });
+        request.on("timeout", () => {
+            request.destroy(new Error("Authorization probe timed out."));
+        });
+        request.end();
+    });
+}
 async function readJsonBody(request) {
     const chunks = [];
     for await (const chunk of request) {

package/dist/runtime/copilot-cli.js

@@ -1,10 +1,46 @@
 "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.setCopilotCliSpawnImplementation = setCopilotCliSpawnImplementation;
 exports.resetCopilotCliSpawnImplementation = resetCopilotCliSpawnImplementation;
 exports.checkCopilotCliAvailable = checkCopilotCliAvailable;
 exports.runCopilotLogin = runCopilotLogin;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
 const node_child_process_1 = require("node:child_process");
+const copilot_installer_1 = require("./copilot-installer");
 let spawnImplementation = node_child_process_1.spawnSync;
 /**
  * Overrides the spawn implementation for Copilot CLI tests.
@@ -19,22 +55,28 @@ function resetCopilotCliSpawnImplementation() {
     spawnImplementation = node_child_process_1.spawnSync;
 }
 /**
- * Checks whether the GitHub Copilot CLI is available on PATH.
+ * Checks whether the GitHub Copilot CLI is available either from the bundled runtime or on PATH.
  */
-function checkCopilotCliAvailable() {
-    const invocation = getCopilotInvocation(["--help"]);
+function checkCopilotCliAvailable(runtimesDir) {
+    const invocation = getCopilotInvocation(["--help"], runtimesDir);
     const result = spawnImplementation(invocation.command, invocation.args, {
         stdio: "pipe",
         encoding: "utf8",
-        shell: false,
+        shell: invocation.shell,
     });
     if (result.error || result.status !== 0) {
         return {
             ok: false,
             cause: result.error?.message ?? (result.stderr.trim() || "Unknown failure"),
+            source: invocation.source,
+            command: formatInvocation(invocation),
         };
     }
-    return { ok: true };
+    return {
+        ok: true,
+        source: invocation.source,
+        command: formatInvocation(invocation),
+    };
 }
 /**
  * Launches the official `copilot login` flow in the current terminal.
@@ -44,27 +86,57 @@ function runCopilotLogin(options) {
     if (options?.host) {
         args.push("--hostname", options.host);
     }
-    const invocation = getCopilotInvocation(args);
+    const invocation = getCopilotInvocation(args, options?.runtimesDir);
     const result = spawnImplementation(invocation.command, invocation.args, {
         stdio: "inherit",
-        shell: false,
+        shell: invocation.shell,
     });
     if (result.error || result.status !== 0) {
-        throw new Error(result.error?.message ?? `copilot login exited with status ${String(result.status)}`);
+        throw new Error(result.error?.message ??
+            `${formatInvocation(invocation)} exited with status ${String(result.status)}`);
     }
 }
 /**
  * Resolves a cross-platform invocation for the Copilot CLI.
  */
-function getCopilotInvocation(args) {
+function getCopilotInvocation(args, runtimesDir) {
+    const bundledCommand = resolveBundledCopilotCommand(runtimesDir);
+    const executable = bundledCommand ?? "copilot";
     if (process.platform === "win32") {
         return {
-            command: process.env.ComSpec || "cmd.exe",
-            args: ["/d", "/s", "/c", ["copilot", ...args].join(" ")],
+            command: executable,
+            args,
+            source: bundledCommand ? "bundled" : "path",
+            shell: true,
         };
     }
     return {
-        command: "copilot",
+        command: executable,
         args,
+        source: bundledCommand ? "bundled" : "path",
+        shell: false,
     };
 }
+/**
+ * Resolves the bundled Copilot CLI shim installed alongside the optional runtime.
+ */
+function resolveBundledCopilotCommand(runtimesDir) {
+    const installDir = (0, copilot_installer_1.getCopilotRuntimeInstallDir)(runtimesDir);
+    const candidates = process.platform === "win32"
+        ? [path.join(installDir, "node_modules", ".bin", "copilot.cmd")]
+        : [path.join(installDir, "node_modules", ".bin", "copilot")];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+/**
+ * Renders the invocation into a short human-readable string for diagnostics.
+ */
+function formatInvocation(invocation) {
+    return invocation.command === "copilot"
+        ? ["copilot", ...invocation.args].join(" ")
+        : [invocation.command, ...invocation.args].join(" ");
+}