@quantum-ai/gemini-cli 0.45.8 → 0.45.9

package/dist/nonInteractiveCliAgentSession.js

@@ -0,0 +1,527 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { isSlashCommand } from './ui/utils/commandUtils.js';
+import { convertSessionToClientHistory, FatalError, FatalAuthenticationError, FatalInputError, FatalSandboxError, FatalConfigError, FatalTurnLimitedError, FatalToolExecutionError, FatalCancellationError, promptIdContext, OutputFormat, JsonFormatter, StreamJsonFormatter, JsonStreamEventType, uiTelemetryService, coreEvents, CoreEvent, createWorkingStdio, Scheduler, ROOT_SCHEDULER_ID, LegacyAgentSession, ToolErrorType, geminiPartsToContentParts, displayContentToString, debugLogger, } from '@google/gemini-cli-core';
+import readline from 'node:readline';
+import stripAnsi from 'strip-ansi';
+import { handleSlashCommand } from './nonInteractiveCliCommands.js';
+import { ConsolePatcher } from './ui/utils/ConsolePatcher.js';
+import { handleAtCommand } from './ui/hooks/atCommandProcessor.js';
+import { handleError, handleToolError } from './utils/errors.js';
+import { TextOutput } from './ui/utils/textOutput.js';
+/**
+ * Runs the non-interactive CLI using the LegacyAgentSession.
+ *
+ * Programmatic output formats (JSON, STREAM_JSON) use lenient sanitization
+ * by stripping ANSI escape sequences from messages to ensure clean,
+ * parseable output for downstream consumers.
+ */
+export async function runNonInteractive({ config, settings, input, prompt_id, resumedSessionData, }) {
+    return promptIdContext.run(prompt_id, async () => {
+        const consolePatcher = new ConsolePatcher({
+            stderr: true,
+            interactive: false,
+            debugMode: config.getDebugMode(),
+            onNewMessage: (msg) => {
+                coreEvents.emitConsoleLog(msg.type, msg.content);
+            },
+        });
+        if (process.env['GEMINI_CLI_ACTIVITY_LOG_TARGET']) {
+            const { setupInitialActivityLogger } = await import('./utils/devtoolsService.js');
+            setupInitialActivityLogger(config);
+        }
+        const { stdout: workingStdout } = createWorkingStdio();
+        const textOutput = new TextOutput(workingStdout);
+        const handleUserFeedback = (payload) => {
+            const prefix = payload.severity.toUpperCase();
+            process.stderr.write(`[${prefix}] ${payload.message}\n`);
+            if (payload.error && config.getDebugMode()) {
+                const errorToLog = payload.error instanceof Error
+                    ? payload.error.stack || payload.error.message
+                    : String(payload.error);
+                process.stderr.write(`${errorToLog}\n`);
+            }
+        };
+        const startTime = Date.now();
+        const streamFormatter = config.getOutputFormat() === OutputFormat.STREAM_JSON
+            ? new StreamJsonFormatter()
+            : null;
+        const abortController = new AbortController();
+        // Track cancellation state
+        let isAborting = false;
+        let cancelMessageTimer = null;
+        // Setup stdin listener for Ctrl+C detection
+        let stdinWasRaw = false;
+        let rl = null;
+        const setupStdinCancellation = () => {
+            // Only setup if stdin is a TTY (user can interact)
+            if (!process.stdin.isTTY) {
+                return;
+            }
+            // Save original raw mode state
+            stdinWasRaw = process.stdin.isRaw || false;
+            // Enable raw mode to capture individual keypresses
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+            // Setup readline to emit keypress events
+            rl = readline.createInterface({
+                input: process.stdin,
+                escapeCodeTimeout: 0,
+            });
+            readline.emitKeypressEvents(process.stdin, rl);
+            // Listen for Ctrl+C
+            const keypressHandler = (str, key) => {
+                // Detect Ctrl+C: either ctrl+c key combo or raw character code 3
+                if ((key && key.ctrl && key.name === 'c') || str === '\u0003') {
+                    // Only handle once
+                    if (isAborting) {
+                        return;
+                    }
+                    isAborting = true;
+                    // Only show message if cancellation takes longer than 200ms
+                    // This reduces verbosity for fast cancellations
+                    cancelMessageTimer = setTimeout(() => {
+                        process.stderr.write('\nCancelling...\n');
+                    }, 200);
+                    abortController.abort();
+                }
+            };
+            process.stdin.on('keypress', keypressHandler);
+        };
+        const cleanupStdinCancellation = () => {
+            // Clear any pending cancel message timer
+            if (cancelMessageTimer) {
+                clearTimeout(cancelMessageTimer);
+                cancelMessageTimer = null;
+            }
+            // Cleanup readline and stdin listeners
+            if (rl) {
+                rl.close();
+                rl = null;
+            }
+            // Remove keypress listener
+            process.stdin.removeAllListeners('keypress');
+            // Restore stdin to original state
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(stdinWasRaw);
+                process.stdin.pause();
+            }
+        };
+        let errorToHandle;
+        let scheduler;
+        let abortSession = () => { };
+        // Set overall timeout to prevent indefinite hangs
+        const overallTimeoutMs = 60000; // 60 seconds
+        const overallTimeoutId = setTimeout(() => {
+            debugLogger.warn(`Overall timeout of ${overallTimeoutMs}ms reached, aborting.`);
+            abortController.abort();
+        }, overallTimeoutMs);
+        try {
+            consolePatcher.patch();
+            if (config.getRawOutput() &&
+                !config.getAcceptRawOutputRisk() &&
+                config.getOutputFormat() === OutputFormat.TEXT) {
+                process.stderr.write('[WARNING] --raw-output is enabled. Model output is not sanitized and may contain harmful ANSI sequences (e.g. for phishing or command injection). Use --accept-raw-output-risk to suppress this warning.\n');
+            }
+            // Setup stdin cancellation listener
+            setupStdinCancellation();
+            coreEvents.on(CoreEvent.UserFeedback, handleUserFeedback);
+            coreEvents.drainBacklogs();
+            // Handle EPIPE errors when the output is piped to a command that closes early.
+            process.stdout.on('error', (err) => {
+                if (err.code === 'EPIPE') {
+                    // Exit gracefully if the pipe is closed.
+                    cleanupStdinCancellation();
+                    consolePatcher.cleanup();
+                    process.exit(0);
+                }
+            });
+            const geminiClient = config.getGeminiClient();
+            scheduler = new Scheduler({
+                context: config,
+                messageBus: config.getMessageBus(),
+                getPreferredEditor: () => undefined,
+                schedulerId: ROOT_SCHEDULER_ID,
+            });
+            // Initialize chat.  Resume if resume data is passed.
+            if (resumedSessionData) {
+                await geminiClient.resumeChat(convertSessionToClientHistory(resumedSessionData.conversation.messages), resumedSessionData);
+            }
+            // Emit init event for streaming JSON
+            if (streamFormatter) {
+                streamFormatter.emitEvent({
+                    type: JsonStreamEventType.INIT,
+                    timestamp: new Date().toISOString(),
+                    session_id: config.getSessionId(),
+                    model: config.getModel(),
+                });
+            }
+            let query;
+            if (isSlashCommand(input)) {
+                const slashCommandResult = await handleSlashCommand(input, abortController, config, settings);
+                if (slashCommandResult) {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                    query = slashCommandResult;
+                }
+            }
+            if (!query) {
+                const { processedQuery, error } = await handleAtCommand({
+                    query: input,
+                    config,
+                    addItem: (_item, _timestamp) => 0,
+                    onDebugMessage: () => { },
+                    messageId: Date.now(),
+                    signal: abortController.signal,
+                    escapePastedAtSymbols: false,
+                });
+                if (error || !processedQuery) {
+                    throw new FatalInputError(error || 'Exiting due to an error processing the @ command.');
+                }
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                query = processedQuery;
+            }
+            // Emit user message event for streaming JSON
+            if (streamFormatter) {
+                streamFormatter.emitEvent({
+                    type: JsonStreamEventType.MESSAGE,
+                    timestamp: new Date().toISOString(),
+                    role: 'user',
+                    content: input,
+                });
+            }
+            // Create LegacyAgentSession — owns the agentic loop
+            const session = new LegacyAgentSession({
+                client: geminiClient,
+                scheduler,
+                config,
+                promptId: prompt_id,
+            });
+            // Wire Ctrl+C to session abort
+            abortSession = () => {
+                void session.abort();
+            };
+            abortController.signal.addEventListener('abort', abortSession);
+            if (abortController.signal.aborted) {
+                throw new FatalCancellationError('Operation cancelled.');
+            }
+            // Start the agentic loop (runs in background)
+            const sendTimeoutMs = 30000; // 30 seconds timeout to prevent hanging
+            let streamId = null;
+            try {
+                await Promise.race([
+                    session.send({
+                        message: {
+                            content: geminiPartsToContentParts(query),
+                            displayContent: input,
+                        },
+                    }).then((result) => {
+                        streamId = result.streamId;
+                    }),
+                    new Promise((_, reject) => {
+                        setTimeout(() => {
+                            reject(new Error('Session send timeout after 30 seconds'));
+                        }, sendTimeoutMs);
+                    }),
+                ]);
+            }
+            catch (error) {
+                throw new Error(`Failed to send message: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            if (streamId === null) {
+                throw new Error('LegacyAgentSession.send() unexpectedly returned no stream for a message send.');
+            }
+            const getTextContent = (parts) => {
+                const text = parts
+                    ?.map((part) => (part.type === 'text' ? part.text : ''))
+                    .join('');
+                return text ? text : undefined;
+            };
+            const emitFinalSuccessResult = () => {
+                if (streamFormatter) {
+                    const metrics = uiTelemetryService.getMetrics();
+                    const durationMs = Date.now() - startTime;
+                    streamFormatter.emitEvent({
+                        type: JsonStreamEventType.RESULT,
+                        timestamp: new Date().toISOString(),
+                        status: 'success',
+                        stats: streamFormatter.convertToStreamStats(metrics, durationMs),
+                    });
+                }
+                else if (config.getOutputFormat() === OutputFormat.JSON) {
+                    const formatter = new JsonFormatter();
+                    const stats = uiTelemetryService.getMetrics();
+                    textOutput.write(formatter.format(config.getSessionId(), responseText, stats, undefined, warnings));
+                }
+                else {
+                    textOutput.ensureTrailingNewline();
+                }
+            };
+            const reconstructFatalError = (event) => {
+                const errorMeta = event._meta;
+                const name = typeof errorMeta?.['errorName'] === 'string'
+                    ? errorMeta['errorName']
+                    : undefined;
+                let errToThrow;
+                switch (name) {
+                    case 'FatalAuthenticationError':
+                        errToThrow = new FatalAuthenticationError(event.message);
+                        break;
+                    case 'FatalInputError':
+                        errToThrow = new FatalInputError(event.message);
+                        break;
+                    case 'FatalSandboxError':
+                        errToThrow = new FatalSandboxError(event.message);
+                        break;
+                    case 'FatalConfigError':
+                        errToThrow = new FatalConfigError(event.message);
+                        break;
+                    case 'FatalTurnLimitedError':
+                        errToThrow = new FatalTurnLimitedError(event.message);
+                        break;
+                    case 'FatalToolExecutionError':
+                        errToThrow = new FatalToolExecutionError(event.message);
+                        break;
+                    case 'FatalCancellationError':
+                        errToThrow = new FatalCancellationError(event.message);
+                        break;
+                    case 'FatalError':
+                        errToThrow = new FatalError(event.message, typeof errorMeta?.['exitCode'] === 'number'
+                            ? errorMeta['exitCode']
+                            : 1);
+                        break;
+                    default:
+                        errToThrow = new Error(event.message);
+                        if (name) {
+                            Object.defineProperty(errToThrow, 'name', {
+                                value: name,
+                                enumerable: true,
+                            });
+                        }
+                        break;
+                }
+                if (errorMeta?.['exitCode'] !== undefined) {
+                    Object.defineProperty(errToThrow, 'exitCode', {
+                        value: errorMeta['exitCode'],
+                        enumerable: true,
+                    });
+                }
+                if (errorMeta?.['code'] !== undefined) {
+                    Object.defineProperty(errToThrow, 'code', {
+                        value: errorMeta['code'],
+                        enumerable: true,
+                    });
+                }
+                if (errorMeta?.['status'] !== undefined) {
+                    Object.defineProperty(errToThrow, 'status', {
+                        value: errorMeta['status'],
+                        enumerable: true,
+                    });
+                }
+                return errToThrow;
+            };
+            // Consume AgentEvents for output formatting
+            let responseText = '';
+            let preToolResponseText;
+            let streamEnded = false;
+            const warnings = [];
+            for await (const event of session.stream({ streamId })) {
+                if (streamEnded)
+                    break;
+                switch (event.type) {
+                    case 'message': {
+                        if (event.role === 'agent') {
+                            for (const part of event.content) {
+                                if (part.type === 'text') {
+                                    const isRaw = config.getRawOutput() || config.getAcceptRawOutputRisk();
+                                    const output = isRaw ? part.text : stripAnsi(part.text);
+                                    if (streamFormatter) {
+                                        streamFormatter.emitEvent({
+                                            type: JsonStreamEventType.MESSAGE,
+                                            timestamp: new Date().toISOString(),
+                                            role: 'assistant',
+                                            content: output,
+                                            delta: true,
+                                        });
+                                    }
+                                    else if (config.getOutputFormat() === OutputFormat.JSON) {
+                                        responseText += output;
+                                    }
+                                    else {
+                                        if (part.text) {
+                                            textOutput.write(output);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        break;
+                    }
+                    case 'tool_request': {
+                        if (config.getOutputFormat() === OutputFormat.JSON) {
+                            // Final JSON output should reflect the last assistant answer after
+                            // any tool orchestration, not intermediate pre-tool text.
+                            preToolResponseText = responseText || preToolResponseText;
+                            responseText = '';
+                        }
+                        if (streamFormatter) {
+                            streamFormatter.emitEvent({
+                                type: JsonStreamEventType.TOOL_USE,
+                                timestamp: new Date().toISOString(),
+                                tool_name: event.name,
+                                tool_id: event.requestId,
+                                parameters: event.args,
+                            });
+                        }
+                        break;
+                    }
+                    case 'tool_response': {
+                        textOutput.ensureTrailingNewline();
+                        if (streamFormatter) {
+                            const display = event.display?.result;
+                            const displayText = displayContentToString(display);
+                            const errorMsg = getTextContent(event.content) ?? 'Tool error';
+                            streamFormatter.emitEvent({
+                                type: JsonStreamEventType.TOOL_RESULT,
+                                timestamp: new Date().toISOString(),
+                                tool_id: event.requestId,
+                                status: event.isError ? 'error' : 'success',
+                                output: displayText,
+                                error: event.isError
+                                    ? {
+                                        type: typeof event.data?.['errorType'] === 'string'
+                                            ? event.data['errorType']
+                                            : 'TOOL_EXECUTION_ERROR',
+                                        message: errorMsg,
+                                    }
+                                    : undefined,
+                            });
+                        }
+                        if (event.isError) {
+                            const display = event.display?.result;
+                            const displayText = displayContentToString(display);
+                            const errorMsg = getTextContent(event.content) ?? 'Tool error';
+                            if (event.data?.['errorType'] === ToolErrorType.STOP_EXECUTION) {
+                                if (config.getOutputFormat() === OutputFormat.JSON &&
+                                    !responseText &&
+                                    preToolResponseText) {
+                                    responseText = preToolResponseText;
+                                }
+                                const stopMessage = `Agent execution stopped: ${errorMsg}`;
+                                if (config.getOutputFormat() === OutputFormat.TEXT) {
+                                    process.stderr.write(`${stopMessage}\n`);
+                                }
+                            }
+                            if (event.data?.['errorType'] === ToolErrorType.NO_SPACE_LEFT) {
+                                throw new FatalToolExecutionError('Error executing tool ' +
+                                    event.name +
+                                    ': ' +
+                                    (displayText || errorMsg));
+                            }
+                            handleToolError(event.name, new Error(errorMsg), config, typeof event.data?.['errorType'] === 'string'
+                                ? event.data['errorType']
+                                : undefined, displayText);
+                        }
+                        break;
+                    }
+                    case 'error': {
+                        if (event.fatal) {
+                            throw reconstructFatalError(event);
+                        }
+                        const errorCode = event._meta?.['code'];
+                        if (errorCode === 'AGENT_EXECUTION_BLOCKED') {
+                            const blockMessage = `Agent execution blocked: ${event.message.trim()}`;
+                            if (config.getOutputFormat() === OutputFormat.TEXT) {
+                                process.stderr.write(`[WARNING] ${blockMessage}\n`);
+                            }
+                            else if (streamFormatter) {
+                                streamFormatter.emitEvent({
+                                    type: JsonStreamEventType.ERROR,
+                                    timestamp: new Date().toISOString(),
+                                    severity: 'warning',
+                                    message: stripAnsi(blockMessage),
+                                });
+                            }
+                            warnings.push(blockMessage);
+                            break;
+                        }
+                        const severity = event.status === 'RESOURCE_EXHAUSTED' ? 'error' : 'warning';
+                        if (config.getOutputFormat() === OutputFormat.TEXT) {
+                            process.stderr.write(`[WARNING] ${event.message}\n`);
+                        }
+                        if (streamFormatter) {
+                            streamFormatter.emitEvent({
+                                type: JsonStreamEventType.ERROR,
+                                timestamp: new Date().toISOString(),
+                                severity,
+                                message: stripAnsi(event.message),
+                            });
+                        }
+                        warnings.push(event.message);
+                        break;
+                    }
+                    case 'agent_end': {
+                        if (event.reason === 'aborted') {
+                            throw new FatalCancellationError('Operation cancelled.');
+                        }
+                        else if (event.reason === 'max_turns') {
+                            const isConfiguredTurnLimit = typeof event.data?.['maxTurns'] === 'number' ||
+                                typeof event.data?.['turnCount'] === 'number';
+                            if (isConfiguredTurnLimit) {
+                                throw new FatalTurnLimitedError('Reached max session turns for this session. Increase the number of turns by specifying maxSessionTurns in settings.json.');
+                            }
+                            else if (streamFormatter) {
+                                streamFormatter.emitEvent({
+                                    type: JsonStreamEventType.ERROR,
+                                    timestamp: new Date().toISOString(),
+                                    severity: 'error',
+                                    message: 'Maximum session turns exceeded',
+                                });
+                            }
+                        }
+                        const stopMessage = typeof event.data?.['message'] === 'string'
+                            ? event.data['message']
+                            : '';
+                        if (stopMessage && config.getOutputFormat() === OutputFormat.TEXT) {
+                            process.stderr.write(`Agent execution stopped: ${stopMessage}\n`);
+                        }
+                        emitFinalSuccessResult();
+                        streamEnded = true;
+                        break;
+                    }
+                    case 'initialize':
+                    case 'session_update':
+                    case 'agent_start':
+                    case 'tool_update':
+                    case 'elicitation_request':
+                    case 'elicitation_response':
+                    case 'usage':
+                    case 'custom':
+                        // Explicitly ignore these non-interactive events
+                        break;
+                    default:
+                        debugLogger.error('Unknown agent event type:', event);
+                        event;
+                        break;
+                }
+            }
+        }
+        catch (error) {
+            errorToHandle = error;
+        }
+        finally {
+            // Cleanup stdin cancellation before other cleanup
+            cleanupStdinCancellation();
+            abortController.signal.removeEventListener('abort', abortSession);
+            clearTimeout(overallTimeoutId);
+            scheduler?.dispose();
+            consolePatcher.cleanup();
+            coreEvents.off(CoreEvent.UserFeedback, handleUserFeedback);
+        }
+        if (errorToHandle) {
+            handleError(errorToHandle, config);
+        }
+    });
+}

package/dist/nonInteractiveCliCommands.js

@@ -0,0 +1,82 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { parseSlashCommand } from './utils/commands.js';
+import { FatalInputError, Logger, uiTelemetryService, } from '@google/gemini-cli-core';
+import { CommandService } from './services/CommandService.js';
+import { BuiltinCommandLoader } from './services/BuiltinCommandLoader.js';
+import { FileCommandLoader } from './services/FileCommandLoader.js';
+import { McpPromptLoader } from './services/McpPromptLoader.js';
+import { createNonInteractiveUI } from './ui/noninteractive/nonInteractiveUi.js';
+/**
+ * Processes a slash command in a non-interactive environment.
+ *
+ * @returns A Promise that resolves to `PartListUnion` if a valid command is
+ *   found and results in a prompt, or `undefined` otherwise.
+ * @throws {FatalInputError} if the command result is not supported in
+ *   non-interactive mode.
+ */
+export const handleSlashCommand = async (rawQuery, abortController, config, settings) => {
+    const trimmed = rawQuery.trim();
+    if (!trimmed.startsWith('/')) {
+        return;
+    }
+    const commandService = await CommandService.create([
+        new BuiltinCommandLoader(config),
+        new McpPromptLoader(config),
+        new FileCommandLoader(config),
+    ], abortController.signal);
+    const commands = commandService.getCommands();
+    const { commandToExecute, args } = parseSlashCommand(rawQuery, commands);
+    if (commandToExecute) {
+        if (commandToExecute.action) {
+            // Not used by custom commands but may be in the future.
+            const sessionStats = {
+                sessionId: config?.getSessionId(),
+                sessionStartTime: new Date(),
+                metrics: uiTelemetryService.getMetrics(),
+                lastPromptTokenCount: 0,
+                promptCount: 1,
+            };
+            const logger = new Logger(config?.getSessionId() || '', config?.storage);
+            const commandContext = {
+                services: {
+                    agentContext: config,
+                    settings,
+                    git: undefined,
+                    logger,
+                },
+                ui: createNonInteractiveUI(),
+                session: {
+                    stats: sessionStats,
+                    sessionShellAllowlist: new Set(),
+                },
+                invocation: {
+                    raw: trimmed,
+                    name: commandToExecute.name,
+                    args,
+                },
+            };
+            const result = await commandToExecute.action(commandContext, args);
+            if (result) {
+                switch (result.type) {
+                    case 'submit_prompt':
+                        return result.content;
+                    case 'confirm_shell_commands':
+                        // This result indicates a command attempted to confirm shell commands.
+                        // However note that currently, ShellTool is excluded in non-interactive
+                        // mode unless 'YOLO mode' is active, so confirmation actually won't
+                        // occur because of YOLO mode.
+                        // This ensures that if a command *does* request confirmation (e.g.
+                        // in the future with more granular permissions), it's handled appropriately.
+                        throw new FatalInputError('Exiting due to a confirmation prompt requested by the command.');
+                    default:
+                        throw new FatalInputError('Exiting due to command result that is not supported in non-interactive mode.');
+                }
+            }
+        }
+    }
+    return;
+};

package/dist/patches/http-proxy-agent.js

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// eslint-disable-next-line import/no-relative-packages
+export { HttpProxyAgent } from '../../../../node_modules/http-proxy-agent/dist/index.js';

package/dist/patches/https-proxy-agent.js

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// eslint-disable-next-line import/no-relative-packages
+export { HttpsProxyAgent } from '../../../../node_modules/https-proxy-agent/dist/index.js';

package/dist/patches/is-in-ci.js

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// This is a replacement for the `is-in-ci` package that always returns false.
+// We are doing this to avoid the issue where `ink` does not render the UI
+// when it detects that it is running in a CI environment.
+// This is safe because `ink` (and thus `is-in-ci`) is only used in the
+// interactive code path of the CLI.
+// See issue #1563 for more details.
+const isInCi = false;
+// eslint-disable-next-line import/no-default-export
+export default isInCi;