@minniexcode/codex-switch 0.1.3 → 0.1.5

package/dist/runtime/copilot-bridge.js

@@ -50,6 +50,9 @@ 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");
+const BRIDGE_REUSE_ATTEMPTS = 2;
+const BRIDGE_REUSE_TIMEOUT_MS = 2500;
+const BRIDGE_REUSE_DELAY_MS = 250;
 let spawnImplementation = node_child_process_1.spawn;
 let cachedBridgeWorkerBuildId = null;
 /**
@@ -69,13 +72,17 @@ function resetCopilotBridgeSpawnImplementation() {
  */
 async function probeCopilotBridgeRuntime(provider, persistedState, runtimeDir) {
     const state = persistedState === undefined ? (0, runtime_state_repo_1.readCopilotBridgeState)(runtimeDir) : persistedState;
+    const logPath = state?.logPath ?? (0, runtime_state_repo_1.getCopilotBridgeLogPath)(runtimeDir);
     if (state && (!provider || !(0, providers_1.isCopilotBridgeProvider)(provider))) {
         return {
             ok: false,
             runtime: "copilot-bridge",
             reason: "failed",
             cause: "Copilot bridge runtime state exists but no active Copilot bridge provider is selected.",
-            details: state,
+            details: {
+                ...state,
+                logPath,
+            },
         };
     }
     if (!provider || !(0, providers_1.isCopilotBridgeProvider)(provider)) {
@@ -100,6 +107,7 @@ async function probeCopilotBridgeRuntime(provider, persistedState, runtimeDir) {
             cause: "Copilot bridge state manifest is missing.",
             details: {
                 expectedBaseUrl: (0, providers_1.buildCopilotBridgeBaseUrl)(runtime),
+                logPath,
             },
         };
     }
@@ -112,27 +120,44 @@ async function probeCopilotBridgeRuntime(provider, persistedState, runtimeDir) {
             details: {
                 stateBaseUrl: state.baseUrl,
                 providerBaseUrl: (0, providers_1.buildCopilotBridgeBaseUrl)(runtime),
+                logPath,
             },
         };
     }
-    const healthy = await healthcheckCopilotBridge(state.host, state.port);
+    const healthy = await probeBridgeEndpoint({
+        host: state.host,
+        port: state.port,
+        stage: "health",
+    });
     if (!healthy.ok) {
         return {
             ok: false,
             runtime: "copilot-bridge",
             reason: "failed",
-            cause: healthy.cause,
-            details: state,
+            cause: healthy.message,
+            details: {
+                ...state,
+                logPath,
+                probeStage: healthy.stage,
+                probeCause: healthy.cause,
+                retryable: healthy.retryable,
+            },
         };
     }
     (0, runtime_state_repo_1.writeCopilotBridgeState)({
         ...state,
         lastHealthcheckAt: new Date().toISOString(),
+        lastProbeAt: new Date().toISOString(),
+        logPath,
     }, runtimeDir);
     return {
         ok: true,
         runtime: "copilot-bridge",
-        details: state,
+        details: {
+            ...state,
+            logPath,
+            lastProbeAt: new Date().toISOString(),
+        },
     };
 }
 /**
@@ -160,47 +185,50 @@ async function startOrReuseCopilotBridge(providerName, provider, runtimeDir, run
     const current = (0, runtime_state_repo_1.readCopilotBridgeState)(runtimeDir);
     const workerBuildId = getCopilotBridgeWorkerBuildId();
     let replaced = false;
-    if (current && current.provider === providerName && current.baseUrl === expectedBaseUrl) {
-        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;
-        }
+    const logPath = current?.logPath ?? (0, runtime_state_repo_1.getCopilotBridgeLogPath)(runtimeDir);
+    const reuseDecision = await evaluateBridgeReuse({
+        current,
+        providerName,
+        expectedBaseUrl,
+        expectedApiKey: provider.apiKey,
+        workerBuildId,
+        runtimeDir,
+        logPath,
+    });
+    if (reuseDecision.reuse) {
+        (0, runtime_state_repo_1.writeCopilotBridgeState)({
+            ...current,
+            lastHealthcheckAt: new Date().toISOString(),
+            lastProbeAt: reuseDecision.probeAt,
+            workerBuildId,
+            logPath: reuseDecision.logPath,
+        }, runtimeDir);
+        appendBridgeLifecycleLog(logPath, `startup success reused provider=${providerName} host=${current.host} port=${String(current.port)}`);
+        return {
+            baseUrl: expectedBaseUrl,
+            host: current.host,
+            port: current.port,
+            reused: true,
+            portChanged: false,
+            replaced: false,
+            logPath: reuseDecision.logPath,
+        };
     }
-    if (current && current.provider !== providerName) {
+    if (reuseDecision.replacedExisting) {
         stopCopilotBridge(runtimeDir);
         replaced = true;
+        appendBridgeLifecycleLog(logPath, `replacement reason=${reuseDecision.reason}`);
     }
     const selectedPort = await selectBridgePort(runtime.bridgeHost, runtime.bridgePort);
     const selectedBaseUrl = `http://${runtime.bridgeHost}:${selectedPort}${runtime.bridgePath}`;
     const workerPath = path.join(__dirname, "copilot-bridge-worker.js");
+    ensureBridgeLogFile(logPath);
+    appendBridgeLifecycleLog(logPath, `worker start provider=${providerName} host=${runtime.bridgeHost} port=${String(selectedPort)} replaced=${String(replaced)}`);
     let child;
     try {
         child = spawnImplementation(process.execPath, [workerPath], {
             detached: true,
-            stdio: "ignore",
+            stdio: ["ignore", openBridgeLogFd(logPath), openBridgeLogFd(logPath)],
             env: {
                 ...process.env,
                 CODEX_SWITCH_BRIDGE_PROVIDER: providerName,
@@ -210,6 +238,7 @@ async function startOrReuseCopilotBridge(providerName, provider, runtimeDir, run
                 CODEX_SWITCH_BRIDGE_BASE_URL: selectedBaseUrl,
                 CODEX_SWITCH_RUNTIME_DIR: runtimeDir ?? "",
                 CODEX_SWITCH_RUNTIMES_DIR: runtimesDir ?? "",
+                CODEX_SWITCH_BRIDGE_LOG_PATH: logPath,
             },
         });
     }
@@ -218,6 +247,12 @@ async function startOrReuseCopilotBridge(providerName, provider, runtimeDir, run
             provider: providerName,
             host: runtime.bridgeHost,
             port: selectedPort,
+            logPath,
+            probeStage: "startup",
+            probeCause: "startup-failed",
+            retryable: false,
+            replacedExisting: replaced,
+            providerName,
             cause: error instanceof Error ? error.message : String(error),
         });
     }
@@ -228,17 +263,29 @@ async function startOrReuseCopilotBridge(providerName, provider, runtimeDir, run
     if (!healthy.ok) {
         (0, runtime_state_repo_1.clearCopilotBridgeState)(runtimeDir);
         if (healthy.reason === "start-failed") {
+            appendBridgeLifecycleLog(logPath, `startup failure provider=${providerName} cause=${healthy.cause}`);
             throw (0, errors_1.cliError)("BRIDGE_START_FAILED", "Copilot bridge worker exited before becoming healthy.", {
                 provider: providerName,
                 host: runtime.bridgeHost,
                 port: selectedPort,
+                logPath,
+                probeStage: "startup",
+                probeCause: "startup-failed",
+                retryable: false,
+                replacedExisting: replaced,
                 cause: healthy.cause,
             });
         }
+        appendBridgeLifecycleLog(logPath, `startup timeout provider=${providerName} host=${runtime.bridgeHost} port=${String(selectedPort)}`);
         throw (0, errors_1.cliError)("BRIDGE_HEALTHCHECK_FAILED", "Copilot bridge did not become healthy after startup.", {
             provider: providerName,
             host: runtime.bridgeHost,
             port: selectedPort,
+            logPath,
+            probeStage: "startup",
+            probeCause: "startup-timeout",
+            retryable: true,
+            replacedExisting: replaced,
             cause: healthy.cause,
         });
     }
@@ -251,8 +298,12 @@ async function startOrReuseCopilotBridge(providerName, provider, runtimeDir, run
         startedAt,
         lastHealthcheckAt: new Date().toISOString(),
         workerBuildId,
+        logPath,
+        lastProbeAt: new Date().toISOString(),
+        lastRestartReason: reuseDecision.reuse ? undefined : reuseDecision.reason,
     };
     (0, runtime_state_repo_1.writeCopilotBridgeState)(state, runtimeDir);
+    appendBridgeLifecycleLog(logPath, `startup success provider=${providerName} host=${runtime.bridgeHost} port=${String(selectedPort)}`);
     return {
         baseUrl: selectedBaseUrl,
         host: runtime.bridgeHost,
@@ -260,6 +311,8 @@ async function startOrReuseCopilotBridge(providerName, provider, runtimeDir, run
         reused: false,
         portChanged: selectedPort !== runtime.bridgePort,
         replaced,
+        logPath,
+        restartReason: replaced ? reuseDecision.reason : undefined,
     };
 }
 /**
@@ -350,9 +403,15 @@ function createCopilotBridgeRequestHandler(context) {
                                 writeResponsesTextDelta(response, messageId, doneText);
                             }
                         },
+                        onRuntimeEvent: (event) => {
+                            writeResponsesRuntimeEvent(response, responseId, event);
+                        },
                     });
                     clearInterval(heartbeat);
                     const outputText = text || getChatCompletionText(payload);
+                    if (text.length === 0 && outputText.length > 0) {
+                        writeResponsesTextDelta(response, messageId, outputText);
+                    }
                     writeResponsesStreamDone(response, responseId, normalized.model, messageId, outputText);
                     response.end();
                     return;
@@ -734,6 +793,112 @@ function writeResponsesStreamDone(response, responseId, model, messageId, output
         },
     });
 }
+function writeResponsesRuntimeEvent(response, responseId, event) {
+    if (event.type === "assistant.message_delta") {
+        return;
+    }
+    if (event.type === "assistant.reasoning_delta") {
+        writeResponsesReasoningDelta(response, responseId, formatRuntimeEventText(event));
+        return;
+    }
+    if (event.type === "session.unknown") {
+        process.stderr.write(`[${new Date().toISOString()}] bridge runtime event ignored type=${event.sdkType} summary=${truncateBridgeText(event.summary, 240)}\n`);
+        return;
+    }
+    const text = formatRuntimeEventText(event);
+    if (text.length === 0) {
+        return;
+    }
+    writeResponsesCommentaryItem(response, responseId, text);
+    process.stderr.write(`[${new Date().toISOString()}] bridge runtime event type=${event.type} summary=${truncateBridgeText(text, 240)}\n`);
+}
+function writeResponsesReasoningDelta(response, responseId, text) {
+    const reasoningId = `${responseId}_rs_0`;
+    writeSseEvent(response, "response.reasoning_summary_part.added", {
+        type: "response.reasoning_summary_part.added",
+        item_id: reasoningId,
+        output_index: 0,
+        summary_index: 0,
+        part: {
+            type: "summary_text",
+            text: "",
+        },
+    });
+    writeSseEvent(response, "response.reasoning_summary_text.delta", {
+        type: "response.reasoning_summary_text.delta",
+        item_id: reasoningId,
+        output_index: 0,
+        summary_index: 0,
+        delta: text,
+    });
+}
+function writeResponsesCommentaryItem(response, responseId, text) {
+    const itemId = `${responseId}_commentary_${Date.now()}_${Math.floor(Math.random() * 100000)}`;
+    writeSseEvent(response, "response.output_item.done", {
+        type: "response.output_item.done",
+        output_index: 0,
+        item: {
+            id: itemId,
+            type: "message",
+            status: "completed",
+            role: "assistant",
+            phase: "commentary",
+            content: [
+                {
+                    type: "output_text",
+                    text,
+                    annotations: [],
+                },
+            ],
+        },
+    });
+}
+function formatRuntimeEventText(event) {
+    switch (event.type) {
+        case "assistant.intent":
+            return truncateBridgeText(event.text, 600);
+        case "assistant.reasoning_delta":
+            return truncateBridgeText(event.text, 600);
+        case "tool.execution_start":
+            return truncateBridgeText(`Copilot started ${formatToolName(event.name)}${formatRequestId(event.requestId)}${formatSummarySuffix(event.summary)}`, 600);
+        case "tool.execution_progress":
+            return truncateBridgeText(`Copilot progress ${formatToolName(event.name)}${formatRequestId(event.requestId)}${formatSummarySuffix(event.summary)}`, 600);
+        case "tool.execution_partial_result":
+            return truncateBridgeText(`Copilot partial result ${formatToolName(event.name)}${formatRequestId(event.requestId)}${formatSummarySuffix(event.summary)}`, 600);
+        case "tool.execution_complete":
+            return truncateBridgeText(`Copilot ${event.success === false ? "failed" : "completed"} ${formatToolName(event.name)}${formatRequestId(event.requestId)}${formatSummarySuffix(event.summary)}`, 600);
+        case "permission.requested":
+            return truncateBridgeText(`Copilot requested permission${event.kind ? `: ${event.kind}` : ""}${formatRequestId(event.requestId)}${formatSummarySuffix(event.summary)}`, 600);
+        case "permission.completed":
+            return truncateBridgeText(`Copilot permission ${event.approved === false ? "denied" : "approved"}${event.kind ? `: ${event.kind}` : ""}${formatRequestId(event.requestId)}${formatSummarySuffix(event.summary)}`, 600);
+        case "user_input.requested":
+            return truncateBridgeText(`Copilot requested user input${formatRequestId(event.requestId)}${formatSummarySuffix(event.summary)}`, 600);
+        case "exit_plan_mode.requested":
+            return truncateBridgeText(`Copilot requested to exit plan mode${formatRequestId(event.requestId)}${formatSummarySuffix(event.summary)}`, 600);
+        case "session.error":
+            return truncateBridgeText(`Copilot session error${formatSummarySuffix(event.summary)}`, 600);
+        case "session.idle":
+            return truncateBridgeText(event.summary, 600);
+        case "assistant.message_delta":
+        case "session.unknown":
+            return "";
+    }
+}
+function formatToolName(name) {
+    return name ? `tool ${name}` : "tool";
+}
+function formatRequestId(requestId) {
+    return requestId ? ` (${requestId})` : "";
+}
+function formatSummarySuffix(summary) {
+    return summary.length > 0 ? `: ${summary}` : "";
+}
+function truncateBridgeText(value, maxLength) {
+    if (value.length <= maxLength) {
+        return value;
+    }
+    return `${value.slice(0, maxLength)}... [truncated]`;
+}
 function startSseHeartbeat(response) {
     return setInterval(() => {
         response.write(": keep-alive\n\n");
@@ -809,9 +974,9 @@ function startCopilotBridgeServer(args) {
  */
 async function waitForCopilotBridgeHealth(host, port, attempts = 10, delayMs = 150) {
     for (let index = 0; index < attempts; index += 1) {
-        const result = await healthcheckCopilotBridge(host, port);
+        const result = await probeBridgeEndpoint({ host, port, stage: "health" });
         if (result.ok) {
-            return result;
+            return { ok: true };
         }
         await new Promise((resolve) => setTimeout(resolve, delayMs));
     }
@@ -896,9 +1061,9 @@ async function waitForCopilotBridgeStartup(child, host, port, attempts, delayMs)
                     cause: startupFailure,
                 };
             }
-            const result = await healthcheckCopilotBridge(host, port);
+            const result = await probeBridgeEndpoint({ host, port, stage: "health" });
             if (result.ok) {
-                return result;
+                return { ok: true };
             }
             await new Promise((resolve) => setTimeout(resolve, delayMs));
         }
@@ -920,74 +1085,222 @@ async function waitForCopilotBridgeStartup(child, host, port, attempts, delayMs)
         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({
+async function evaluateBridgeReuse(args) {
+    const probeAt = new Date().toISOString();
+    if (!args.current) {
+        return {
+            reuse: false,
+            reason: "no persisted bridge state",
+            replacedExisting: false,
+            probeAt,
+            logPath: args.logPath,
+        };
+    }
+    if (args.current.provider !== args.providerName) {
+        return {
+            reuse: false,
+            reason: `provider mismatch: ${args.current.provider} -> ${args.providerName}`,
+            replacedExisting: true,
+            probeAt,
+            logPath: args.logPath,
+            probe: {
                 ok: false,
-                cause: `Health endpoint returned status ${String(response.statusCode ?? 0)}.`,
-            });
-        });
-        request.on("error", (error) => {
-            resolve({
+                stage: "health",
+                attempts: 0,
+                cause: "provider-mismatch",
+                retryable: false,
+                message: "Persisted bridge provider does not match the requested provider.",
+            },
+        };
+    }
+    if (args.current.baseUrl !== args.expectedBaseUrl) {
+        return {
+            reuse: false,
+            reason: `base URL mismatch: ${args.current.baseUrl} -> ${args.expectedBaseUrl}`,
+            replacedExisting: true,
+            probeAt,
+            logPath: args.logPath,
+            probe: {
                 ok: false,
-                cause: error.message,
-            });
-        });
-        request.on("timeout", () => {
-            request.destroy(new Error("Health endpoint timed out."));
-        });
-        request.end();
+                stage: "health",
+                attempts: 0,
+                cause: "base-url-mismatch",
+                retryable: false,
+                message: "Persisted bridge base URL does not match the requested provider runtime base URL.",
+            },
+        };
+    }
+    if (args.current.workerBuildId !== args.workerBuildId) {
+        return {
+            reuse: false,
+            reason: "worker build changed",
+            replacedExisting: true,
+            probeAt,
+            logPath: args.logPath,
+            probe: {
+                ok: false,
+                stage: "health",
+                attempts: 0,
+                cause: "worker-build-stale",
+                retryable: false,
+                message: "Persisted bridge worker build is stale.",
+            },
+        };
+    }
+    const health = await probeBridgeEndpoint({
+        host: args.current.host,
+        port: args.current.port,
+        stage: "health",
+    });
+    appendBridgeLifecycleLog(args.logPath, `probe stage=health attempts=${String(health.attempts)} ok=${String(health.ok)}${health.ok ? "" : ` retryable=${String(health.retryable)} cause=${health.cause}`}`);
+    if (!health.ok) {
+        return {
+            reuse: false,
+            reason: `health probe failed: ${health.message}`,
+            replacedExisting: true,
+            probeAt,
+            logPath: args.logPath,
+            probe: health,
+        };
+    }
+    const auth = await probeBridgeEndpoint({
+        host: args.current.host,
+        port: args.current.port,
+        stage: "auth",
+        apiKey: args.expectedApiKey,
     });
+    appendBridgeLifecycleLog(args.logPath, `probe stage=auth attempts=${String(auth.attempts)} ok=${String(auth.ok)}${auth.ok ? "" : ` retryable=${String(auth.retryable)} cause=${auth.cause}`}`);
+    if (!auth.ok) {
+        return {
+            reuse: false,
+            reason: `auth probe failed: ${auth.message}`,
+            replacedExisting: true,
+            probeAt,
+            logPath: args.logPath,
+            probe: auth,
+        };
+    }
+    return {
+        reuse: true,
+        health,
+        auth,
+        probeAt,
+        logPath: args.logPath,
+    };
 }
-/**
- * Checks whether a healthy bridge still accepts the provider's current bearer secret.
- */
-async function verifyCopilotBridgeAuthorization(host, port, apiKey) {
+async function probeBridgeEndpoint(args) {
+    for (let attempt = 1; attempt <= BRIDGE_REUSE_ATTEMPTS; attempt += 1) {
+        const result = await requestBridgeProbe(args);
+        if (result.ok) {
+            return {
+                ok: true,
+                stage: args.stage,
+                attempts: attempt,
+            };
+        }
+        if (!result.retryable || attempt === BRIDGE_REUSE_ATTEMPTS) {
+            return {
+                ...result,
+                stage: args.stage,
+                attempts: attempt,
+            };
+        }
+        await new Promise((resolve) => setTimeout(resolve, BRIDGE_REUSE_DELAY_MS));
+    }
+    return {
+        ok: false,
+        stage: args.stage,
+        attempts: BRIDGE_REUSE_ATTEMPTS,
+        cause: "transport-timeout",
+        retryable: true,
+        message: "Bridge probe timed out.",
+    };
+}
+async function requestBridgeProbe(args) {
     return new Promise((resolve) => {
         const request = http.request({
-            host,
-            port,
+            host: args.host,
+            port: args.port,
             method: "GET",
-            path: "/v1/models",
-            timeout: 1000,
-            headers: {
-                authorization: `Bearer ${apiKey}`,
-            },
+            path: args.stage === "health" ? "/healthz" : "/v1/models",
+            timeout: BRIDGE_REUSE_TIMEOUT_MS,
+            headers: args.stage === "auth"
+                ? {
+                    authorization: `Bearer ${args.apiKey ?? ""}`,
+                }
+                : undefined,
         }, (response) => {
             response.resume();
             if (response.statusCode === 200) {
                 resolve({ ok: true });
                 return;
             }
+            if (args.stage === "auth" && (response.statusCode === 401 || response.statusCode === 403)) {
+                resolve({
+                    ok: false,
+                    cause: "auth-rejected",
+                    retryable: false,
+                    statusCode: response.statusCode,
+                    message: `Authorization probe returned status ${String(response.statusCode)}.`,
+                });
+                return;
+            }
             resolve({
                 ok: false,
-                cause: `Authorization probe returned status ${String(response.statusCode ?? 0)}.`,
+                cause: args.stage === "health" ? "health-non-200" : "transport-error",
+                retryable: false,
+                statusCode: response.statusCode,
+                message: args.stage === "health"
+                    ? `Health endpoint returned status ${String(response.statusCode ?? 0)}.`
+                    : `Authorization probe returned status ${String(response.statusCode ?? 0)}.`,
             });
         });
         request.on("error", (error) => {
+            const classified = classifyProbeTransportError(error);
             resolve({
                 ok: false,
-                cause: error.message,
+                cause: classified.cause,
+                retryable: classified.retryable,
+                message: error.message,
             });
         });
         request.on("timeout", () => {
-            request.destroy(new Error("Authorization probe timed out."));
+            request.destroy(new Error(args.stage === "health" ? "Health endpoint timed out." : "Authorization probe timed out."));
         });
         request.end();
     });
 }
+function classifyProbeTransportError(error) {
+    const message = error.message.toLowerCase();
+    if (message.includes("timed out") ||
+        message.includes("econnrefused") ||
+        message.includes("econnreset") ||
+        message.includes("socket hang up") ||
+        message.includes("epipe")) {
+        return {
+            cause: message.includes("timed out") ? "transport-timeout" : "transport-error",
+            retryable: true,
+        };
+    }
+    return {
+        cause: "transport-error",
+        retryable: false,
+    };
+}
+function ensureBridgeLogFile(logPath) {
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    if (!fs.existsSync(logPath)) {
+        fs.writeFileSync(logPath, "", "utf8");
+    }
+}
+function openBridgeLogFd(logPath) {
+    ensureBridgeLogFile(logPath);
+    return fs.openSync(logPath, "a");
+}
+function appendBridgeLifecycleLog(logPath, message) {
+    ensureBridgeLogFile(logPath);
+    fs.appendFileSync(logPath, `[${new Date().toISOString()}] ${message}\n`, "utf8");
+}
 async function readJsonBody(request) {
     const chunks = [];
     for await (const chunk of request) {

package/dist/storage/runtime-state-repo.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCopilotBridgeStatePath = getCopilotBridgeStatePath;
+exports.getCopilotBridgeLogPath = getCopilotBridgeLogPath;
 exports.readCopilotBridgeState = readCopilotBridgeState;
 exports.inspectCopilotBridgeState = inspectCopilotBridgeState;
 exports.writeCopilotBridgeState = writeCopilotBridgeState;
@@ -54,6 +55,13 @@ function getCopilotBridgeStatePath(runtimeDir) {
     const baseRuntimeDir = runtimeDir ? path.resolve(runtimeDir) : path.join((0, codex_paths_1.resolveCodexSwitchHome)(), "runtime");
     return path.join(baseRuntimeDir, "copilot-bridge-state.json");
 }
+/**
+ * Returns the persisted bridge runtime log path colocated with the bridge state manifest.
+ */
+function getCopilotBridgeLogPath(runtimeDir) {
+    const statePath = getCopilotBridgeStatePath(runtimeDir);
+    return path.join(path.dirname(statePath), "copilot-bridge.log");
+}
 /**
  * Reads the Copilot bridge state manifest when present.
  */