@junctionpanel/server 0.1.75 → 0.1.77

package/dist/server/server/agent/providers/gemini-agent.js

@@ -1,5 +1,6 @@
 import * as acp from "@agentclientprotocol/sdk";
-import { execSync, spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { spawn } from "node:child_process";
 import { access, open, readdir, readFile, realpath, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
@@ -7,6 +8,7 @@ import { Readable as NodeReadable, Writable as NodeWritable } from "node:stream"
 import { setTimeout as delay } from "node:timers/promises";
 import { z } from "zod";
 import { applyProviderEnv, isProviderCommandAvailable, resolveProviderCommandPrefix, } from "../provider-launch-config.js";
+import { resolveCommandPathWithFallback } from "../../provider-command-resolution.js";
 import { ToolEditInputSchema, ToolEditOutputSchema, ToolReadInputSchema, ToolReadOutputSchema, ToolSearchInputSchema, ToolShellInputSchema, ToolShellOutputSchema, ToolWriteInputSchema, ToolWriteOutputSchema, toEditToolDetail, toReadToolDetail, toSearchToolDetail, toShellToolDetail, toWriteToolDetail, } from "./tool-call-detail-primitives.js";
 import { coerceToolCallId, nonEmptyString } from "./tool-call-mapper-utils.js";
 const GEMINI_PROVIDER = "gemini";
@@ -18,7 +20,8 @@ const GEMINI_RECORDED_SESSION_POLL_INTERVAL_MS = 100;
 const GEMINI_RECORDED_SESSION_DISCOVERY_TIMEOUT_MS = 200;
 const GEMINI_PLAN_TEXT_MAX_BYTES = 64 * 1024;
 const GEMINI_PLAN_TEXT_TRUNCATION_MARKER = "\n\n[Plan truncated because the file exceeded Junction's Gemini plan preview limit.]";
-const GEMINI_ACP_PROBE_TIMEOUT_MS = 3000;
+const GEMINI_ACP_INITIALIZE_TIMEOUT_MS = 12000;
+const GEMINI_ACP_PROBE_TIMEOUT_MS = 12000;
 const GEMINI_ACP_PROBE_CACHE_TTL_MS = 10 * 60000;
 const GEMINI_CAPABILITIES = {
     supportsStreaming: true,
@@ -205,31 +208,48 @@ class AsyncEventQueue {
         return this.items.shift() ?? null;
     }
 }
-function resolveGeminiBinary() {
-    try {
-        const geminiPath = execSync("which gemini", { encoding: "utf8" }).trim();
-        if (geminiPath) {
-            return geminiPath;
-        }
-    }
-    catch {
-        // fall through
-    }
-    throw new Error("Gemini CLI not found. Please install gemini globally so Junction can launch the provider.");
-}
 function formatGeminiLaunchError(error) {
     const message = stringifyUnknown(error);
     return new Error(`Failed to launch Gemini ACP process: ${message}`);
 }
+function resolveGeminiBinary(runtimeSettings) {
+    const env = applyProviderEnv(process.env, runtimeSettings);
+    const geminiPath = resolveCommandPathWithFallback("gemini", {
+        env,
+        platform: process.platform,
+        loginShell: env.SHELL ?? process.env.SHELL ?? null,
+    });
+    if (geminiPath) {
+        return geminiPath;
+    }
+    throw new Error("Gemini CLI not found. Please install gemini globally so Junction can launch the provider.");
+}
+function resolveGeminiLaunchContext(runtimeSettings) {
+    const env = applyProviderEnv(process.env, runtimeSettings);
+    return {
+        env,
+        launchPrefix: resolveProviderCommandPrefix(runtimeSettings?.command, () => resolveGeminiBinary(runtimeSettings)),
+    };
+}
 function getGeminiAcpProbeCacheKey(runtimeSettings) {
+    const mergedEnv = applyProviderEnv(process.env, runtimeSettings);
+    const fingerprintEnv = Object.fromEntries(Object.entries(mergedEnv)
+        // Shell bookkeeping churns frequently and should not invalidate the probe cache.
+        .filter(([key]) => !["OLDPWD", "PWD", "SHLVL", "_"].includes(key))
+        .sort(([left], [right]) => left.localeCompare(right)));
+    const envHash = createHash("sha256")
+        .update(JSON.stringify(fingerprintEnv))
+        .digest("hex");
     return JSON.stringify({
         command: runtimeSettings?.command ?? null,
+        path: mergedEnv.PATH ?? null,
+        envHash,
     });
 }
-async function runGeminiAcpSupportProbe(runtimeSettings) {
-    const launchPrefix = resolveProviderCommandPrefix(runtimeSettings?.command, resolveGeminiBinary);
-    const env = applyProviderEnv(process.env, runtimeSettings);
-    const child = spawn(launchPrefix.command, [...launchPrefix.args, "--help"], {
+async function runGeminiAcpSupportProbe(runtimeSettings, launchFlag) {
+    const { env, launchPrefix } = resolveGeminiLaunchContext(runtimeSettings);
+    const probeArgs = [...launchPrefix.args, launchFlag, "--help"];
+    const child = spawn(launchPrefix.command, probeArgs, {
         env,
         stdio: ["ignore", "pipe", "pipe"],
     });
@@ -250,7 +270,7 @@ async function runGeminiAcpSupportProbe(runtimeSettings) {
                 child.kill();
             }
             finish(() => {
-                reject(new Error("Gemini ACP support probe timed out while checking `gemini --help`."));
+                reject(new Error(`Gemini ACP support probe timed out while checking \`gemini ${launchFlag} --help\`.`));
             });
         }, GEMINI_ACP_PROBE_TIMEOUT_MS);
         child.once("error", (error) => {
@@ -264,54 +284,109 @@ async function runGeminiAcpSupportProbe(runtimeSettings) {
         child.stderr?.on("data", (chunk) => {
             stderr += chunk.toString();
         });
-        child.once("close", () => {
+        child.once("close", (code, signal) => {
             finish(() => {
-                const output = `${stdout}\n${stderr}`;
-                if (output.includes("--acp")) {
+                const output = `${stdout}\n${stderr}`.trim();
+                if (code === 0 && output.includes(launchFlag)) {
                     resolve();
                     return;
                 }
-                reject(new Error("Installed Gemini CLI does not support --acp. Upgrade Gemini CLI to a version that includes ACP support."));
+                if (isGeminiUnsupportedLaunchFlagError(output, launchFlag)) {
+                    reject(new Error(launchFlag === "--acp"
+                        ? "Installed Gemini CLI does not support --acp. Upgrade Gemini CLI to a version that includes ACP support or still exposes --experimental-acp."
+                        : "Installed Gemini CLI does not support ACP launch mode. Upgrade Gemini CLI to a version that includes --acp or --experimental-acp."));
+                    return;
+                }
+                if (typeof code === "number" && code !== 0) {
+                    reject(new Error(`Gemini ACP support probe failed while checking \`gemini ${launchFlag} --help\`: ${output || `process exited with code ${code}`}`));
+                    return;
+                }
+                if (signal) {
+                    reject(new Error(`Gemini ACP support probe failed while checking \`gemini ${launchFlag} --help\`: process exited with signal ${signal}`));
+                    return;
+                }
+                reject(new Error(launchFlag === "--acp"
+                    ? "Installed Gemini CLI does not support --acp. Upgrade Gemini CLI to a version that includes ACP support or still exposes --experimental-acp."
+                    : "Installed Gemini CLI does not support ACP launch mode. Upgrade Gemini CLI to a version that includes --acp or --experimental-acp."));
             });
         });
     });
 }
-export async function ensureGeminiAcpSupport(runtimeSettings) {
+function getCachedGeminiAcpLaunchFlag(runtimeSettings) {
     const cacheKey = getGeminiAcpProbeCacheKey(runtimeSettings);
     const cached = geminiAcpProbeCache.get(cacheKey);
-    if (cached && Date.now() - cached.checkedAt < GEMINI_ACP_PROBE_CACHE_TTL_MS) {
-        if (cached.error) {
-            throw new Error(cached.error.message);
-        }
-        return;
+    if (!cached) {
+        return null;
+    }
+    if (Date.now() - cached.checkedAt >= GEMINI_ACP_PROBE_CACHE_TTL_MS) {
+        geminiAcpProbeCache.delete(cacheKey);
+        return null;
+    }
+    return cached.launchFlag;
+}
+function setCachedGeminiAcpLaunchFlag(runtimeSettings, launchFlag) {
+    geminiAcpProbeCache.set(getGeminiAcpProbeCacheKey(runtimeSettings), {
+        checkedAt: Date.now(),
+        launchFlag,
+    });
+}
+function getGeminiAcpLaunchCandidates(runtimeSettings) {
+    const cached = getCachedGeminiAcpLaunchFlag(runtimeSettings);
+    if (!cached) {
+        return ["--acp", "--experimental-acp"];
+    }
+    return cached === "--acp"
+        ? ["--acp", "--experimental-acp"]
+        : ["--experimental-acp", "--acp"];
+}
+function isGeminiUnsupportedLaunchFlagError(error, launchFlag) {
+    const normalizedMessage = stringifyUnknown(error).toLowerCase();
+    const normalizedFlagPattern = new RegExp(`(^|[^a-z0-9-])${launchFlag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").toLowerCase()}([^a-z0-9-]|$)`);
+    return (normalizedFlagPattern.test(normalizedMessage) &&
+        (normalizedMessage.includes("unknown") ||
+            normalizedMessage.includes("unsupported") ||
+            normalizedMessage.includes("invalid") ||
+            normalizedMessage.includes("unrecognized") ||
+            normalizedMessage.includes("did you mean") ||
+            normalizedMessage.includes("not support")));
+}
+export async function ensureGeminiAcpSupport(runtimeSettings) {
+    const cacheKey = getGeminiAcpProbeCacheKey(runtimeSettings);
+    const cachedLaunchFlag = getCachedGeminiAcpLaunchFlag(runtimeSettings);
+    if (cachedLaunchFlag) {
+        return cachedLaunchFlag;
     }
     const existingInflight = geminiAcpProbeInflight.get(cacheKey);
     if (existingInflight) {
-        await existingInflight;
-        return;
+        return await existingInflight;
     }
     const probePromise = (async () => {
+        let lastUnsupportedError = null;
         try {
-            await runGeminiAcpSupportProbe(runtimeSettings);
-            geminiAcpProbeCache.set(cacheKey, {
-                checkedAt: Date.now(),
-                error: null,
-            });
-        }
-        catch (error) {
-            const normalizedError = error instanceof Error ? error : new Error(stringifyUnknown(error));
-            geminiAcpProbeCache.set(cacheKey, {
-                checkedAt: Date.now(),
-                error: normalizedError,
-            });
-            throw normalizedError;
+            for (const launchFlag of getGeminiAcpLaunchCandidates(runtimeSettings)) {
+                try {
+                    await runGeminiAcpSupportProbe(runtimeSettings, launchFlag);
+                    setCachedGeminiAcpLaunchFlag(runtimeSettings, launchFlag);
+                    return launchFlag;
+                }
+                catch (error) {
+                    const normalizedError = error instanceof Error ? error : new Error(stringifyUnknown(error));
+                    if (isGeminiUnsupportedLaunchFlagError(normalizedError, launchFlag)) {
+                        lastUnsupportedError = normalizedError;
+                        continue;
+                    }
+                    throw normalizedError;
+                }
+            }
         }
         finally {
             geminiAcpProbeInflight.delete(cacheKey);
         }
+        throw (lastUnsupportedError ??
+            new Error("Installed Gemini CLI does not support ACP launch mode. Upgrade Gemini CLI to a version that includes --acp or --experimental-acp."));
     })();
     geminiAcpProbeInflight.set(cacheKey, probePromise);
-    await probePromise;
+    return await probePromise;
 }
 export function clearGeminiAcpSupportCacheForTests() {
     geminiAcpProbeCache.clear();
@@ -1466,7 +1541,6 @@ class GeminiAgentSession {
         if (this.initialized) {
             return;
         }
-        await ensureGeminiAcpSupport(this.runtimeSettings);
         await this.openConnection();
         this.initialized = true;
     }
@@ -1738,6 +1812,25 @@ class GeminiAgentSession {
         this.connection = null;
         this.child = null;
     }
+    async teardownPartialConnection(params) {
+        this.finishHistoryCapture();
+        if (params.child.stdin) {
+            params.child.stdin.end();
+        }
+        if (!params.child.killed) {
+            params.child.kill();
+        }
+        await params.closePromise.catch(() => { });
+        if (this.connection === params.connection) {
+            this.connection = null;
+        }
+        if (this.child === params.child) {
+            this.child = null;
+        }
+        if (this.closePromise === params.closePromise) {
+            this.closePromise = Promise.resolve();
+        }
+    }
     async setModel(modelId) {
         await this.initialize();
         const normalizedModelId = typeof modelId === "string" && modelId.trim().length > 0 ? modelId.trim() : null;
@@ -1762,16 +1855,26 @@ class GeminiAgentSession {
         this.config.model = normalizedModelId;
     }
     async setThinkingOption(_thinkingOptionId) { }
-    async openConnection() {
-        const launchPrefix = resolveProviderCommandPrefix(this.runtimeSettings?.command, resolveGeminiBinary);
-        const env = applyProviderEnv(process.env, this.runtimeSettings);
-        const launchArgs = [...launchPrefix.args, "--acp"];
+    buildLaunchFailureMessage(params) {
+        if (params.stderr) {
+            return params.stderr;
+        }
+        if (typeof params.code === "number" && params.code !== 0) {
+            return `Gemini ACP process exited with code ${params.code}`;
+        }
+        if (params.signal) {
+            return `Gemini ACP process exited with signal ${params.signal}`;
+        }
+        return "Gemini ACP process closed before initialization";
+    }
+    async startConnectionWithLaunchFlag(launchFlag) {
+        const { env, launchPrefix } = resolveGeminiLaunchContext(this.runtimeSettings);
+        const launchArgs = [...launchPrefix.args, launchFlag];
         const child = spawn(launchPrefix.command, launchArgs, {
             cwd: this.config.cwd,
             env,
             stdio: ["pipe", "pipe", "pipe"],
         });
-        this.child = child;
         let initializing = true;
         let rejectLaunchFailure = null;
         const launchFailure = new Promise((_, reject) => {
@@ -1787,35 +1890,49 @@ class GeminiAgentSession {
                 cwd: this.config.cwd,
             }, "Gemini ACP process failed to launch");
             if (initializing) {
-                this.connection = null;
-                this.child = null;
-                this.closePromise = Promise.resolve();
                 rejectLaunchFailure?.(launchError);
             }
         });
         if (!child.stdin || !child.stdout || !child.stderr) {
-            await this.close().catch(() => { });
+            if (!child.killed) {
+                child.kill();
+            }
             throw new Error("Gemini ACP process did not expose stdio pipes");
         }
         const stderrChunks = [];
         child.stderr.on("data", (chunk) => {
-            const text = chunk.toString("utf8");
+            const text = chunk.toString();
             if (text.length > 0) {
                 stderrChunks.push(text);
             }
         });
-        this.closePromise = new Promise((resolve) => {
+        const stream = acp.ndJsonStream(NodeWritable.toWeb(child.stdin), NodeReadable.toWeb(child.stdout));
+        const connection = new acp.ClientSideConnection(() => ({
+            sessionUpdate: async (notification) => {
+                await this.handleSessionUpdate(notification);
+            },
+            requestPermission: async (request) => this.handlePermissionRequest(request),
+        }), stream);
+        const closePromise = new Promise((resolve) => {
             child.once("close", (code, signal) => {
                 const stderr = stderrChunks.join("").trim();
-                this.child = null;
-                this.connection = null;
+                const message = this.buildLaunchFailureMessage({
+                    code,
+                    signal,
+                    stderr,
+                });
+                if (initializing) {
+                    rejectLaunchFailure?.(new Error(message));
+                    resolve();
+                    return;
+                }
+                if (this.child === child) {
+                    this.child = null;
+                }
+                if (this.connection === connection) {
+                    this.connection = null;
+                }
                 if (!this.closed) {
-                    const message = stderr ||
-                        (typeof code === "number" && code !== 0
-                            ? `Gemini ACP process exited with code ${code}`
-                            : signal
-                                ? `Gemini ACP process exited with signal ${signal}`
-                                : "Gemini ACP process closed");
                     if (this.activeTurnQueue) {
                         this.activeTurnQueue.push({
                             type: "turn_failed",
@@ -1829,16 +1946,9 @@ class GeminiAgentSession {
                 resolve();
             });
         });
-        const stream = acp.ndJsonStream(NodeWritable.toWeb(child.stdin), NodeReadable.toWeb(child.stdout));
-        this.connection = new acp.ClientSideConnection(() => ({
-            sessionUpdate: async (notification) => {
-                await this.handleSessionUpdate(notification);
-            },
-            requestPermission: async (request) => this.handlePermissionRequest(request),
-        }), stream);
         try {
             await Promise.race([
-                this.connection.initialize({
+                connection.initialize({
                     protocolVersion: acp.PROTOCOL_VERSION,
                     clientCapabilities: {
                         fs: {
@@ -1853,15 +1963,32 @@ class GeminiAgentSession {
                     },
                 }),
                 launchFailure,
+                delay(GEMINI_ACP_INITIALIZE_TIMEOUT_MS).then(() => {
+                    throw new Error(`Gemini ACP initialization timed out while launching with \`${launchFlag}\`.`);
+                }),
             ]);
             initializing = false;
+            this.child = child;
+            this.connection = connection;
+            this.closePromise = closePromise;
+        }
+        catch (error) {
+            initializing = false;
+            child.stdin.end();
+            if (!child.killed) {
+                child.kill();
+            }
+            await closePromise.catch(() => { });
+            throw error;
+        }
+        try {
             if (this.sessionId) {
                 const recordedSessionMatch = await findGeminiRecordedSessionForCwd(this.config.cwd, this.sessionId);
                 const recordedSession = recordedSessionMatch?.session ?? null;
                 this.hasObservedRecordedSession = recordedSession !== null;
                 this.recordedSessionFilePath = recordedSessionMatch?.filePath ?? null;
                 this.beginHistoryCapture(recordedSession ? countGeminiRecordedHistoryEvents(recordedSession) : null);
-                const response = await this.connection.loadSession({
+                const response = await connection.loadSession({
                     sessionId: this.sessionId,
                     cwd: this.config.cwd,
                     mcpServers: toGeminiAcpMcpServers(this.config.mcpServers),
@@ -1875,7 +2002,7 @@ class GeminiAgentSession {
                 }
             }
             else {
-                const response = await this.connection.newSession({
+                const response = await connection.newSession({
                     cwd: this.config.cwd,
                     mcpServers: toGeminiAcpMcpServers(this.config.mcpServers),
                 });
@@ -1883,13 +2010,42 @@ class GeminiAgentSession {
                 this.applySessionSetup(response);
             }
             await this.applyRequestedOverrides();
+            setCachedGeminiAcpLaunchFlag(this.runtimeSettings, launchFlag);
         }
         catch (error) {
-            initializing = false;
-            await this.close().catch(() => { });
+            await this.teardownPartialConnection({
+                child,
+                connection,
+                closePromise,
+            });
             throw new Error(formatGeminiAcpError(error));
         }
     }
+    async openConnection() {
+        let lastUnsupportedError = null;
+        for (const launchFlag of getGeminiAcpLaunchCandidates(this.runtimeSettings)) {
+            try {
+                await this.startConnectionWithLaunchFlag(launchFlag);
+                return;
+            }
+            catch (error) {
+                const normalizedError = error instanceof Error ? error : new Error(stringifyUnknown(error));
+                if (isGeminiUnsupportedLaunchFlagError(normalizedError, launchFlag)) {
+                    lastUnsupportedError = normalizedError;
+                    this.logger.info({
+                        launchFlag,
+                        message: normalizedError.message,
+                        normalizedMessage: normalizedError.message.toLowerCase(),
+                        classifier: "isGeminiUnsupportedLaunchFlagError",
+                    }, "Gemini ACP launch flag unsupported; trying next candidate");
+                    continue;
+                }
+                throw normalizedError;
+            }
+        }
+        throw (lastUnsupportedError ??
+            new Error("Installed Gemini CLI does not support ACP launch mode. Upgrade Gemini CLI to a version that includes --acp or --experimental-acp."));
+    }
     applySessionSetup(response) {
         if (response.modes) {
             this.availableModes = response.modes.availableModes.map((mode) => toAgentMode(mode));