@quantum-ai/gemini-cli 0.45.8 → 0.45.9

package/dist/utils/logCleanup.js

@@ -0,0 +1,57 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import { ShellExecutionService, debugLogger } from '@google/gemini-cli-core';
+const RETENTION_PERIOD_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
+/**
+ * Cleans up background process log files older than 7 days.
+ * Scans ~/.gemini/tmp/background-processes/ for .log files.
+ *
+ * @param debugMode Whether to log detailed debug information.
+ */
+export async function cleanupBackgroundLogs(debugMode = false) {
+    try {
+        const logDir = ShellExecutionService.getLogDir();
+        // Check if the directory exists
+        try {
+            await fs.access(logDir);
+        }
+        catch {
+            // Directory doesn't exist, nothing to clean up
+            return;
+        }
+        const entries = await fs.readdir(logDir, { withFileTypes: true });
+        const now = Date.now();
+        let deletedCount = 0;
+        for (const entry of entries) {
+            if (entry.isFile() && entry.name.endsWith('.log')) {
+                const filePath = path.join(logDir, entry.name);
+                try {
+                    const stats = await fs.stat(filePath);
+                    if (now - stats.mtime.getTime() > RETENTION_PERIOD_MS) {
+                        await fs.unlink(filePath);
+                        deletedCount++;
+                    }
+                }
+                catch (error) {
+                    if (debugMode) {
+                        debugLogger.debug(`Failed to process log file ${entry.name}:`, error);
+                    }
+                }
+            }
+        }
+        if (deletedCount > 0 && debugMode) {
+            debugLogger.debug(`Cleaned up ${deletedCount} expired background logs.`);
+        }
+    }
+    catch (error) {
+        // Best-effort cleanup, don't let it crash the CLI
+        if (debugMode) {
+            debugLogger.warn('Background log cleanup failed:', error);
+        }
+    }
+}

package/dist/utils/math.js

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Linearly interpolates between two values.
+ *
+ * @param start The start value.
+ * @param end The end value.
+ * @param t The interpolation amount (typically between 0 and 1).
+ */
+export const lerp = (start, end, t) => start + (end - start) * t;

package/dist/utils/persistentState.js

@@ -0,0 +1,65 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Storage, debugLogger } from '@google/gemini-cli-core';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+const STATE_FILENAME = 'state.json';
+export class PersistentState {
+    cache = null;
+    filePath = null;
+    getPath() {
+        if (!this.filePath) {
+            this.filePath = path.join(Storage.getGlobalGeminiDir(), STATE_FILENAME);
+        }
+        return this.filePath;
+    }
+    load() {
+        if (this.cache) {
+            return this.cache;
+        }
+        try {
+            const filePath = this.getPath();
+            if (fs.existsSync(filePath)) {
+                const content = fs.readFileSync(filePath, 'utf-8');
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                this.cache = JSON.parse(content);
+            }
+            else {
+                this.cache = {};
+            }
+        }
+        catch (error) {
+            debugLogger.warn('Failed to load persistent state:', error);
+            // If error reading (e.g. corrupt JSON), start fresh
+            this.cache = {};
+        }
+        return this.cache;
+    }
+    save() {
+        if (!this.cache)
+            return;
+        try {
+            const filePath = this.getPath();
+            const dir = path.dirname(filePath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(filePath, JSON.stringify(this.cache, null, 2));
+        }
+        catch (error) {
+            debugLogger.warn('Failed to save persistent state:', error);
+        }
+    }
+    get(key) {
+        return this.load()[key];
+    }
+    set(key, value) {
+        this.load(); // ensure loaded
+        this.cache[key] = value;
+        this.save();
+    }
+}
+export const persistentState = new PersistentState();

package/dist/utils/processUtils.js

@@ -0,0 +1,98 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { runExitCleanup } from './cleanup.js';
+import { waitForUpdateCompletion } from './handleAutoUpdate.js';
+/**
+ * Exit code used to signal that the CLI should be relaunched.
+ */
+export const RELAUNCH_EXIT_CODE = 199;
+/**
+ * Exits the process with a special code to signal that the parent process should relaunch it.
+ */
+let isRelaunching = false;
+/** @internal only for testing */
+export function _resetRelaunchStateForTesting() {
+    isRelaunching = false;
+}
+export async function relaunchApp() {
+    if (isRelaunching)
+        return;
+    isRelaunching = true;
+    await waitForUpdateCompletion();
+    await runExitCleanup();
+    process.exit(RELAUNCH_EXIT_CODE);
+}
+/**
+ * Determines whether the current process is a "standard" SEA (Single Executable Application)
+ * where the user arguments start at index 1 instead of index 2.
+ * A relaunched SEA child will have process.argv[0] === process.argv[1] (because we inject execPath),
+ * so it will return false here and correctly slice from index 2.
+ */
+export function isStandardSea() {
+    return (process.argv[0] !== process.argv[1] &&
+        (process.env['IS_BINARY'] === 'true' ||
+            process.isSea?.() === true));
+}
+/**
+ * Extracts the user-provided script arguments from process.argv,
+ * accounting for the differences in SEA execution modes.
+ */
+export function getScriptArgs() {
+    return process.argv.slice(isStandardSea() ? 1 : 2);
+}
+/**
+ * Determines if the current process is running in any SEA environment
+ * (either the initial launch or a relaunched child).
+ */
+export function isSeaEnvironment() {
+    return (process.env['IS_BINARY'] === 'true' ||
+        process.isSea?.() === true ||
+        process.argv[0] === process.argv[1]);
+}
+/**
+ * Constructs the arguments and environment for spawning a child process during relaunch.
+ * Handles differences between standard Node and SEA binary modes.
+ */
+export function getSpawnConfig(nodeArgs, scriptArgs) {
+    const isBinary = isSeaEnvironment();
+    const newEnv = {
+        ...process.env,
+        GEMINI_CLI_NO_RELAUNCH: 'true',
+    };
+    const finalSpawnArgs = [];
+    if (isBinary) {
+        // In SEA mode, Node flags must be passed via NODE_OPTIONS, as the binary
+        // passes all CLI arguments directly to the application.
+        // We only need to append the *new* nodeArgs (e.g., memory flags).
+        // Existing execArgv are inherited via the environment or baked into the binary.
+        if (nodeArgs.length > 0) {
+            for (const arg of nodeArgs) {
+                if (/[\s"'\\]/.test(arg)) {
+                    throw new Error(`Unsupported node argument for SEA relaunch: ${arg}. Complex escaping is not supported.`);
+                }
+            }
+            const existingNodeOptions = process.env['NODE_OPTIONS'] || '';
+            // nodeArgs in our codebase are simple flags like --max-old-space-size=X
+            // that do not contain spaces and do not require complex escaping.
+            newEnv['NODE_OPTIONS'] =
+                `${existingNodeOptions} ${nodeArgs.join(' ')}`.trim();
+        }
+        // Binary is its own entry point. To maintain the [node, script, ...args]
+        // structure expected by the application (which uses slice(2)),
+        // we must provide a placeholder for the script path.
+        // We explicitly use process.execPath to break the cycle and prevent
+        // compounding argument duplication on subsequent relaunches.
+        finalSpawnArgs.push(process.execPath, ...scriptArgs);
+    }
+    else {
+        // Standard Node mode: pass all flags via command line.
+        finalSpawnArgs.push(...process.execArgv, ...nodeArgs, process.argv[1], ...scriptArgs);
+    }
+    return {
+        spawnArgs: finalSpawnArgs,
+        env: newEnv,
+    };
+}

package/dist/utils/readStdin.js

@@ -0,0 +1,86 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { debugLogger } from '@google/gemini-cli-core';
+/**
+ * Truncates a string to fit within a UTF-8 byte limit without splitting
+ * multi-byte characters. Walks back from the cut point to find the last
+ * complete character boundary.
+ */
+function truncateUtf8Bytes(str, maxBytes) {
+    const buf = Buffer.from(str, 'utf8');
+    if (buf.length <= maxBytes)
+        return str;
+    let end = maxBytes;
+    // Walk backward past any UTF-8 continuation bytes (10xxxxxx)
+    while (end > 0 && (buf[end] & 0xc0) === 0x80) {
+        end--;
+    }
+    // end now points to the lead byte of an incomplete sequence — exclude it
+    return buf.subarray(0, end).toString('utf8');
+}
+export async function readStdin() {
+    const MAX_STDIN_SIZE = 8 * 1024 * 1024; // 8MB
+    return new Promise((resolve, reject) => {
+        let data = '';
+        let totalSize = 0;
+        process.stdin.setEncoding('utf8');
+        const pipedInputShouldBeAvailableInMs = 500;
+        let pipedInputTimerId = setTimeout(() => {
+            // stop reading if input is not available yet, this is needed
+            // in terminals where stdin is never TTY and nothing's piped
+            // which causes the program to get stuck expecting data from stdin
+            onEnd();
+        }, pipedInputShouldBeAvailableInMs);
+        const onReadable = () => {
+            let chunk;
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            while ((chunk = process.stdin.read()) !== null) {
+                if (pipedInputTimerId) {
+                    clearTimeout(pipedInputTimerId);
+                    pipedInputTimerId = null;
+                }
+                const chunkByteLength = Buffer.byteLength(chunk, 'utf8');
+                if (totalSize + chunkByteLength > MAX_STDIN_SIZE) {
+                    const remainingBytes = MAX_STDIN_SIZE - totalSize;
+                    data += truncateUtf8Bytes(chunk, remainingBytes);
+                    debugLogger.warn(`Warning: stdin input truncated to ${MAX_STDIN_SIZE} bytes.`);
+                    process.stdin.destroy(); // Stop reading further
+                    onEnd();
+                    break;
+                }
+                data += chunk;
+                totalSize += chunkByteLength;
+            }
+        };
+        const onEnd = () => {
+            cleanup();
+            resolve(data);
+        };
+        const onError = (err) => {
+            cleanup();
+            reject(err);
+        };
+        const cleanup = () => {
+            if (pipedInputTimerId) {
+                clearTimeout(pipedInputTimerId);
+                pipedInputTimerId = null;
+            }
+            process.stdin.removeListener('readable', onReadable);
+            process.stdin.removeListener('end', onEnd);
+            process.stdin.removeListener('error', onError);
+            // Add a no-op error listener if no other error listeners are present to prevent
+            // unhandled 'error' events (like EIO) from crashing the process after we stop reading.
+            // This is especially important for background execution where TTY might cause EIO.
+            if (process.stdin.listenerCount('error') === 0) {
+                process.stdin.on('error', noopErrorHandler);
+            }
+        };
+        process.stdin.on('readable', onReadable);
+        process.stdin.on('end', onEnd);
+        process.stdin.on('error', onError);
+    });
+}
+function noopErrorHandler() { }

package/dist/utils/relaunch.js

@@ -0,0 +1,60 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { spawn } from 'node:child_process';
+import { RELAUNCH_EXIT_CODE, getSpawnConfig, getScriptArgs, } from './processUtils.js';
+import { writeToStderr, } from '@google/gemini-cli-core';
+export async function relaunchOnExitCode(runner) {
+    while (true) {
+        try {
+            const exitCode = await runner();
+            if (process.platform === 'android' || exitCode !== RELAUNCH_EXIT_CODE) {
+                process.exit(exitCode);
+            }
+        }
+        catch (error) {
+            process.stdin.resume();
+            const errorMessage = error instanceof Error ? (error.stack ?? error.message) : String(error);
+            writeToStderr(`Fatal error: Failed to relaunch the CLI process.\n${errorMessage}\n`);
+            process.exit(1);
+        }
+    }
+}
+export async function relaunchAppInChildProcess(additionalNodeArgs, additionalScriptArgs, remoteAdminSettings) {
+    if (process.env['GEMINI_CLI_NO_RELAUNCH']) {
+        return;
+    }
+    let latestAdminSettings = remoteAdminSettings;
+    const runner = () => {
+        const scriptArgs = getScriptArgs();
+        const { spawnArgs, env: newEnv } = getSpawnConfig(additionalNodeArgs, [
+            ...additionalScriptArgs,
+            ...scriptArgs,
+        ]);
+        // The parent process should not be reading from stdin while the child is running.
+        process.stdin.pause();
+        const child = spawn(process.execPath, spawnArgs, {
+            stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+            env: newEnv,
+        });
+        if (latestAdminSettings) {
+            child.send({ type: 'admin-settings', settings: latestAdminSettings });
+        }
+        child.on('message', (msg) => {
+            if (msg.type === 'admin-settings-update' && msg.settings) {
+                latestAdminSettings = msg.settings;
+            }
+        });
+        return new Promise((resolve, reject) => {
+            child.on('error', reject);
+            child.on('close', (code) => {
+                // Resume stdin before the parent process exits.
+                process.stdin.resume();
+                resolve(code ?? 1);
+            });
+        });
+    };
+    await relaunchOnExitCode(runner);
+}

package/dist/utils/resize-observer-polyfill.js

@@ -0,0 +1,6 @@
+import ResizeObserver from 'resize-observer-polyfill';
+// これは Node.js 環境で ResizeObserver をグローバルに定義するためのポリフィル
+if (typeof window === 'undefined') {
+    global.ResizeObserver = ResizeObserver;
+}
+export default ResizeObserver;

package/dist/utils/resolvePath.js

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as path from 'node:path';
+import { homedir } from '@google/gemini-cli-core';
+export function resolvePath(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);
+}