@quantum-ai/gemini-cli 0.45.8 → 0.45.9

package/dist/ui/utils/commandUtils.js

@@ -0,0 +1,259 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { debugLogger } from '@google/gemini-cli-core';
+import clipboardy from 'clipboardy';
+import fs from 'node:fs';
+import { AT_COMMAND_PATH_REGEX_SOURCE } from '../hooks/atCommandProcessor.js';
+// Pre-compiled regex for detecting @<path> patterns consistent with parseAllAtCommands.
+// Uses the same AT_COMMAND_PATH_REGEX_SOURCE so that isAtCommand is true whenever
+// parseAllAtCommands would find at least one atPath part.
+const AT_COMMAND_DETECT_REGEX = new RegExp(`(?<!\\\\)@${AT_COMMAND_PATH_REGEX_SOURCE}`);
+/**
+ * Checks if a query string potentially represents an '@' command.
+ * Returns true if the query contains any '@<path>' pattern that would be
+ * recognised by the @ command processor, regardless of what character
+ * precedes the '@' sign. This ensures that prompts written in an external
+ * editor (where '@' may follow punctuation like ':' or '(') are correctly
+ * identified and their referenced files pre-loaded before the query is sent
+ * to the model.
+ *
+ * @param query The input query string.
+ * @returns True if the query looks like an '@' command, false otherwise.
+ */
+export const isAtCommand = (query) => AT_COMMAND_DETECT_REGEX.test(query);
+/**
+ * Checks if a query string potentially represents an '/' command.
+ * It triggers if the query starts with '/' but excludes code comments like '//' and '/*'.
+ *
+ * @param query The input query string.
+ * @returns True if the query looks like an '/' command, false otherwise.
+ */
+export const isSlashCommand = (query) => {
+    if (!query.startsWith('/')) {
+        return false;
+    }
+    // Exclude line comments that start with '//'
+    if (query.startsWith('//')) {
+        return false;
+    }
+    // Exclude block comments that start with '/*'
+    if (query.startsWith('/*')) {
+        return false;
+    }
+    return true;
+};
+const ESC = '\u001B';
+const BEL = '\u0007';
+const ST = '\u001B\\';
+const MAX_OSC52_SEQUENCE_BYTES = 100_000;
+const OSC52_HEADER = `${ESC}]52;c;`;
+const OSC52_FOOTER = BEL;
+const MAX_OSC52_BODY_B64_BYTES = MAX_OSC52_SEQUENCE_BYTES -
+    Buffer.byteLength(OSC52_HEADER) -
+    Buffer.byteLength(OSC52_FOOTER);
+const MAX_OSC52_DATA_BYTES = Math.floor(MAX_OSC52_BODY_B64_BYTES / 4) * 3;
+// Conservative chunk size for GNU screen DCS passthrough.
+const SCREEN_DCS_CHUNK_SIZE = 240;
+const pickTty = () => new Promise((resolve) => {
+    // /dev/tty is only available on Unix-like systems (Linux, macOS, BSD, etc.)
+    if (process.platform !== 'win32') {
+        // Prefer the controlling TTY to avoid interleaving escape sequences with piped stdout.
+        try {
+            const devTty = fs.createWriteStream('/dev/tty');
+            // Safety timeout: if /dev/tty doesn't respond quickly, fallback to avoid hanging.
+            const timeout = setTimeout(() => {
+                // Remove listeners to prevent them from firing after timeout.
+                devTty.removeAllListeners('open');
+                devTty.removeAllListeners('error');
+                devTty.destroy();
+                resolve(getStdioTty());
+            }, 100);
+            // If we can't open it (e.g. sandbox), we'll get an error.
+            // We wait for 'open' to confirm it's usable, or 'error' to fallback.
+            // If it opens, we resolve with the stream.
+            devTty.once('open', () => {
+                clearTimeout(timeout);
+                devTty.removeAllListeners('error');
+                // Prevent future unhandled 'error' events from crashing the process
+                devTty.on('error', () => { });
+                resolve({ stream: devTty, closeAfter: true });
+            });
+            // If it errors immediately (or quickly), we fallback.
+            devTty.once('error', () => {
+                clearTimeout(timeout);
+                devTty.removeAllListeners('open');
+                resolve(getStdioTty());
+            });
+            return;
+        }
+        catch {
+            // fall through - synchronous failure
+        }
+    }
+    resolve(getStdioTty());
+});
+const getStdioTty = () => {
+    // On Windows, prioritize stdout to prevent shell-specific formatting (e.g., PowerShell's
+    // red stderr) from corrupting the raw escape sequence payload.
+    if (process.platform === 'win32') {
+        if (process.stdout?.isTTY)
+            return { stream: process.stdout, closeAfter: false };
+        if (process.stderr?.isTTY)
+            return { stream: process.stderr, closeAfter: false };
+        return null;
+    }
+    // On non-Windows platforms, prioritize stderr to avoid polluting stdout,
+    // preserving it for potential redirection or piping.
+    if (process.stderr?.isTTY)
+        return { stream: process.stderr, closeAfter: false };
+    if (process.stdout?.isTTY)
+        return { stream: process.stdout, closeAfter: false };
+    return null;
+};
+const inTmux = () => Boolean(process.env['TMUX'] || (process.env['TERM'] ?? '').startsWith('tmux'));
+const inScreen = () => Boolean(process.env['STY'] || (process.env['TERM'] ?? '').startsWith('screen'));
+const isSSH = () => Boolean(process.env['SSH_TTY'] ||
+    process.env['SSH_CONNECTION'] ||
+    process.env['SSH_CLIENT']);
+const isWSL = () => Boolean(process.env['WSL_DISTRO_NAME'] ||
+    process.env['WSLENV'] ||
+    process.env['WSL_INTEROP']);
+const isWindowsTerminal = () => process.platform === 'win32' && Boolean(process.env['WT_SESSION']);
+const isDumbTerm = () => (process.env['TERM'] ?? '') === 'dumb';
+const shouldUseOsc52 = (tty, settings) => Boolean(tty) &&
+    !isDumbTerm() &&
+    (settings?.experimental?.useOSC52Copy ||
+        isSSH() ||
+        isWSL() ||
+        isWindowsTerminal());
+const safeUtf8Truncate = (buf, maxBytes) => {
+    if (buf.length <= maxBytes)
+        return buf;
+    let end = maxBytes;
+    // Back up to the start of a UTF-8 code point if we cut through a continuation byte (10xxxxxx).
+    while (end > 0 && (buf[end - 1] & 0b1100_0000) === 0b1000_0000)
+        end--;
+    return buf.subarray(0, end);
+};
+const buildOsc52 = (text) => {
+    const raw = Buffer.from(text, 'utf8');
+    const safe = safeUtf8Truncate(raw, MAX_OSC52_DATA_BYTES);
+    const b64 = safe.toString('base64');
+    return `${OSC52_HEADER}${b64}${OSC52_FOOTER}`;
+};
+const wrapForTmux = (seq) => {
+    // Double ESC bytes in payload without a control-character regex.
+    const doubledEsc = seq.split(ESC).join(ESC + ESC);
+    return `${ESC}Ptmux;${doubledEsc}${ST}`;
+};
+const wrapForScreen = (seq) => {
+    let out = '';
+    for (let i = 0; i < seq.length; i += SCREEN_DCS_CHUNK_SIZE) {
+        out += `${ESC}P${seq.slice(i, i + SCREEN_DCS_CHUNK_SIZE)}${ST}`;
+    }
+    return out;
+};
+const writeAll = (stream, data) => new Promise((resolve, reject) => {
+    // On Windows, writing directly to the underlying file descriptor bypasses
+    // application-level stream interception (e.g., by the Ink UI framework).
+    // This ensures the raw OSC-52 escape sequence reaches the terminal host uncorrupted.
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const fd = stream.fd;
+    if (process.platform === 'win32' &&
+        typeof fd === 'number' &&
+        (stream === process.stdout || stream === process.stderr)) {
+        try {
+            fs.writeSync(fd, data);
+            resolve();
+            return;
+        }
+        catch (e) {
+            debugLogger.warn('Direct write to TTY failed, falling back to stream write', e);
+        }
+    }
+    const onError = (err) => {
+        cleanup();
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        reject(err);
+    };
+    const onDrain = () => {
+        cleanup();
+        resolve();
+    };
+    const cleanup = () => {
+        stream.off('error', onError);
+        stream.off('drain', onDrain);
+        // Writable.write() handlers may not emit 'drain' if the first write succeeded.
+    };
+    stream.once('error', onError);
+    if (stream.write(data)) {
+        cleanup();
+        resolve();
+    }
+    else {
+        stream.once('drain', onDrain);
+    }
+});
+// Copies a string snippet to the clipboard with robust OSC-52 support.
+export const copyToClipboard = async (text, settings) => {
+    if (!text)
+        return;
+    const tty = await pickTty();
+    if (shouldUseOsc52(tty, settings)) {
+        const osc = buildOsc52(text);
+        const payload = inTmux()
+            ? wrapForTmux(osc)
+            : inScreen()
+                ? wrapForScreen(osc)
+                : osc;
+        await writeAll(tty.stream, payload);
+        if (tty.closeAfter) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            tty.stream.end();
+        }
+        return;
+    }
+    // Local / non-TTY fallback
+    await clipboardy.write(text);
+};
+export const getUrlOpenCommand = () => {
+    // --- Determine the OS-specific command to open URLs ---
+    let openCmd;
+    switch (process.platform) {
+        case 'darwin':
+            openCmd = 'open';
+            break;
+        case 'win32':
+            openCmd = 'start';
+            break;
+        case 'linux':
+            openCmd = 'xdg-open';
+            break;
+        default:
+            // Default to xdg-open, which appears to be supported for the less popular operating systems.
+            openCmd = 'xdg-open';
+            debugLogger.warn(`Unknown platform: ${process.platform}. Attempting to open URLs with: ${openCmd}.`);
+            break;
+    }
+    return openCmd;
+};
+/**
+ * Determines if a slash command should auto-execute when selected.
+ *
+ * All built-in commands have autoExecute explicitly set to true or false.
+ * Custom commands (.toml files) and extension commands without this flag
+ * will default to false (safe default - won't auto-execute).
+ *
+ * @param command The slash command to check
+ * @returns true if the command should auto-execute on Enter
+ */
+export function isAutoExecutableCommand(command) {
+    if (!command) {
+        return false;
+    }
+    // Simply return the autoExecute flag value, defaulting to false if undefined
+    return command.autoExecute ?? false;
+}

package/dist/ui/utils/computeStats.js

@@ -0,0 +1,61 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export function calculateErrorRate(metrics) {
+    if (metrics.api.totalRequests === 0) {
+        return 0;
+    }
+    return (metrics.api.totalErrors / metrics.api.totalRequests) * 100;
+}
+export function calculateAverageLatency(metrics) {
+    if (metrics.api.totalRequests === 0) {
+        return 0;
+    }
+    return metrics.api.totalLatencyMs / metrics.api.totalRequests;
+}
+export function calculateCacheHitRate(metrics) {
+    if (metrics.tokens.prompt === 0) {
+        return 0;
+    }
+    return (metrics.tokens.cached / metrics.tokens.prompt) * 100;
+}
+export const computeSessionStats = (metrics) => {
+    const { models, tools, files } = metrics;
+    const totalApiTime = Object.values(models).reduce((acc, model) => acc + model.api.totalLatencyMs, 0);
+    const totalToolTime = tools.totalDurationMs;
+    const agentActiveTime = totalApiTime + totalToolTime;
+    const apiTimePercent = agentActiveTime > 0 ? (totalApiTime / agentActiveTime) * 100 : 0;
+    const toolTimePercent = agentActiveTime > 0 ? (totalToolTime / agentActiveTime) * 100 : 0;
+    const totalCachedTokens = Object.values(models).reduce((acc, model) => acc + model.tokens.cached, 0);
+    const totalInputTokens = Object.values(models).reduce((acc, model) => acc + model.tokens.input, 0);
+    const totalPromptTokens = Object.values(models).reduce((acc, model) => acc + model.tokens.prompt, 0);
+    const cacheEfficiency = totalPromptTokens > 0 ? (totalCachedTokens / totalPromptTokens) * 100 : 0;
+    const totalDecisions = tools.totalDecisions.accept +
+        tools.totalDecisions.reject +
+        tools.totalDecisions.modify +
+        tools.totalDecisions.auto_accept;
+    const successRate = tools.totalCalls > 0 ? (tools.totalSuccess / tools.totalCalls) * 100 : 0;
+    const agreementRate = totalDecisions > 0
+        ? ((tools.totalDecisions.accept + tools.totalDecisions.auto_accept) /
+            totalDecisions) *
+            100
+        : 0;
+    return {
+        totalApiTime,
+        totalToolTime,
+        agentActiveTime,
+        apiTimePercent,
+        toolTimePercent,
+        cacheEfficiency,
+        totalDecisions,
+        successRate,
+        agreementRate,
+        totalCachedTokens,
+        totalInputTokens,
+        totalPromptTokens,
+        totalLinesAdded: files.totalLinesAdded,
+        totalLinesRemoved: files.totalLinesRemoved,
+    };
+};

package/dist/ui/utils/confirmingTool.js

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CoreToolCallStatus, belongsInConfirmationQueue, } from '@google/gemini-cli-core';
+import { getAllToolCalls, buildToolVisibilityContextFromDisplay, } from './historyUtils.js';
+/**
+ * Selects the "head" of the confirmation queue.
+ */
+export function getConfirmingToolState(pendingHistoryItems) {
+    const allPendingTools = getAllToolCalls(pendingHistoryItems);
+    const confirmingTools = allPendingTools.filter((tool) => tool.status === CoreToolCallStatus.AwaitingApproval);
+    if (confirmingTools.length === 0) {
+        return null;
+    }
+    const actionablePendingTools = allPendingTools.filter((tool) => belongsInConfirmationQueue(buildToolVisibilityContextFromDisplay(tool)));
+    const head = confirmingTools[0];
+    const headIndexInFullList = actionablePendingTools.findIndex((tool) => tool.callId === head.callId);
+    return {
+        tool: head,
+        index: headIndexInFullList + 1,
+        total: actionablePendingTools.length,
+    };
+}

package/dist/ui/utils/contextUsage.js

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { tokenLimit } from '@google/gemini-cli-core';
+export function getContextUsagePercentage(promptTokenCount, model) {
+    if (!model || typeof model !== 'string' || model.length === 0) {
+        return 0;
+    }
+    const limit = tokenLimit(model);
+    if (limit <= 0) {
+        return 0;
+    }
+    return promptTokenCount / limit;
+}
+export function isContextUsageHigh(promptTokenCount, model, threshold = 0.6) {
+    return getContextUsagePercentage(promptTokenCount, model) > threshold;
+}

package/dist/ui/utils/directoryUtils.js

@@ -0,0 +1,124 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { opendir } from 'node:fs/promises';
+import { homedir } from '@google/gemini-cli-core';
+const MAX_SUGGESTIONS = 50;
+const MATCH_BUFFER_MULTIPLIER = 3;
+export function expandHomeDir(p) {
+    if (!p) {
+        return '';
+    }
+    let expandedPath = p;
+    if (p.toLowerCase().startsWith('%userprofile%')) {
+        expandedPath = homedir() + p.substring('%userprofile%'.length);
+    }
+    else if (p === '~' || p.startsWith('~/')) {
+        expandedPath = homedir() + p.substring(1);
+    }
+    return path.normalize(expandedPath);
+}
+function parsePartialPath(partialPath) {
+    const isHomeExpansion = partialPath.startsWith('~');
+    const expandedPath = expandHomeDir(partialPath || '.');
+    let searchDir;
+    let filter;
+    if (partialPath === '' ||
+        partialPath.endsWith('/') ||
+        partialPath.endsWith(path.sep)) {
+        searchDir = expandedPath;
+        filter = '';
+    }
+    else {
+        searchDir = path.dirname(expandedPath);
+        filter = path.basename(expandedPath);
+        // Special case for ~ because path.dirname('~') can be '.'
+        if (isHomeExpansion &&
+            !partialPath.includes('/') &&
+            !partialPath.includes(path.sep)) {
+            searchDir = homedir();
+            filter = partialPath.substring(1);
+        }
+    }
+    // Calculate result prefix
+    let resultPrefix = '';
+    if (partialPath === '' ||
+        partialPath.endsWith('/') ||
+        partialPath.endsWith(path.sep)) {
+        resultPrefix = partialPath;
+    }
+    else {
+        const lastSlashIndex = Math.max(partialPath.lastIndexOf('/'), partialPath.lastIndexOf(path.sep));
+        if (lastSlashIndex !== -1) {
+            resultPrefix = partialPath.substring(0, lastSlashIndex + 1);
+        }
+        else if (isHomeExpansion) {
+            resultPrefix = `~${path.sep}`;
+        }
+    }
+    return { searchDir, filter, isHomeExpansion, resultPrefix };
+}
+/**
+ * Gets directory suggestions based on a partial path.
+ * Uses async iteration with fs.opendir for efficient handling of large directories.
+ *
+ * @param partialPath The partial path typed by the user.
+ * @returns A promise resolving to an array of directory path suggestions.
+ */
+export async function getDirectorySuggestions(partialPath) {
+    try {
+        const { searchDir, filter, resultPrefix } = parsePartialPath(partialPath);
+        if (!fs.existsSync(searchDir) || !fs.statSync(searchDir).isDirectory()) {
+            return [];
+        }
+        const matches = [];
+        const filterLower = filter.toLowerCase();
+        const showHidden = filter.startsWith('.');
+        const dir = await opendir(searchDir);
+        try {
+            for await (const entry of dir) {
+                if (!entry.isDirectory()) {
+                    continue;
+                }
+                if (entry.name.startsWith('.') && !showHidden) {
+                    continue;
+                }
+                if (entry.name.toLowerCase().startsWith(filterLower)) {
+                    matches.push(entry.name);
+                    // Early termination with buffer for sorting
+                    if (matches.length >= MAX_SUGGESTIONS * MATCH_BUFFER_MULTIPLIER) {
+                        break;
+                    }
+                }
+            }
+        }
+        finally {
+            await dir.close().catch(() => { });
+        }
+        // Use the separator style from user's input for consistency
+        const userSep = resultPrefix.includes('/') ? '/' : path.sep;
+        return matches
+            .sort()
+            .slice(0, MAX_SUGGESTIONS)
+            .map((name) => resultPrefix + name + userSep);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Helper to batch add directories to the workspace context.
+ * Handles expansion and error formatting.
+ */
+export function batchAddDirectories(workspaceContext, paths) {
+    const result = workspaceContext.addDirectories(paths.map((p) => expandHomeDir(p.trim())));
+    const errors = [];
+    for (const failure of result.failed) {
+        errors.push(`Error adding '${failure.path}': ${failure.error.message}`);
+    }
+    return { added: result.added, errors };
+}

package/dist/ui/utils/displayUtils.js

@@ -0,0 +1,42 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { theme } from '../semantic-colors.js';
+// --- Thresholds ---
+export const TOOL_SUCCESS_RATE_HIGH = 95;
+export const TOOL_SUCCESS_RATE_MEDIUM = 85;
+export const USER_AGREEMENT_RATE_HIGH = 75;
+export const USER_AGREEMENT_RATE_MEDIUM = 45;
+export const CACHE_EFFICIENCY_HIGH = 40;
+export const CACHE_EFFICIENCY_MEDIUM = 15;
+export const QUOTA_THRESHOLD_HIGH = 20;
+export const QUOTA_THRESHOLD_MEDIUM = 5;
+export const QUOTA_USED_WARNING_THRESHOLD = 80;
+export const QUOTA_USED_CRITICAL_THRESHOLD = 95;
+// --- Color Logic ---
+export const getStatusColor = (value, thresholds, options = {}) => {
+    if (value >= thresholds.green) {
+        return theme.status.success;
+    }
+    if (value >= thresholds.yellow) {
+        return theme.status.warning;
+    }
+    if (thresholds.red != null && value >= thresholds.red) {
+        return theme.status.error;
+    }
+    return options.defaultColor ?? theme.status.error;
+};
+/**
+ * Gets the status color based on "used" percentage (where higher is worse).
+ */
+export const getUsedStatusColor = (usedPercentage, thresholds) => {
+    if (usedPercentage >= thresholds.critical) {
+        return theme.status.error;
+    }
+    if (usedPercentage >= thresholds.warning) {
+        return theme.status.warning;
+    }
+    return undefined;
+};

package/dist/ui/utils/editorUtils.js

@@ -0,0 +1,150 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { spawn, spawnSync } from 'node:child_process';
+import { ALL_EDITORS, CoreEvent, coreEvents, getEditorCommand, getEditorExtraArgs, getEditorWaitFlag, isGuiEditor, isTerminalEditor, isValidEditorType, resolveEditorTypeFromCommand, } from '@google/gemini-cli-core';
+/**
+ * Command name substrings used to guess whether an unknown $VISUAL/$EDITOR
+ * value is a GUI editor. This is a fallback for editors not in the registry;
+ * registered editors are detected via resolveEditorTypeFromCommand instead.
+ */
+const HEURISTIC_GUI_COMMANDS = [
+    'code',
+    'cursor',
+    'subl',
+    'zed',
+    'atom',
+    'agy',
+];
+/**
+ * Opens a file in an external editor and waits for it to close.
+ * Handles raw mode switching to ensure the editor can interact with the terminal.
+ *
+ * @param filePath Path to the file to open
+ * @param stdin The stdin stream from Ink/Node
+ * @param setRawMode Function to toggle raw mode
+ * @param preferredEditorType The user's preferred editor from config
+ * @param openInNewWindow Whether to open VS Code-family editors in a new window
+ */
+export async function openFileInEditor(filePath, stdin, setRawMode, preferredEditorType, openInNewWindow) {
+    let command = undefined;
+    const args = [filePath];
+    // Extra args that come before the file path (e.g. -nw for emacsclient)
+    const extraArgs = [];
+    if (preferredEditorType) {
+        if (!isValidEditorType(preferredEditorType)) {
+            coreEvents.emitFeedback('error', `Editor '${preferredEditorType}' is not a recognized editor identifier. ` +
+                `Supported editors: ${ALL_EDITORS.join(', ')}. ` +
+                `Use /editor to select one, or set the $VISUAL or $EDITOR environment variable.`);
+            return;
+        }
+        command = getEditorCommand(preferredEditorType);
+        if (isGuiEditor(preferredEditorType)) {
+            args.unshift(getEditorWaitFlag(preferredEditorType));
+        }
+        extraArgs.push(...getEditorExtraArgs(preferredEditorType, {
+            newWindow: openInNewWindow,
+        }));
+    }
+    if (!command) {
+        const envCommand = process.env['VISUAL'] ?? process.env['EDITOR'];
+        if (envCommand) {
+            command = envCommand;
+            const [envExecutable = ''] = envCommand.split(' ');
+            const resolvedType = resolveEditorTypeFromCommand(envExecutable);
+            if (resolvedType) {
+                if (isGuiEditor(resolvedType) &&
+                    !envCommand.includes('--wait') &&
+                    !envCommand.includes('-w')) {
+                    args.unshift(getEditorWaitFlag(resolvedType));
+                }
+                extraArgs.push(...getEditorExtraArgs(resolvedType, { newWindow: openInNewWindow }));
+            }
+            else {
+                // Heuristic fallback for commands not in the registry
+                const lower = envCommand.toLowerCase();
+                const isGui = HEURISTIC_GUI_COMMANDS.some((g) => lower.includes(g));
+                if (isGui && !lower.includes('--wait') && !lower.includes('-w')) {
+                    args.unshift(lower.includes('subl') ? '-w' : '--wait');
+                }
+            }
+        }
+    }
+    if (!command) {
+        command = process.platform === 'win32' ? 'notepad' : 'vi';
+    }
+    const [executable = '', ...initialArgs] = command.split(' ');
+    // Determine if we should use sync or async based on the command/editor type.
+    // If we have a preferredEditorType, we can check if it's a terminal editor.
+    // Otherwise, we guess based on the command name.
+    const terminalEditors = [
+        'vi',
+        'vim',
+        'nvim',
+        'emacs',
+        'emacsclient',
+        'hx',
+        'nano',
+        'micro',
+    ];
+    const isTerminal = preferredEditorType
+        ? isTerminalEditor(preferredEditorType)
+        : terminalEditors.some((te) => executable.toLowerCase().includes(te));
+    if (isTerminal &&
+        (executable.includes('vi') ||
+            executable.includes('vim') ||
+            executable.includes('nvim'))) {
+        // Pass -i NONE to prevent E138 'Can't write viminfo file' errors in restricted environments.
+        args.unshift('-i', 'NONE');
+    }
+    const wasRaw = stdin?.isRaw ?? false;
+    setRawMode?.(false);
+    try {
+        if (isTerminal) {
+            const result = spawnSync(executable, [...initialArgs, ...extraArgs, ...args], {
+                stdio: 'inherit',
+                shell: process.platform === 'win32',
+            });
+            if (result.error) {
+                const spawnErr = result.error;
+                coreEvents.emitFeedback('error', spawnErr.code === 'ENOENT'
+                    ? `Editor command '${executable}' was not found in PATH. Install it or use /editor to choose another editor.`
+                    : (spawnErr.message ?? String(spawnErr)));
+                return;
+            }
+            if (typeof result.status === 'number' && result.status !== 0) {
+                coreEvents.emitFeedback('error', `External editor exited with status ${result.status}`);
+                return;
+            }
+        }
+        else {
+            await new Promise((resolve) => {
+                const child = spawn(executable, [...initialArgs, ...extraArgs, ...args], {
+                    stdio: 'inherit',
+                    shell: process.platform === 'win32',
+                });
+                child.on('error', (err) => {
+                    const spawnErr = err;
+                    resolve();
+                    coreEvents.emitFeedback('error', spawnErr.code === 'ENOENT'
+                        ? `Editor command '${executable}' was not found in PATH. Install it or use /editor to choose another editor.`
+                        : (spawnErr.message ?? String(spawnErr)));
+                });
+                child.on('close', (status) => {
+                    resolve();
+                    if (typeof status === 'number' && status !== 0) {
+                        coreEvents.emitFeedback('error', `External editor exited with status ${status}`);
+                    }
+                });
+            });
+        }
+    }
+    finally {
+        if (wasRaw) {
+            setRawMode?.(true);
+        }
+        coreEvents.emit(CoreEvent.ExternalEditorClosed);
+    }
+}