@quantum-ai/gemini-cli 0.45.8 → 0.45.10

package/dist/commands/extensions/uninstall.js

@@ -0,0 +1,88 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { debugLogger, getErrorMessage } from '@google/gemini-cli-core';
+import { requestConsentNonInteractive } from '../../config/extensions/consent.js';
+import { ExtensionManager } from '../../config/extension-manager.js';
+import { loadSettings } from '../../config/settings.js';
+import { promptForSetting } from '../../config/extensions/extensionSettings.js';
+import { exitCli } from '../utils.js';
+export async function handleUninstall(args) {
+    try {
+        const workspaceDir = process.cwd();
+        const extensionManager = new ExtensionManager({
+            workspaceDir,
+            requestConsent: requestConsentNonInteractive,
+            requestSetting: promptForSetting,
+            settings: loadSettings(workspaceDir).merged,
+        });
+        await extensionManager.loadExtensions();
+        let namesToUninstall = [];
+        if (args.all) {
+            namesToUninstall = extensionManager
+                .getExtensions()
+                .map((ext) => ext.name);
+        }
+        else if (args.names) {
+            namesToUninstall = [...new Set(args.names)];
+        }
+        if (namesToUninstall.length === 0) {
+            if (args.all) {
+                debugLogger.log('No extensions currently installed.');
+            }
+            return;
+        }
+        const errors = [];
+        for (const name of namesToUninstall) {
+            try {
+                await extensionManager.uninstallExtension(name, false);
+                debugLogger.log(`Extension "${name}" successfully uninstalled.`);
+            }
+            catch (error) {
+                errors.push({ name, error: getErrorMessage(error) });
+            }
+        }
+        if (errors.length > 0) {
+            for (const { name, error } of errors) {
+                debugLogger.error(`Failed to uninstall "${name}": ${error}`);
+            }
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        debugLogger.error(getErrorMessage(error));
+        process.exit(1);
+    }
+}
+export const uninstallCommand = {
+    command: 'uninstall [names..]',
+    describe: 'Uninstalls one or more extensions.',
+    builder: (yargs) => yargs
+        .positional('names', {
+        describe: 'The name(s) or source path(s) of the extension(s) to uninstall.',
+        type: 'string',
+        array: true,
+    })
+        .option('all', {
+        type: 'boolean',
+        describe: 'Uninstall all installed extensions.',
+        default: false,
+    })
+        .check((argv) => {
+        if (!argv.all && (!argv.names || argv.names.length === 0)) {
+            throw new Error('Please include at least one extension name to uninstall as a positional argument, or use the --all flag.');
+        }
+        return true;
+    }),
+    handler: async (argv) => {
+        await handleUninstall({
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            names: argv['names'],
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            all: argv['all'],
+        });
+        await exitCli();
+    },
+};

package/dist/commands/extensions/update.js

@@ -0,0 +1,113 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { updateAllUpdatableExtensions, checkForAllExtensionUpdates, updateExtension, } from '../../config/extensions/update.js';
+import { checkForExtensionUpdate } from '../../config/extensions/github.js';
+import { ExtensionUpdateState } from '../../ui/state/extensions.js';
+import { coreEvents, debugLogger, getErrorMessage, } from '@google/gemini-cli-core';
+import { ExtensionManager } from '../../config/extension-manager.js';
+import { requestConsentNonInteractive } from '../../config/extensions/consent.js';
+import { loadSettings } from '../../config/settings.js';
+import { promptForSetting } from '../../config/extensions/extensionSettings.js';
+import { exitCli } from '../utils.js';
+const updateOutput = (info) => `Extension "${info.name}" successfully updated: ${info.originalVersion} → ${info.updatedVersion}.`;
+export async function handleUpdate(args) {
+    const workspaceDir = process.cwd();
+    const settings = loadSettings(workspaceDir).merged;
+    const extensionManager = new ExtensionManager({
+        workspaceDir,
+        requestConsent: requestConsentNonInteractive,
+        requestSetting: promptForSetting,
+        settings,
+    });
+    const extensions = await extensionManager.loadExtensions();
+    if (args.name) {
+        try {
+            const extension = extensions.find((extension) => extension.name === args.name);
+            if (!extension) {
+                if (extensions.length === 0) {
+                    coreEvents.emitFeedback('error', `Extension "${args.name}" not found.\n\nNo extensions installed.`);
+                    return;
+                }
+                const installedExtensions = extensions
+                    .map((extension) => `${extension.name} (${extension.version})`)
+                    .join('\n');
+                coreEvents.emitFeedback('error', `Extension "${args.name}" not found.\n\nInstalled extensions:\n${installedExtensions}\n\nRun "gemini extensions list" for details.`);
+                return;
+            }
+            if (!extension.installMetadata) {
+                debugLogger.log(`Unable to install extension "${args.name}" due to missing install metadata`);
+                return;
+            }
+            const updateState = await checkForExtensionUpdate(extension, extensionManager);
+            if (updateState !== ExtensionUpdateState.UPDATE_AVAILABLE) {
+                debugLogger.log(`Extension "${args.name}" is already up to date.`);
+                return;
+            }
+            const updatedExtensionInfo = (await updateExtension(extension, extensionManager, updateState, () => { }, settings.experimental?.extensionReloading));
+            if (updatedExtensionInfo.originalVersion !==
+                updatedExtensionInfo.updatedVersion) {
+                debugLogger.log(`Extension "${args.name}" successfully updated: ${updatedExtensionInfo.originalVersion} → ${updatedExtensionInfo.updatedVersion}.`);
+            }
+            else {
+                debugLogger.log(`Extension "${args.name}" is already up to date.`);
+            }
+        }
+        catch (error) {
+            debugLogger.error(getErrorMessage(error));
+        }
+    }
+    if (args.all) {
+        try {
+            const extensionState = new Map();
+            await checkForAllExtensionUpdates(extensions, extensionManager, (action) => {
+                if (action.type === 'SET_STATE') {
+                    extensionState.set(action.payload.name, {
+                        status: action.payload.state,
+                    });
+                }
+            });
+            let updateInfos = await updateAllUpdatableExtensions(extensions, extensionState, extensionManager, () => { });
+            updateInfos = updateInfos.filter((info) => info.originalVersion !== info.updatedVersion);
+            if (updateInfos.length === 0) {
+                debugLogger.log('No extensions to update.');
+                return;
+            }
+            debugLogger.log(updateInfos.map((info) => updateOutput(info)).join('\n'));
+        }
+        catch (error) {
+            debugLogger.error(getErrorMessage(error));
+        }
+    }
+}
+export const updateCommand = {
+    command: 'update [<name>] [--all]',
+    describe: 'Updates all extensions or a named extension to the latest version.',
+    builder: (yargs) => yargs
+        .positional('name', {
+        describe: 'The name of the extension to update.',
+        type: 'string',
+    })
+        .option('all', {
+        describe: 'Update all extensions.',
+        type: 'boolean',
+    })
+        .conflicts('name', 'all')
+        .check((argv) => {
+        if (!argv.all && !argv.name) {
+            throw new Error('Either an extension name or --all must be provided');
+        }
+        return true;
+    }),
+    handler: async (argv) => {
+        await handleUpdate({
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            name: argv['name'],
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            all: argv['all'],
+        });
+        await exitCli();
+    },
+};

package/dist/commands/extensions/utils.js

@@ -0,0 +1,122 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ExtensionManager } from '../../config/extension-manager.js';
+import { loadSettings } from '../../config/settings.js';
+import { requestConsentNonInteractive } from '../../config/extensions/consent.js';
+import { debugLogger, } from '@google/gemini-cli-core';
+import prompts from 'prompts';
+import { promptForSetting, updateSetting, getScopedEnvContents, ExtensionSettingScope, } from '../../config/extensions/extensionSettings.js';
+const defaultLogger = {
+    log: (message) => debugLogger.log(message),
+    error: (message) => debugLogger.error(message),
+};
+const defaultRequestSetting = async (setting) => promptForSetting(setting);
+const defaultRequestConfirmation = async (message) => {
+    const response = await prompts({
+        type: 'confirm',
+        name: 'confirm',
+        message,
+        initial: false,
+    });
+    return typeof response.confirm === 'boolean' ? response.confirm : false;
+};
+export async function getExtensionManager() {
+    const workspaceDir = process.cwd();
+    const extensionManager = new ExtensionManager({
+        workspaceDir,
+        requestConsent: requestConsentNonInteractive,
+        requestSetting: promptForSetting,
+        settings: loadSettings(workspaceDir).merged,
+    });
+    await extensionManager.loadExtensions();
+    return extensionManager;
+}
+export async function getExtensionAndManager(extensionManager, name, logger = defaultLogger) {
+    const extension = extensionManager
+        .getExtensions()
+        .find((ext) => ext.name === name);
+    if (!extension) {
+        logger.error(`Extension "${name}" is not installed.`);
+        return { extension: null };
+    }
+    return { extension };
+}
+export async function configureSpecificSetting(extensionManager, extensionName, settingKey, scope, logger = defaultLogger, requestSetting = defaultRequestSetting) {
+    const { extension } = await getExtensionAndManager(extensionManager, extensionName, logger);
+    if (!extension) {
+        return;
+    }
+    const extensionConfig = await extensionManager.loadExtensionConfig(extension.path);
+    if (!extensionConfig) {
+        logger.error(`Could not find configuration for extension "${extensionName}".`);
+        return;
+    }
+    await updateSetting(extensionConfig, extension.id, settingKey, requestSetting, scope, process.cwd());
+    logger.log(`Setting "${settingKey}" updated.`);
+}
+export async function configureExtension(extensionManager, extensionName, scope, logger = defaultLogger, requestSetting = defaultRequestSetting, requestConfirmation = defaultRequestConfirmation) {
+    const { extension } = await getExtensionAndManager(extensionManager, extensionName, logger);
+    if (!extension) {
+        return;
+    }
+    const extensionConfig = await extensionManager.loadExtensionConfig(extension.path);
+    if (!extensionConfig ||
+        !extensionConfig.settings ||
+        extensionConfig.settings.length === 0) {
+        logger.log(`Extension "${extensionName}" has no settings to configure.`);
+        return;
+    }
+    logger.log(`Configuring settings for "${extensionName}"...`);
+    await configureExtensionSettings(extensionConfig, extension.id, scope, logger, requestSetting, requestConfirmation);
+}
+export async function configureAllExtensions(extensionManager, scope, logger = defaultLogger, requestSetting = defaultRequestSetting, requestConfirmation = defaultRequestConfirmation) {
+    const extensions = extensionManager.getExtensions();
+    if (extensions.length === 0) {
+        logger.log('No extensions installed.');
+        return;
+    }
+    for (const extension of extensions) {
+        const extensionConfig = await extensionManager.loadExtensionConfig(extension.path);
+        if (extensionConfig &&
+            extensionConfig.settings &&
+            extensionConfig.settings.length > 0) {
+            logger.log(`\nConfiguring settings for "${extension.name}"...`);
+            await configureExtensionSettings(extensionConfig, extension.id, scope, logger, requestSetting, requestConfirmation);
+        }
+    }
+}
+export async function configureExtensionSettings(extensionConfig, extensionId, scope, logger = defaultLogger, requestSetting = defaultRequestSetting, requestConfirmation = defaultRequestConfirmation) {
+    const currentScopedSettings = await getScopedEnvContents(extensionConfig, extensionId, scope, process.cwd());
+    let workspaceSettings = {};
+    if (scope === ExtensionSettingScope.USER) {
+        workspaceSettings = await getScopedEnvContents(extensionConfig, extensionId, ExtensionSettingScope.WORKSPACE, process.cwd());
+    }
+    if (!extensionConfig.settings)
+        return;
+    for (const setting of extensionConfig.settings) {
+        const currentValue = currentScopedSettings[setting.envVar];
+        const workspaceValue = workspaceSettings[setting.envVar];
+        if (workspaceValue !== undefined) {
+            logger.log(`Note: Setting "${setting.name}" is already configured in the workspace scope.`);
+        }
+        if (currentValue !== undefined) {
+            const confirmed = await requestConfirmation(`Setting "${setting.name}" (${setting.envVar}) is already set. Overwrite?`);
+            if (!confirmed) {
+                continue;
+            }
+        }
+        await updateSetting(extensionConfig, extensionId, setting.envVar, requestSetting, scope, process.cwd());
+    }
+}
+export function getFormattedSettingValue(setting) {
+    if (!setting.value) {
+        return '[not set]';
+    }
+    if (setting.sensitive) {
+        return '***';
+    }
+    return setting.value;
+}

package/dist/commands/extensions/validate.js

@@ -0,0 +1,84 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { debugLogger, getErrorMessage } from '@google/gemini-cli-core';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import semver from 'semver';
+import { ExtensionManager } from '../../config/extension-manager.js';
+import { requestConsentNonInteractive } from '../../config/extensions/consent.js';
+import { promptForSetting } from '../../config/extensions/extensionSettings.js';
+import { loadSettings } from '../../config/settings.js';
+import { exitCli } from '../utils.js';
+export async function handleValidate(args) {
+    try {
+        await validateExtension(args);
+        debugLogger.log(`Extension ${args.path} has been successfully validated.`);
+    }
+    catch (error) {
+        debugLogger.error(getErrorMessage(error));
+        process.exit(1);
+    }
+}
+async function validateExtension(args) {
+    const workspaceDir = process.cwd();
+    const extensionManager = new ExtensionManager({
+        workspaceDir,
+        requestConsent: requestConsentNonInteractive,
+        requestSetting: promptForSetting,
+        settings: loadSettings(workspaceDir).merged,
+    });
+    const absoluteInputPath = path.resolve(args.path);
+    const extensionConfig = await extensionManager.loadExtensionConfig(absoluteInputPath);
+    const warnings = [];
+    const errors = [];
+    if (extensionConfig.contextFileName) {
+        const contextFileNames = Array.isArray(extensionConfig.contextFileName)
+            ? extensionConfig.contextFileName
+            : [extensionConfig.contextFileName];
+        const missingContextFiles = [];
+        for (const contextFilePath of contextFileNames) {
+            const contextFileAbsolutePath = path.resolve(absoluteInputPath, contextFilePath);
+            if (!fs.existsSync(contextFileAbsolutePath)) {
+                missingContextFiles.push(contextFilePath);
+            }
+        }
+        if (missingContextFiles.length > 0) {
+            errors.push(`The following context files referenced in gemini-extension.json are missing: ${missingContextFiles}`);
+        }
+    }
+    if (!semver.valid(extensionConfig.version)) {
+        warnings.push(`Warning: Version '${extensionConfig.version}' does not appear to be standard semver (e.g., 1.0.0).`);
+    }
+    if (warnings.length > 0) {
+        debugLogger.warn('Validation warnings:');
+        for (const warning of warnings) {
+            debugLogger.warn(`  - ${warning}`);
+        }
+    }
+    if (errors.length > 0) {
+        debugLogger.error('Validation failed with the following errors:');
+        for (const error of errors) {
+            debugLogger.error(`  - ${error}`);
+        }
+        throw new Error('Extension validation failed.');
+    }
+}
+export const validateCommand = {
+    command: 'validate <path>',
+    describe: 'Validates an extension from a local path.',
+    builder: (yargs) => yargs.positional('path', {
+        describe: 'The path of the extension to validate.',
+        type: 'string',
+        demandOption: true,
+    }),
+    handler: async (args) => {
+        await handleValidate({
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            path: args['path'],
+        });
+        await exitCli();
+    },
+};

package/dist/commands/extensions.js

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { installCommand } from './extensions/install.js';
+import { uninstallCommand } from './extensions/uninstall.js';
+import { listCommand } from './extensions/list.js';
+import { updateCommand } from './extensions/update.js';
+import { disableCommand } from './extensions/disable.js';
+import { enableCommand } from './extensions/enable.js';
+import { linkCommand } from './extensions/link.js';
+import { newCommand } from './extensions/new.js';
+import { validateCommand } from './extensions/validate.js';
+import { configureCommand } from './extensions/configure.js';
+import { initializeOutputListenersAndFlush } from '../gemini.js';
+import { defer } from '../deferred.js';
+export const extensionsCommand = {
+    command: 'extensions <command>',
+    aliases: ['extension'],
+    describe: 'Manage Gemini CLI extensions.',
+    builder: (yargs) => yargs
+        .middleware((argv) => {
+        initializeOutputListenersAndFlush();
+        argv['isCommand'] = true;
+    })
+        .command(defer(installCommand, 'extensions'))
+        .command(defer(uninstallCommand, 'extensions'))
+        .command(defer(listCommand, 'extensions'))
+        .command(defer(updateCommand, 'extensions'))
+        .command(defer(disableCommand, 'extensions'))
+        .command(defer(enableCommand, 'extensions'))
+        .command(defer(linkCommand, 'extensions'))
+        .command(defer(newCommand, 'extensions'))
+        .command(defer(validateCommand, 'extensions'))
+        .command(defer(configureCommand, 'extensions'))
+        .demandCommand(1, 'You need at least one command before continuing.')
+        .version(false),
+    handler: () => {
+        // This handler is not called when a subcommand is provided.
+        // Yargs will show the help menu.
+    },
+};

package/dist/commands/gemma/constants.js

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import path from 'node:path';
+import { Storage } from '@google/gemini-cli-core';
+export const LITERT_RELEASE_VERSION = 'v0.9.0-alpha03';
+export const LITERT_RELEASE_BASE_URL = 'https://github.com/google-ai-edge/LiteRT-LM/releases/download';
+export const GEMMA_MODEL_NAME = 'gemma3-1b-gpu-custom';
+export const DEFAULT_PORT = 9379;
+export const HEALTH_CHECK_TIMEOUT_MS = 5000;
+export const LITERT_API_VERSION = 'v1beta';
+export const SERVER_START_WAIT_MS = 3000;
+export const PLATFORM_BINARY_MAP = {
+    'darwin-arm64': 'lit.macos_arm64',
+    'linux-x64': 'lit.linux_x86_64',
+    'win32-x64': 'lit.windows_x86_64.exe',
+};
+// SHA-256 hashes for the official LiteRT-LM v0.9.0-alpha03 release binaries.
+export const PLATFORM_BINARY_SHA256 = {
+    'lit.macos_arm64': '9e826a2634f2e8b220ad0f1e1b5c139e0b47cb172326e3b7d46d31382f49478e',
+    'lit.linux_x86_64': '66601df8a07f08244b188e9fcab0bf4a16562fe76d8d47e49f40273d57541ee8',
+    'lit.windows_x86_64.exe': 'de82d2829d2fb1cbdb318e2d8a78dc2f9659ff14cb11b2894d1f30e0bfde2bf6',
+};
+export function getLiteRtBinDir() {
+    return path.join(Storage.getGlobalGeminiDir(), 'bin', 'litert');
+}
+export function getPidFilePath() {
+    return path.join(Storage.getGlobalTempDir(), 'litert-server.pid');
+}
+export function getLogFilePath() {
+    return path.join(Storage.getGlobalTempDir(), 'litert-server.log');
+}

package/dist/commands/gemma/logs.js

@@ -0,0 +1,153 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import fs from 'node:fs';
+import { spawn } from 'node:child_process';
+import { debugLogger } from '@google/gemini-cli-core';
+import { exitCli } from '../utils.js';
+import { getLogFilePath } from './constants.js';
+export async function readLastLines(filePath, count) {
+    if (count <= 0) {
+        return '';
+    }
+    const CHUNK_SIZE = 64 * 1024;
+    const fileHandle = await fs.promises.open(filePath, fs.constants.O_RDONLY);
+    try {
+        const stats = await fileHandle.stat();
+        if (stats.size === 0) {
+            return '';
+        }
+        const chunks = [];
+        let totalBytes = 0;
+        let newlineCount = 0;
+        let position = stats.size;
+        while (position > 0 && newlineCount <= count) {
+            const readSize = Math.min(CHUNK_SIZE, position);
+            position -= readSize;
+            const buffer = Buffer.allocUnsafe(readSize);
+            const { bytesRead } = await fileHandle.read(buffer, 0, readSize, position);
+            if (bytesRead === 0) {
+                break;
+            }
+            const chunk = bytesRead === readSize ? buffer : buffer.subarray(0, bytesRead);
+            chunks.unshift(chunk);
+            totalBytes += chunk.length;
+            for (const byte of chunk) {
+                if (byte === 0x0a) {
+                    newlineCount += 1;
+                }
+            }
+        }
+        const content = Buffer.concat(chunks, totalBytes).toString('utf-8');
+        const lines = content.split('\n');
+        if (position > 0 && lines.length > 0) {
+            const boundary = Buffer.allocUnsafe(1);
+            const { bytesRead } = await fileHandle.read(boundary, 0, 1, position - 1);
+            if (bytesRead === 1 && boundary[0] !== 0x0a) {
+                lines.shift();
+            }
+        }
+        if (lines.length > 0 && lines[lines.length - 1] === '') {
+            lines.pop();
+        }
+        if (lines.length === 0) {
+            return '';
+        }
+        return lines.slice(-count).join('\n') + '\n';
+    }
+    finally {
+        await fileHandle.close();
+    }
+}
+function waitForChild(child) {
+    return new Promise((resolve, reject) => {
+        child.once('error', reject);
+        child.once('close', (code) => resolve(code ?? 1));
+    });
+}
+async function runTail(logPath, lines, follow) {
+    const tailArgs = follow
+        ? ['-f', '-n', String(lines), logPath]
+        : ['-n', String(lines), logPath];
+    const child = spawn('tail', tailArgs, { stdio: 'inherit' });
+    if (!follow) {
+        return waitForChild(child);
+    }
+    const handleSigint = () => {
+        child.kill('SIGTERM');
+    };
+    process.once('SIGINT', handleSigint);
+    try {
+        return await waitForChild(child);
+    }
+    finally {
+        process.off('SIGINT', handleSigint);
+    }
+}
+export const logsCommand = {
+    command: 'logs',
+    describe: 'View LiteRT-LM server logs',
+    builder: (yargs) => yargs
+        .option('lines', {
+        alias: 'n',
+        type: 'number',
+        description: 'Show the last N lines and exit (omit to follow live)',
+    })
+        .option('follow', {
+        alias: 'f',
+        type: 'boolean',
+        description: 'Follow log output (defaults to true when --lines is omitted)',
+    }),
+    handler: async (argv) => {
+        const logPath = getLogFilePath();
+        try {
+            await fs.promises.access(logPath, fs.constants.F_OK);
+        }
+        catch {
+            debugLogger.log(`No log file found at ${logPath}`);
+            debugLogger.log('Is the LiteRT server running? Start it with: gemini gemma start');
+            await exitCli(1);
+            return;
+        }
+        const lines = argv.lines;
+        const follow = argv.follow ?? lines === undefined;
+        const requestedLines = lines ?? 20;
+        if (follow && process.platform === 'win32') {
+            debugLogger.log('Live log following is not supported on Windows. Use --lines N to view recent logs.');
+            await exitCli(1);
+            return;
+        }
+        if (process.platform === 'win32') {
+            process.stdout.write(await readLastLines(logPath, requestedLines));
+            await exitCli(0);
+            return;
+        }
+        try {
+            if (follow) {
+                debugLogger.log(`Tailing ${logPath} (Ctrl+C to stop)\n`);
+            }
+            const exitCode = await runTail(logPath, requestedLines, follow);
+            await exitCli(exitCode);
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                'code' in error &&
+                error.code === 'ENOENT') {
+                if (!follow) {
+                    process.stdout.write(await readLastLines(logPath, requestedLines));
+                    await exitCli(0);
+                }
+                else {
+                    debugLogger.error('"tail" command not found. Use --lines N to view recent logs without tail.');
+                    await exitCli(1);
+                }
+            }
+            else {
+                debugLogger.error(`Failed to read log output: ${error instanceof Error ? error.message : String(error)}`);
+                await exitCli(1);
+            }
+        }
+    },
+};