@qodalis/cli 2.0.0-beta.1

package/public-api.d.ts

@@ -0,0 +1,2302 @@
+import * as _qodalis_cli_core from '@qodalis/cli-core';
+import { ICliCommandProcessor, ICliCommandParameterDescriptor, ICliCommandProcessorRegistry, ICliCommandChildProcessor, CliProcessorMetadata, CliStateConfiguration, ICliExecutionContext, CliProcessCommand, ICliCommandAuthor, CliThemeInfo, ICliExecutionProcess, ICliUserSession, ICliSpinner, ICliPercentageProgressBar, ICliTextAnimator, ICliTerminalWriter, ICliCommandExecutorService, ICliClipboard, ICliStateStore, CliOptions, ICliLogger, ICliServiceProvider, ICliTranslationService, ICliInputReader, ICliBackgroundServiceRegistry, ICliManagedInterval, ICliManagedTimer, ICliKeyValueStore, CliSelectOption, CliMultiSelectOption, ICliCompletionProvider, ICliGlobalParameterHandler, CliProvider, CliForegroundColor, CliBackgroundColor, CliLogLevel, CliPercentageProgressBarUpdateValueOptions, CliTextAnimatorOptions, ICliModule, CliModuleRegistry, Package, ICliPingServerService, ICliProcessRegistry, ICliProcessEntry, ICliDragDropService, CliState, CliEngineSnapshot, CliServerConfig, CliServerCommandDescriptor, CliServerCapabilities, CliServerResponse, CliIcon } from '@qodalis/cli-core';
+export { ICliUserSessionService_TOKEN, ICliUsersStoreService_TOKEN } from '@qodalis/cli-core';
+import { ITheme, Terminal, ITerminalAddon, ITerminalOptions, ITerminalInitOnlyOptions } from '@xterm/xterm';
+import { Subject, Observable, Subscription } from 'rxjs';
+
+type ParsedArg = {
+    name: string;
+    value: any;
+};
+type ParsedToken = {
+    kind: 'flag';
+    name: string;
+    value: string | number | boolean;
+    hasEquals: boolean;
+} | {
+    kind: 'word';
+    value: string;
+};
+type CommandParserOutput = {
+    commandName: string;
+    args: ParsedArg[];
+    tokens: ParsedToken[];
+};
+type CommandPart = {
+    /** 'command' for a command to execute, or the operator string */
+    type: 'command' | '&&' | '||' | '2>>' | '2>' | '>>' | '>' | '|' | ';';
+    value: string;
+};
+/**
+ * A utility class for parsing command strings into command names and arguments.
+ */
+declare class CommandParser {
+    /** Operators recognized during command-line splitting. */
+    private static readonly OPERATORS;
+    /**
+     * Split a raw command line into commands and operators.
+     * Respects single and double quotes — operators inside quoted strings
+     * are treated as literal text, not as operators.
+     * @param input - The full raw input string.
+     * @returns An array of command parts with their types.
+     */
+    static splitByOperators(input: string): CommandPart[];
+    /**
+     * Parse a command string into a full command name and arguments.
+     * @param command - The full command string.
+     * @returns An object containing the full command name and arguments.
+     */
+    parse(command: string): CommandParserOutput;
+    /**
+     * Parse individual values to their appropriate type.
+     * @param value - The value to parse.
+     * @returns The parsed value.
+     */
+    private parseValue;
+}
+
+declare class CliArgsParser {
+    static convertToRecord(args: ParsedArg[], processor: ICliCommandProcessor): Record<string, any>;
+}
+
+/**
+ * Re-interprets parsed tokens using processor parameter descriptors to support
+ * `--param value` (space-separated) argument format in addition to `--param=value`.
+ *
+ * When a flag has no explicit `=` value and the matching descriptor's type is
+ * not boolean, the next word token is consumed as the flag's value.
+ *
+ * @param tokens - Ordered tokens from the parser.
+ * @param descriptors - Parameter descriptors from the matched processor.
+ * @returns Reconciled args array and remaining command parts.
+ */
+declare function reconcileArgs(tokens: ParsedToken[], descriptors: ICliCommandParameterDescriptor[] | undefined): {
+    args: ParsedArg[];
+    commandParts: string[];
+};
+
+declare const groupBy: <T, K>(list: T[], keySelector: (item: T) => K) => Map<K, T[]>;
+
+declare const getGreetingBasedOnTime: (date?: Date) => "☀️ Good morning! Wishing you a productive day ahead!" | "🌤️ Good afternoon! Keep up the great work!" | "🌆 Good evening! Hope you had a fantastic day!" | "🌙 Good night! Rest well and see you tomorrow!";
+
+declare const openLink: (link: string) => void;
+
+declare class ProcessExitedError extends Error {
+    code: number;
+    constructor(code: number);
+}
+
+declare class CliCommandProcessorRegistry implements ICliCommandProcessorRegistry {
+    readonly processors: ICliCommandProcessor[];
+    constructor(initialProcessors?: ICliCommandProcessor[]);
+    registerProcessor(processor: ICliCommandProcessor): void;
+    unregisterProcessor(processor: ICliCommandProcessor): void;
+    findProcessor(mainCommand: string, chainCommands: string[]): ICliCommandProcessor | undefined;
+    /**
+     * Recursively searches for a processor matching the given command.
+     * @param mainCommand The main command name.
+     * @param chainCommands The remaining chain commands (if any).
+     * @param processors The list of available processors.
+     * @returns The matching processor or undefined if not found.
+     */
+    findProcessorInCollection(mainCommand: string, chainCommands: string[], processors: ICliCommandProcessor[]): ICliCommandProcessor | undefined;
+    getRootProcessor(child: ICliCommandChildProcessor): ICliCommandProcessor;
+    private getProcessorByName;
+}
+
+/**
+ * Framework-agnostic token for the CLI command processor registry.
+ * Used as a key in the service provider to retrieve the registry.
+ */
+declare const CliProcessorsRegistry_TOKEN = "cli-processors-registry";
+/**
+ * Framework-agnostic token for the CLI state store manager.
+ * Used as a key in the service provider to retrieve the state store manager.
+ */
+declare const CliStateStoreManager_TOKEN = "cli-state-store-manager";
+/**
+ * Framework-agnostic token for the CLI command history service.
+ * Used as a key in the service provider to retrieve the command history.
+ */
+declare const CliCommandHistory_TOKEN = "cli-command-history";
+/**
+ * Framework-agnostic token for the CLI ping server service.
+ * Used as a key in the service provider to retrieve the ping server service.
+ */
+declare const ICliPingServerService_TOKEN = "cli-ping-server-service";
+/**
+ * Framework-agnostic token for the CLI module registry.
+ * Used as a key in the service provider to retrieve the module registry.
+ */
+declare const CliModuleRegistry_TOKEN = "cli-module-registry";
+/**
+ * Framework-agnostic token for the CLI background service registry.
+ * Used as a key in the service provider to retrieve the background service registry.
+ */
+declare const CliBackgroundServiceRegistry_TOKEN = "cli-background-service-registry";
+/**
+ * Framework-agnostic token for the CLI package manager service.
+ * Used as a key in the service provider to retrieve the package manager.
+ */
+declare const CliPackageManagerService_TOKEN = "cli-package-manager-service";
+
+declare const LIBRARY_VERSION = "2.0.0-beta.1";
+declare const API_VERSION = 2;
+
+declare class CliAliasCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    description: string;
+    processors?: ICliCommandProcessor[] | undefined;
+    metadata?: CliProcessorMetadata | undefined;
+    stateConfiguration?: CliStateConfiguration | undefined;
+    userAliases: Record<string, string>;
+    private stateSubscription?;
+    constructor();
+    writeDescription(context: ICliExecutionContext): void;
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    initialize(context: ICliExecutionContext): Promise<void>;
+}
+
+declare class CliBase64CommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    processors?: ICliCommandProcessor[];
+    metadata?: CliProcessorMetadata;
+    constructor();
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare class CliCalCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    metadata?: CliProcessorMetadata;
+    parameters: {
+        name: string;
+        aliases: string[];
+        description: string;
+        type: "number";
+        required: boolean;
+    }[];
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare class CliClearCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description?: string | undefined;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    metadata?: CliProcessorMetadata | undefined;
+    processCommand(_: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare class CliClipboardCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    processors?: ICliCommandProcessor[];
+    metadata?: CliProcessorMetadata;
+    constructor();
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare class CliColorCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    acceptsRawInput: boolean;
+    valueRequired: boolean;
+    metadata?: CliProcessorMetadata;
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+    private parseHex;
+    private parseRgb;
+    private parseHsl;
+    private rgbToHex;
+    private rgbToHsl;
+    private hslToRgb;
+}
+
+declare class CliConvertCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    acceptsRawInput: boolean;
+    valueRequired: boolean;
+    metadata?: CliProcessorMetadata;
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+    private isTemperatureUnit;
+    private tempLabel;
+    private convertTemperature;
+}
+
+declare class CliEchoCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description: string;
+    acceptsRawInput: boolean;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    metadata?: CliProcessorMetadata | undefined;
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    /** Remove surrounding quotes from the text. */
+    private stripQuotes;
+    /** Interpret common escape sequences like a POSIX echo -e. */
+    private interpretEscapes;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare class CliEvalCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    acceptsRawInput: boolean;
+    metadata?: CliProcessorMetadata | undefined;
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare class CliHashCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    processors?: ICliCommandProcessor[];
+    metadata?: CliProcessorMetadata;
+    constructor();
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare class CliHexCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    processors?: ICliCommandProcessor[];
+    metadata?: CliProcessorMetadata;
+    constructor();
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare class CliJsonCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    processors?: ICliCommandProcessor[];
+    metadata?: CliProcessorMetadata;
+    constructor();
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare class CliJwtCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    processors?: ICliCommandProcessor[];
+    metadata?: CliProcessorMetadata;
+    constructor();
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+    private base64UrlDecode;
+}
+
+declare class CliLoremCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    processors?: ICliCommandProcessor[];
+    metadata?: CliProcessorMetadata;
+    constructor();
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+    private generateWords;
+}
+
+declare class CliOpenCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    acceptsRawInput: boolean;
+    valueRequired: boolean;
+    metadata?: CliProcessorMetadata;
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare class CliRandomCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    processors?: ICliCommandProcessor[];
+    metadata?: CliProcessorMetadata;
+    constructor();
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare class CliScreenCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    metadata?: CliProcessorMetadata;
+    processCommand(_: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare class CliSeqCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    acceptsRawInput: boolean;
+    valueRequired: boolean;
+    metadata?: CliProcessorMetadata;
+    parameters: ({
+        name: string;
+        aliases: string[];
+        description: string;
+        type: "number";
+        required: boolean;
+    } | {
+        name: string;
+        aliases: string[];
+        description: string;
+        type: "string";
+        required: boolean;
+    })[];
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare class CliSleepCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description?: string | undefined;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    metadata?: CliProcessorMetadata | undefined;
+    valueRequired?: boolean | undefined;
+    constructor();
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare class CliTimeCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    version: string;
+    processors?: ICliCommandProcessor[] | undefined;
+    metadata?: CliProcessorMetadata | undefined;
+    constructor();
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare class CliTimestampCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    processors?: ICliCommandProcessor[];
+    metadata?: CliProcessorMetadata;
+    constructor();
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare class CliUnAliasCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    description: string;
+    valueRequired?: boolean | undefined;
+    stateConfiguration?: CliStateConfiguration | undefined;
+    metadata?: CliProcessorMetadata | undefined;
+    writeDescription(context: ICliExecutionContext): void;
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+}
+
+declare class CliUnameCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description?: string | undefined;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    metadata?: CliProcessorMetadata | undefined;
+    writeDescription(context: ICliExecutionContext): void;
+    processCommand(_: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    parseUserAgent(userAgent: string): {
+        browserName: string;
+        version: string;
+        os: string;
+    };
+}
+
+declare class CliUptimeCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    metadata?: CliProcessorMetadata;
+    private sessionStartTimes;
+    initialize(context: ICliExecutionContext): Promise<void>;
+    processCommand(_: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare class CliUrlCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    processors?: ICliCommandProcessor[];
+    metadata?: CliProcessorMetadata;
+    constructor();
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare class CliYesCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    acceptsRawInput: boolean;
+    metadata?: CliProcessorMetadata;
+    parameters: {
+        name: string;
+        aliases: string[];
+        description: string;
+        type: "number";
+        required: boolean;
+    }[];
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare class CliCaptureCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    aliases: string[];
+    author: ICliCommandAuthor;
+    metadata: CliProcessorMetadata;
+    parameters: ICliCommandParameterDescriptor[];
+    processCommand(cmd: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    private sanitizeCssColor;
+    private toHtml;
+    private escapeHtml;
+    private download;
+}
+
+declare class CliSnippetCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    aliases: string[];
+    author: ICliCommandAuthor;
+    metadata: CliProcessorMetadata;
+    stateConfiguration: CliStateConfiguration;
+    processors: ICliCommandChildProcessor[];
+    processCommand(_: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+}
+
+declare class CliDiffCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    author: ICliCommandAuthor;
+    metadata: CliProcessorMetadata;
+    parameters: ICliCommandParameterDescriptor[];
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+}
+
+type DiffType = 'same' | 'add' | 'remove';
+interface DiffLine {
+    type: DiffType;
+    text: string;
+}
+/**
+ * Compute line-by-line diff using LCS (longest common subsequence).
+ */
+declare function computeDiff(left: string, right: string): DiffLine[];
+/**
+ * Format diff with ANSI colors. Only shows lines near changes (contextLines around each change).
+ */
+declare function formatDiff(lines: DiffLine[], contextLines?: number): string[];
+
+declare class CliHelpCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description: string;
+    acceptsRawInput?: boolean | undefined;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    metadata?: CliProcessorMetadata | undefined;
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+    private translateDescription;
+    private writeProcessorDescription;
+    private formatModuleName;
+    private writeParameter;
+}
+
+declare class CliVersionCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description?: string | undefined;
+    processors?: ICliCommandProcessor[] | undefined;
+    author?: ICliCommandAuthor | undefined;
+    metadata?: CliProcessorMetadata | undefined;
+    processCommand(_: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare class CliFeedbackCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description?: string | undefined;
+    processors?: ICliCommandChildProcessor[] | undefined;
+    author?: ICliCommandAuthor | undefined;
+    metadata?: CliProcessorMetadata | undefined;
+    constructor();
+    processCommand(_: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare class CliHistoryCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description?: string | undefined;
+    processors?: ICliCommandProcessor[] | undefined;
+    author?: ICliCommandAuthor | undefined;
+    metadata?: CliProcessorMetadata | undefined;
+    constructor();
+    processCommand(_: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare class CliHotKeysCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description: string;
+    processors?: ICliCommandProcessor[] | undefined;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    metadata?: CliProcessorMetadata | undefined;
+    processCommand(_: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare class CliPackagesCommandProcessor implements ICliCommandProcessor {
+    readonly command = "pkg";
+    readonly aliases: string[];
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    readonly version = "1.0.3";
+    readonly processors?: ICliCommandProcessor[] | undefined;
+    readonly metadata?: CliProcessorMetadata | undefined;
+    stateConfiguration?: CliStateConfiguration | undefined;
+    private registeredDependencies;
+    private scriptsLoader;
+    private packagesManager;
+    private registry;
+    private createAbortSignal;
+    constructor();
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription?(context: ICliExecutionContext): void;
+    initialize(context: ICliExecutionContext): Promise<void>;
+    private removePackage;
+    private addPackage;
+    private doAddPackage;
+    private updatePackage;
+    private injectScriptWithCdnFallback;
+    private registerPackageDependencies;
+    private resolvePackageCdnPath;
+    private waitForGlobal;
+}
+
+declare class CliDebugCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    metadata?: CliProcessorMetadata;
+    processors?: ICliCommandProcessor[];
+    processCommand(_: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+    private countProcessors;
+}
+
+declare class CliNanoCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    acceptsRawInput: boolean;
+    metadata: CliProcessorMetadata;
+    private buffer;
+    private renderer;
+    private filePath;
+    private fs;
+    private context;
+    private resizeDisposable;
+    private statusMessage;
+    private statusTimeout;
+    private inputMode;
+    private inputBuffer;
+    private searchNeedle;
+    private replaceWith;
+    private replaceAllMode;
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    onData(data: string, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+    private render;
+    private renderPrompt;
+    private showStatus;
+    private handleTextPrompt;
+    private getPromptLabel;
+    private handleReplaceConfirm;
+    private exitEditor;
+    private handleExitSavePrompt;
+    private writeOut;
+    private save;
+    private readFileIntoBuffer;
+    private cleanup;
+}
+
+declare class CliServicesCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    processors?: ICliCommandProcessor[];
+    metadata?: CliProcessorMetadata;
+    constructor();
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare class CliPsCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    metadata: {
+        icon: string;
+        sealed: boolean;
+    };
+    processCommand(_command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+}
+
+declare class CliKillCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    valueRequired: boolean;
+    metadata: {
+        icon: string;
+        sealed: boolean;
+    };
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+}
+
+declare const systemProcessors: ICliCommandProcessor[];
+
+declare class CliThemeCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description: string;
+    author?: ICliCommandAuthor | undefined;
+    version?: string | undefined;
+    processors?: ICliCommandProcessor[] | undefined;
+    metadata?: CliProcessorMetadata | undefined;
+    stateConfiguration?: CliStateConfiguration | undefined;
+    private themeOptions;
+    private defaultTheme;
+    constructor();
+    initialize(context: ICliExecutionContext): Promise<void>;
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    private renderThemePreview;
+    private applyStyles;
+    private saveTheme;
+    writeDescription?(context: ICliExecutionContext): void;
+}
+
+type ThemeState = {
+    selectedTheme?: string;
+    customOptions?: ITheme;
+};
+declare const themes: {
+    [x: string]: ITheme;
+    default: ITheme;
+    classic: ITheme;
+    dracula: ITheme;
+    monokai: ITheme;
+    solarizedDark: ITheme;
+    solarizedLight: ITheme;
+    gruvboxDark: ITheme;
+    gruvboxLight: ITheme;
+    nord: ITheme;
+    oneDark: ITheme;
+    material: ITheme;
+    highContrastLight: ITheme;
+    tokyoNight: ITheme;
+    catppuccinMocha: ITheme;
+    catppuccinFrappe: ITheme;
+    rosePine: ITheme;
+    kanagawa: ITheme;
+    everforestDark: ITheme;
+    ayuDark: ITheme;
+    catppuccinLatte: ITheme;
+    rosePineDawn: ITheme;
+    everforestLight: ITheme;
+    githubLight: ITheme;
+    cyberpunk: ITheme;
+    retroGreen: ITheme;
+    retroAmber: ITheme;
+    matrix: ITheme;
+    synthwave: ITheme;
+    highContrastDark: ITheme;
+    yellow: ITheme;
+};
+declare const themeInfos: Record<string, CliThemeInfo>;
+
+declare class CliConfigureCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    author?: ICliCommandAuthor | undefined;
+    version?: string | undefined;
+    processors?: ICliCommandProcessor[] | undefined;
+    metadata?: CliProcessorMetadata | undefined;
+    stateConfiguration?: CliStateConfiguration | undefined;
+    constructor();
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    initialize(context: ICliExecutionContext): Promise<void>;
+    writeDescription?(context: ICliExecutionContext): void;
+    private showMainMenu;
+    private showCategoryMenu;
+    private editOption;
+    private setConfigValue;
+    private getConfigValue;
+    private getAllOptions;
+    private applySystemSettings;
+    private buildListProcessor;
+    private buildGetProcessor;
+    private buildSetProcessor;
+    private buildResetProcessor;
+    private coerceValue;
+    private getLanguageLabel;
+    private static buildDefaults;
+}
+
+interface ConfigureState {
+    system: Record<string, any>;
+    plugins: Record<string, Record<string, any>>;
+}
+
+declare class CliPingCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    author: ICliCommandAuthor;
+    acceptsRawInput: boolean;
+    metadata: CliProcessorMetadata;
+    parameters: {
+        name: string;
+        aliases: string[];
+        description: string;
+        required: boolean;
+        type: "number";
+    }[];
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+    private normalizeUrl;
+    private sleep;
+}
+
+/**
+ * `export` — set environment variables.
+ *
+ * Usage:
+ *   export VAR=value
+ *   export VAR="value with spaces"
+ */
+declare class CliExportCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    acceptsRawInput: boolean;
+    metadata: {
+        icon: string;
+        module: string;
+    };
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+/**
+ * `unset` — remove environment variables.
+ */
+declare class CliUnsetCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    acceptsRawInput: boolean;
+    metadata: {
+        icon: string;
+        module: string;
+    };
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+/**
+ * `env` / `printenv` — display environment variables.
+ */
+declare class CliEnvCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    acceptsRawInput: boolean;
+    metadata: {
+        icon: string;
+        module: string;
+    };
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare class CliFontSizeCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    aliases: string[];
+    author: ICliCommandAuthor;
+    metadata: CliProcessorMetadata;
+    stateConfiguration: CliStateConfiguration;
+    processors: ICliCommandProcessor[];
+    initialize(context: ICliExecutionContext): Promise<void>;
+    processCommand(_: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    private getCurrent;
+    private setFontSize;
+}
+
+declare const miscProcessors: (CliAliasCommandProcessor | CliBase64CommandProcessor | CliCalCommandProcessor | CliClearCommandProcessor | CliClipboardCommandProcessor | CliColorCommandProcessor | CliConvertCommandProcessor | CliEchoCommandProcessor | CliEvalCommandProcessor | CliHashCommandProcessor | CliHexCommandProcessor | CliJsonCommandProcessor | CliJwtCommandProcessor | CliLoremCommandProcessor | CliOpenCommandProcessor | CliRandomCommandProcessor | CliScreenCommandProcessor | CliSeqCommandProcessor | CliSleepCommandProcessor | CliTimeCommandProcessor | CliTimestampCommandProcessor | CliUnAliasCommandProcessor | CliUnameCommandProcessor | CliUptimeCommandProcessor | CliUrlCommandProcessor | CliYesCommandProcessor)[];
+declare const builtinProcessors: ICliCommandProcessor[];
+
+declare class CliExecutionProcess implements ICliExecutionProcess {
+    private readonly context;
+    exited?: boolean | undefined;
+    exitCode?: number | undefined;
+    running: boolean;
+    data: any | undefined;
+    /**
+     * Whether `output()` was explicitly called during this command's execution.
+     * Used by the executor to decide whether to auto-capture terminal output.
+     */
+    outputCalled: boolean;
+    constructor(context: ICliExecutionContext);
+    exit(code?: number, options?: {
+        silent?: boolean;
+    }): void;
+    output(data: any): void;
+    start(): void;
+    end(): void;
+}
+
+declare class CliCommandExecutionContext implements ICliExecutionContext {
+    readonly context: ICliExecutionContext;
+    userSession?: ICliUserSession | undefined;
+    spinner?: ICliSpinner | undefined;
+    progressBar: ICliPercentageProgressBar;
+    textAnimator?: ICliTextAnimator | undefined;
+    onAbort: Subject<void>;
+    signal?: AbortSignal;
+    terminal: Terminal;
+    writer: ICliTerminalWriter;
+    executor: ICliCommandExecutorService;
+    clipboard: ICliClipboard;
+    state: ICliStateStore;
+    options?: CliOptions | undefined;
+    setContextProcessor: (processor: ICliCommandProcessor | undefined, silent?: boolean, fullScreen?: boolean) => void;
+    process: ICliExecutionProcess;
+    logger: ICliLogger;
+    services: ICliServiceProvider;
+    translator: ICliTranslationService;
+    reader: ICliInputReader;
+    readonly backgroundServices: ICliBackgroundServiceRegistry;
+    get promptLength(): number;
+    set promptLength(value: number);
+    get currentLine(): string;
+    setCurrentLine: (line: string) => void;
+    get cursorPosition(): number;
+    set cursorPosition(value: number);
+    clearLine: () => void;
+    showPrompt: (options?: {
+        reset?: boolean;
+        newLine?: boolean;
+        keepCurrentLine?: boolean;
+    }) => void;
+    clearCurrentLine: () => void;
+    refreshCurrentLine: () => void;
+    enterFullScreenMode: (processor: ICliCommandProcessor) => void;
+    exitFullScreenMode: () => void;
+    createInterval: (callback: () => void, ms: number) => ICliManagedInterval;
+    createTimeout: (callback: () => void, ms: number) => ICliManagedTimer;
+    constructor(context: ICliExecutionContext, processor: ICliCommandProcessor);
+}
+
+declare class CliCommandHistory {
+    private readonly store;
+    private readonly storageKey;
+    private commandHistory;
+    constructor(store: ICliKeyValueStore);
+    addCommand(command: string): Promise<void>;
+    getLastIndex(): number;
+    getHistory(): string[];
+    clearHistory(): Promise<void>;
+    setHistory(commands: string[]): Promise<void>;
+    getCommand(index: number): string | undefined;
+    /**
+     * Search history for commands containing the query string (case-insensitive).
+     * Returns matching commands in chronological order (oldest first).
+     */
+    search(query: string): string[];
+    /**
+     * Find the index of the most recent command that starts with the given prefix,
+     * searching backward from `fromIndex` (exclusive).
+     * Returns -1 if no match found.
+     */
+    searchBackward(prefix: string, fromIndex: number): number;
+    /**
+     * Find the index of the next command that starts with the given prefix,
+     * searching forward from `fromIndex` (exclusive).
+     * Returns -1 if no match found.
+     */
+    searchForward(prefix: string, fromIndex: number): number;
+    private saveHistory;
+    private loadHistory;
+    initialize(): Promise<void>;
+}
+
+interface ICliStateStoreManager {
+    getProcessorStateStore(processor: ICliCommandProcessor): ICliStateStore;
+    getStateStore(name: string, defaultState?: Record<string, any>): ICliStateStore;
+    getStoreEntries(): {
+        name: string;
+        state: Record<string, any>;
+    }[];
+}
+declare class CliStateStoreManager implements ICliStateStoreManager {
+    private readonly services;
+    private readonly registry;
+    private stores;
+    constructor(services: ICliServiceProvider, registry: ICliCommandProcessorRegistry);
+    getStateStore(name: string, defaultState?: Record<string, any>): ICliStateStore;
+    getProcessorStateStore(processor: ICliCommandProcessor): ICliStateStore;
+    /**
+     * Returns all store names and their current state values.
+     */
+    getStoreEntries(): {
+        name: string;
+        state: Record<string, any>;
+    }[];
+}
+
+type ActiveInputRequestType = 'line' | 'password' | 'confirm' | 'select' | 'select-inline' | 'multi-select' | 'number';
+interface ActiveInputRequest {
+    type: ActiveInputRequestType;
+    promptText: string;
+    resolve: (value: any) => void;
+    buffer: string;
+    cursorPosition: number;
+    defaultValue?: boolean;
+    options?: CliSelectOption[];
+    selectedIndex?: number;
+    onChange?: (value: string) => void;
+    checkedIndices?: Set<number>;
+    numberOptions?: {
+        min?: number;
+        max?: number;
+        default?: number;
+    };
+    scrollOffset?: number;
+    maxVisible?: number;
+    displayLines?: number;
+}
+interface CliInputReaderHost {
+    readonly activeInputRequest: ActiveInputRequest | null;
+    setActiveInputRequest(request: ActiveInputRequest | null): void;
+    writeToTerminal(text: string): void;
+    getTerminalRows?(): number;
+}
+declare class CliInputReader implements ICliInputReader {
+    private readonly host;
+    constructor(host: CliInputReaderHost);
+    readLine(prompt: string): Promise<string | null>;
+    readPassword(prompt: string): Promise<string | null>;
+    readConfirm(prompt: string, defaultValue?: boolean): Promise<boolean | null>;
+    readSelect(prompt: string, options: CliSelectOption[], onChange?: (value: string) => void): Promise<string | null>;
+    readSelectInline(prompt: string, options: CliSelectOption[], onChange?: (value: string) => void): Promise<string | null>;
+    readMultiSelect(prompt: string, options: CliMultiSelectOption[]): Promise<string[] | null>;
+    readNumber(prompt: string, options?: {
+        min?: number;
+        max?: number;
+        default?: number;
+    }): Promise<number | null>;
+    renderSelectOptions(options: CliSelectOption[], selectedIndex: number, scrollOffset?: number, maxVisible?: number): number;
+    renderInlineSelectOptions(options: CliSelectOption[], selectedIndex: number): string;
+    renderMultiSelectOptions(options: CliSelectOption[], selectedIndex: number, checkedIndices: Set<number>, scrollOffset?: number, maxVisible?: number): number;
+    private createInputRequest;
+}
+
+/**
+ * Manages tab-completion by querying registered providers in priority order.
+ * Implements bash-style behavior:
+ *  - First Tab: complete common prefix (or single match fully)
+ *  - Second Tab: display all candidates
+ */
+declare class CliCompletionEngine {
+    private providers;
+    private lastCandidates;
+    private tabCount;
+    private lastInput;
+    setProviders(providers: ICliCompletionProvider[]): void;
+    addProvider(provider: ICliCompletionProvider): void;
+    /**
+     * Reset tab state. Call on any non-tab keypress.
+     */
+    resetState(): void;
+    /**
+     * Process a tab press. Returns the completion result.
+     */
+    complete(input: string, cursor: number): Promise<{
+        /** What to do */
+        action: 'complete' | 'show-candidates' | 'none';
+        /** Replacement text for the token (when action = 'complete') */
+        replacement?: string;
+        /** Where the token starts in the input */
+        tokenStart?: number;
+        /** The original token */
+        token?: string;
+        /** All candidates (when action = 'show-candidates') */
+        candidates?: string[];
+    }>;
+    private buildContext;
+    private tokenize;
+    private fetchCompletions;
+    /**
+     * Return the single best completion string for ghost-text display.
+     * Returns null if there is no clear best match or multiple candidates.
+     */
+    completeSingle(input: string, cursor: number): Promise<string | null>;
+    private commonPrefix;
+}
+
+/**
+ * Reusable text buffer with cursor management.
+ * Eliminates duplicated line-editing logic across CommandLineMode,
+ * ReaderMode, and any future input mode.
+ */
+declare class CliLineBuffer {
+    private _text;
+    private _cursorPosition;
+    get text(): string;
+    get cursorPosition(): number;
+    set cursorPosition(value: number);
+    insert(str: string): void;
+    deleteCharBefore(): void;
+    deleteCharAt(): void;
+    moveCursorLeft(): void;
+    moveCursorRight(): void;
+    moveHome(): void;
+    moveEnd(): void;
+    clear(): void;
+    setText(str: string): void;
+}
+
+/**
+ * State machine interface for terminal input routing.
+ * Each mode handles its own key events and data.
+ */
+interface IInputMode {
+    /**
+     * Handle raw terminal data (characters, escape sequences, control chars).
+     * Called by terminal.onData.
+     */
+    handleInput(data: string): Promise<void>;
+    /**
+     * Handle keyboard events before they reach onData.
+     * Called by terminal.attachCustomKeyEventHandler for 'keydown' events.
+     * Return false to prevent the key from reaching onData.
+     * Return true to let the key pass through to onData.
+     */
+    handleKeyEvent(event: KeyboardEvent): boolean;
+    /**
+     * Called when this mode becomes the active input mode.
+     */
+    activate?(): void;
+    /**
+     * Called when this mode is no longer the active input mode.
+     */
+    deactivate?(): void;
+}
+
+interface PromptOptions {
+    userName?: string;
+    hideUserName?: boolean;
+    contextProcessor?: string;
+    pathProvider?: () => string | null;
+}
+/**
+ * Handles prompt rendering and line display for the CLI.
+ * Encapsulates all terminal escape sequences for line editing.
+ */
+declare class CliTerminalLineRenderer {
+    private readonly terminal;
+    private readonly writer;
+    constructor(terminal: Terminal, writer: ICliTerminalWriter);
+    /**
+     * Builds the prompt string (user:path$ ) with ANSI color codes.
+     */
+    getPromptString(options: PromptOptions): string;
+    /**
+     * Writes the prompt to the terminal and returns the visible prompt length
+     * (number of columns the prompt occupies).
+     */
+    renderPrompt(options: PromptOptions): number;
+    /**
+     * Clears and redraws the current line (prompt + user input + cursor positioning).
+     */
+    refreshLine(currentLine: string, cursorPosition: number, promptLength: number, promptString: string, previousContentLength?: number): void;
+    /**
+     * Clears the current terminal line.
+     */
+    clearLine(contentLength: number): void;
+}
+
+/**
+ * Host interface for CommandLineMode — provides access to
+ * the execution context's services without a circular dependency.
+ */
+interface CommandLineModeHost {
+    readonly terminal: Terminal;
+    readonly lineBuffer: CliLineBuffer;
+    readonly lineRenderer: CliTerminalLineRenderer;
+    readonly completionEngine: CliCompletionEngine;
+    readonly commandHistory: CliCommandHistory;
+    getPromptOptions(): PromptOptions;
+    getPromptLength(): number;
+    setPromptLength(value: number): void;
+    getExecutionContext(): ICliExecutionContext;
+    isProgressRunning(): boolean;
+    isRawModeActive(): boolean;
+    abort(): void;
+    showPrompt(options?: {
+        reset?: boolean;
+        newLine?: boolean;
+        keepCurrentLine?: boolean;
+    }): void;
+}
+
+/**
+ * Host interface for ReaderMode — provides access to the active input request.
+ */
+interface ReaderModeHost {
+    readonly terminal: Terminal;
+    getActiveInputRequest(): ActiveInputRequest | null;
+    setActiveInputRequest(request: ActiveInputRequest | null): void;
+    popMode(): void;
+}
+
+interface CliExecutionContextDeps {
+    services: ICliServiceProvider;
+    logger: ICliLogger;
+    commandHistory: CliCommandHistory;
+    stateStoreManager: CliStateStoreManager;
+    translator: ICliTranslationService;
+}
+declare class CliExecutionContext implements ICliExecutionContext, CliInputReaderHost, CommandLineModeHost, ReaderModeHost {
+    terminal: Terminal;
+    executor: ICliCommandExecutorService;
+    userSession?: ICliUserSession;
+    contextProcessor?: ICliCommandProcessor;
+    readonly writer: ICliTerminalWriter;
+    readonly spinner: ICliSpinner;
+    readonly textAnimator: ICliTextAnimator;
+    readonly progressBar: ICliPercentageProgressBar;
+    readonly options?: CliOptions;
+    readonly onAbort: Subject<void>;
+    readonly state: ICliStateStore;
+    readonly clipboard: ICliClipboard;
+    readonly process: ICliExecutionProcess;
+    readonly logger: ICliLogger;
+    readonly services: ICliServiceProvider;
+    readonly translator: ICliTranslationService;
+    readonly backgroundServices: ICliBackgroundServiceRegistry;
+    promptPathProvider?: () => string | null;
+    readonly completionEngine: CliCompletionEngine;
+    promptLength: number;
+    readonly reader: ICliInputReader;
+    readonly lineBuffer: CliLineBuffer;
+    readonly lineRenderer: CliTerminalLineRenderer;
+    readonly commandHistory: CliCommandHistory;
+    private _activeInputRequest;
+    private readonly modeStack;
+    private readonly managedTimers;
+    private resizeDisposable;
+    constructor(deps: CliExecutionContextDeps, terminal: Terminal, executor: ICliCommandExecutorService, cliOptions?: CliOptions);
+    get activeInputRequest(): ActiveInputRequest | null;
+    /**
+     * Sets the active input request. When a non-null request is provided,
+     * pushes ReaderMode onto the mode stack. ReaderMode pops itself on
+     * completion, so passing null here does NOT pop the mode.
+     */
+    setActiveInputRequest(request: ActiveInputRequest | null): void;
+    writeToTerminal(text: string): void;
+    getTerminalRows(): number;
+    get currentLine(): string;
+    get cursorPosition(): number;
+    set cursorPosition(value: number);
+    initializeTerminalListeners(): void;
+    setContextProcessor: (processor: ICliCommandProcessor | undefined, silent?: boolean, fullScreen?: boolean) => void;
+    setCurrentLine(line: string): void;
+    clearLine(): void;
+    showPrompt(options?: {
+        reset?: boolean;
+        newLine?: boolean;
+        keepCurrentLine?: boolean;
+    }): void;
+    clearCurrentLine(): void;
+    refreshCurrentLine(previousContentLength?: number): void;
+    /**
+     * Redraw the prompt after a terminal resize.
+     * Called by CliEngine.safeFit() when terminal columns change.
+     * No-op when progress indicators, raw mode, or input requests are active.
+     *
+     * Uses the buffer's `isWrapped` flags to walk backwards from the cursor
+     * and find the first visual line of the current logical line.  This tells
+     * us exactly how many rows the prompt (+ user input) spans after xterm
+     * reflow, so we can clear them all — including reflow artefacts that the
+     * simple `ceil(contentLength / cols)` calculation would miss.
+     */
+    handleTerminalResize(): void;
+    isRawModeActive(): boolean;
+    enterFullScreenMode(processor: ICliCommandProcessor): void;
+    exitFullScreenMode(): void;
+    createInterval(callback: () => void, ms: number): ICliManagedInterval;
+    createTimeout(callback: () => void, ms: number): ICliManagedTimer;
+    isProgressRunning(): boolean;
+    abort(): void;
+    setSession(session: ICliUserSession): void;
+    getPromptOptions(): PromptOptions;
+    getPromptLength(): number;
+    setPromptLength(value: number): void;
+    getExecutionContext(): ICliExecutionContext;
+    getActiveInputRequest(): ActiveInputRequest | null;
+    private clearAllManagedTimers;
+    /**
+     * Dispose all resources. Called by CliEngine.destroy() when the
+     * CLI component is being torn down.
+     */
+    dispose(): void;
+    private get currentMode();
+    pushMode(mode: IInputMode): void;
+    popMode(): void;
+}
+
+/**
+ * Extended execution context interface used internally by the command executor.
+ * The concrete implementation (e.g. CliExecutionContext in angular-cli) provides these.
+ */
+interface ICliExecutionHost extends ICliExecutionContext {
+    contextProcessor?: ICliCommandProcessor;
+    abort?(): void;
+}
+declare class CliCommandExecutor implements ICliCommandExecutorService {
+    protected readonly registry: ICliCommandProcessorRegistry;
+    private commandParser;
+    private globalParameters;
+    private lastCapturingWriter?;
+    constructor(registry: ICliCommandProcessorRegistry);
+    registerGlobalParameter(handler: ICliGlobalParameterHandler): void;
+    getGlobalParameters(): ICliCommandParameterDescriptor[];
+    executeCommand(command: string, context: ICliExecutionContext): Promise<void>;
+    private appendOutputToFile;
+    private writeOutputToFile;
+    private executeSingleCommand;
+    private writeStderrToFile;
+    private appendStderrToFile;
+    showHelp(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    /**
+     * Attempt to execute a file path as a script.
+     * Returns true if the file was found and executed, false otherwise.
+     * Requires the @qodalis/cli-files plugin for filesystem access.
+     */
+    private tryExecuteScript;
+    private substituteVars;
+    /**
+     * Expand $VAR and ${VAR} references using the global environment store.
+     * Variables inside single-quoted strings are NOT expanded (like bash).
+     */
+    private expandEnvironmentVars;
+    /**
+     * Validates the command arguments before execution.
+     * @param context The current CLI execution context.
+     * @param processor The processor to validate.
+     * @param args The command arguments.
+     * @param hasPositionalInput Whether the command has positional or piped input.
+     *   When true, required-parameter checks are skipped because the processor
+     *   will parse the positional text itself.
+     * @returns True if the arguments are valid, false otherwise.
+     */
+    private validateBeforeExecution;
+    /**
+     * Returns true when the processor (or one of its ancestors) declares a
+     * parameter whose name or aliases overlap with the global handler's
+     * parameter.  In that case the global handler must be skipped so the
+     * processor can handle the flag itself.
+     */
+    private processorOwnsParameter;
+}
+
+/**
+ * --version / -v : prints the processor's version and halts execution.
+ */
+declare const versionGlobalParameter: ICliGlobalParameterHandler;
+/**
+ * --help / -h : shows help for the current command and halts execution.
+ */
+declare const helpGlobalParameter: ICliGlobalParameterHandler;
+/**
+ * --context : sets the processor as the active context processor and halts execution.
+ */
+declare const contextGlobalParameter: ICliGlobalParameterHandler;
+
+/**
+ * A simple Map-based service container implementing ICliServiceProvider.
+ *
+ * Supports three provider types:
+ * - `useValue`   : registers a static value
+ * - `useFactory` : registers a factory function, invoked once on first `get`
+ * - `useClass`   : registers a class constructor, instantiated once on first `get`
+ *
+ * When `multi: true`, multiple providers for the same token are accumulated
+ * and `get()` returns an array of resolved values.
+ */
+declare class CliServiceContainer implements ICliServiceProvider {
+    /** Stores single-value providers (resolved or pending). */
+    private readonly services;
+    /** Stores multi-provider arrays. */
+    private readonly multiServices;
+    /**
+     * Retrieve a service by its token.
+     *
+     * @param token The token used to register the service.
+     * @returns The resolved service instance (or array for multi providers).
+     * @throws Error if the token has not been registered.
+     */
+    get<T>(token: any): T;
+    /**
+     * Register one or more providers.
+     *
+     * @param definition A single CliProvider or an array of CliProviders.
+     */
+    set(definition: CliProvider | CliProvider[]): void;
+    /**
+     * Returns all registered service tokens (single + multi providers).
+     */
+    getRegisteredTokens(): string[];
+    /**
+     * Returns detailed info for each registered service: token name, value type, and multi flag.
+     */
+    getRegisteredServiceDetails(): {
+        token: string;
+        type: string;
+        multi: boolean;
+    }[];
+    /**
+     * Describe a resolved value for diagnostic display.
+     */
+    private describeValue;
+    /**
+     * Register a single provider.
+     */
+    private registerProvider;
+    /**
+     * Resolve a provider definition to a concrete value.
+     */
+    private resolveProvider;
+}
+
+declare class CliTerminalWriter implements ICliTerminalWriter {
+    readonly terminal: Terminal;
+    constructor(terminal: Terminal);
+    write(text: string): void;
+    writeln(text?: string): void;
+    writeSuccess(message: string): void;
+    writeInfo(message: string): void;
+    writeWarning(message: string): void;
+    writeError(message: string): void;
+    private writeLog;
+    writeDivider(options?: {
+        color?: CliForegroundColor;
+        length?: number;
+        char?: string;
+    }): void;
+    wrapInColor(text: string, color: CliForegroundColor): string;
+    wrapInBackgroundColor(text: string, color: CliBackgroundColor): string;
+    writeJson(json: any): void;
+    writeToFile(fileName: string, content: string): void;
+    writeObjectsAsTable(objects: any[]): void;
+    writeList(items: string[], options?: {
+        ordered?: boolean;
+        prefix?: string;
+        color?: CliForegroundColor;
+    }): void;
+    writeKeyValue(entries: Record<string, string> | [string, string][], options?: {
+        separator?: string;
+        keyColor?: CliForegroundColor;
+    }): void;
+    writeColumns(items: string[], options?: {
+        columns?: number;
+        padding?: number;
+    }): void;
+    writeTable(headers: string[], rows: string[][]): void;
+}
+
+declare class CliClipboard implements ICliClipboard {
+    private readonly context;
+    constructor(context: ICliExecutionContext);
+    write(text: string): Promise<void>;
+    read(): Promise<string>;
+}
+
+declare class CliLogger implements ICliLogger {
+    private CliLogLevel;
+    constructor();
+    setCliLogLevel(level: CliLogLevel): void;
+    log(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    debug(...args: any[]): void;
+}
+
+declare class CliTerminalSpinner implements ICliSpinner {
+    private terminal;
+    isRunning: boolean;
+    text: string;
+    context?: ICliExecutionContext;
+    constructor(terminal: Terminal);
+    private spinnerInterval?;
+    private spinnerFrames;
+    private spinnerColors;
+    private spinnerIndex;
+    private savedCurrentLine;
+    private lastContentLength;
+    private lastLineCount;
+    private resizeDisposable?;
+    show(text?: string): void;
+    hide(): void;
+    setText(text: string): void;
+    private clearCurrentLine;
+    private calcLineCount;
+}
+
+declare class CliTerminalProgressBar implements ICliPercentageProgressBar {
+    private terminal;
+    isRunning: boolean;
+    context?: ICliExecutionContext;
+    private text;
+    private progressBarInterval?;
+    private progress;
+    private total;
+    private progressText;
+    private progressTextPlainLength;
+    private savedCurrentLine;
+    private tickCount;
+    private lastLineCount;
+    private resizeDisposable?;
+    constructor(terminal: Terminal);
+    show(text?: string): void;
+    hide(): void;
+    update(progress: number, options?: CliPercentageProgressBarUpdateValueOptions): void;
+    complete(): void;
+    setText(text: string): void;
+    private updateProgressBar;
+    /**
+     * Returns an ANSI 256-color escape for a position in the progress bar.
+     * Gradient: red (0%) -> yellow (50%) -> green (100%).
+     */
+    private progressGradientColor;
+    private clearCurrentLine;
+    private calcLineCount;
+}
+
+declare class CliTerminalTextAnimator implements ICliTextAnimator {
+    private terminal;
+    isRunning: boolean;
+    context?: ICliExecutionContext;
+    private animationInterval?;
+    private text;
+    private textColor;
+    constructor(terminal: Terminal);
+    show(text?: string): void;
+    showText(text: string, options?: CliTextAnimatorOptions): Promise<void>;
+    /**
+     * Hide the animation and reset the state.
+     */
+    hide(): void;
+}
+
+interface CliWelcomeMessageConfig {
+    /** Custom message to display instead of the default */
+    message?: string;
+    /** When to show the welcome message (default: 'always') */
+    show?: 'always' | 'once' | 'daily' | 'never';
+}
+interface ICliWelcomeModule extends ICliModule {
+    configure(config: CliWelcomeMessageConfig): ICliModule;
+}
+declare const welcomeModule: ICliWelcomeModule;
+
+declare class CliBoot {
+    private readonly registry;
+    private readonly services;
+    private initialized;
+    private initializing;
+    private readonly moduleRegistry;
+    private readonly bootedModules;
+    constructor(registry: ICliCommandProcessorRegistry, services: ICliServiceProvider);
+    /**
+     * Get the module registry for external access.
+     */
+    getModuleRegistry(): CliModuleRegistry;
+    boot(context: CliExecutionContext, modules: ICliModule[]): Promise<void>;
+    private bootModule;
+    private buildCoreModule;
+    /**
+     * Topologically sort modules by their dependencies using DFS.
+     * Modules with no dependencies come first.
+     * Circular dependencies are detected and reported. Missing dependencies
+     * cause the dependent module to be skipped.
+     */
+    private topologicalSort;
+    private filterByVersion;
+    private bootShared;
+    private initializeProcessorsInternal;
+}
+
+type CdnSourceName = string;
+type SourceKind = 'registry' | 'file';
+interface SourceEntry {
+    url: string;
+    kind: SourceKind;
+}
+declare class ScriptLoaderService {
+    private sources;
+    private primary;
+    constructor();
+    /**
+     * Registers a custom package source.
+     */
+    addSource(name: string, url: string, kind?: SourceKind): void;
+    /**
+     * Returns all registered source names.
+     */
+    getSources(): string[];
+    /**
+     * Returns the full source entry for a given name, or undefined if not found.
+     */
+    getSource(name: string): SourceEntry | undefined;
+    /**
+     * Returns the base URL for a given source name, or undefined if not found.
+     */
+    getSourceUrl(name: string): string | undefined;
+    /**
+     * Returns all sources of a given kind.
+     */
+    getSourcesByKind(kind: SourceKind): {
+        name: string;
+        url: string;
+    }[];
+    /**
+     * Sets the preferred CDN source. The other sources become fallbacks.
+     */
+    setCdnSource(preferred: CdnSourceName): void;
+    /**
+     * Returns the current preferred CDN source name.
+     */
+    getCdnSource(): CdnSourceName;
+    injectScript(src: string): Promise<void>;
+    getScript(src: string, options?: {
+        onProgress?: (progress: number) => void;
+        signal?: AbortSignal;
+    }): Promise<{
+        xhr: XMLHttpRequest;
+        content?: string;
+        error?: any;
+    }>;
+    injectBodyScript(code: string): void;
+    /**
+     * Returns CDN URLs for a given npm package path.
+     * The first entry is the primary source, the rest are fallbacks.
+     * Only includes 'file' kind sources (CDNs and file servers).
+     */
+    getCdnUrls(packagePath: string): string[];
+    /**
+     * Tries to fetch a script from multiple CDN sources, falling back on failure.
+     */
+    getScriptWithFallback(packagePath: string, options?: {
+        onProgress?: (progress: number) => void;
+        signal?: AbortSignal;
+    }): Promise<{
+        xhr: XMLHttpRequest;
+        content?: string;
+        error?: any;
+    }>;
+    /**
+     * Tries to inject a script tag from multiple CDN sources, falling back on failure.
+     */
+    injectScriptWithFallback(packagePath: string): Promise<void>;
+    private getScriptFromUrls;
+    private injectScriptFromUrls;
+}
+
+declare class CliPackageManagerService {
+    private readonly storageKey;
+    QODALIS_COMMAND_PREFIX: string;
+    private store;
+    constructor();
+    /**
+     * Set the key-value store instance for persistence.
+     */
+    setStore(store: ICliKeyValueStore): void;
+    /**
+     * Retrieves the list of packages
+     * @returns {Package[]} Array of packages
+     */
+    getPackages(): Promise<Package[]>;
+    /**
+     * Retrieves a package by name from the list.
+     */
+    getPackage(packageName: string): Promise<Package | undefined>;
+    /**
+     * Checks if a package with the given name exists in the list.
+     */
+    hasPackage(packageName: string): Promise<boolean>;
+    /**
+     * Adds a new package to the list and saves it in storage.
+     */
+    addPackage(pkg: Package): Promise<void>;
+    /**
+     * Removes a package by name and saves the updated list in storage.
+     */
+    removePackage(packageName: string): Promise<Package>;
+    /**
+     * Updates an existing package in the list.
+     */
+    updatePackage(pkg: Package): Promise<void>;
+    private savePackages;
+}
+
+declare class CliDefaultPingServerService implements ICliPingServerService {
+    ping(): Promise<void>;
+}
+
+/**
+ * A terminal writer wrapper that captures "stdout-equivalent" output
+ * (`write`, `writeln`, `writeJson`, `writeObjectsAsTable`, `writeTable`)
+ * while passing everything through to the underlying writer unchanged.
+ *
+ * Diagnostic methods (`writeError`, `writeWarning`, `writeInfo`, `writeSuccess`)
+ * are NOT captured — they are the equivalent of stderr.
+ *
+ * After a command finishes, the executor can retrieve the captured data to use
+ * as implicit pipeline output when the command did not call `process.output()`.
+ */
+declare class CapturingTerminalWriter implements ICliTerminalWriter {
+    private readonly inner;
+    /** Raw text lines captured from write/writeln calls. */
+    private _lines;
+    /** Structured data captured from writeJson calls. */
+    private _jsonValues;
+    /** Structured data captured from writeObjectsAsTable calls. */
+    private _tableObjects;
+    /** Raw text lines captured from writeError/writeWarning calls. */
+    private _stderrLines;
+    constructor(inner: ICliTerminalWriter);
+    write(text: string): void;
+    writeln(text?: string): void;
+    writeJson(json: any): void;
+    writeObjectsAsTable(objects: any[]): void;
+    writeTable(headers: string[], rows: string[][]): void;
+    writeSuccess(message: string): void;
+    writeInfo(message: string): void;
+    writeWarning(message: string): void;
+    writeError(message: string): void;
+    wrapInColor(text: string, color: CliForegroundColor): string;
+    wrapInBackgroundColor(text: string, color: CliBackgroundColor): string;
+    writeToFile(fileName: string, content: string): void;
+    writeDivider(options?: {
+        color?: CliForegroundColor;
+        length?: number;
+        char?: string;
+    }): void;
+    writeList(items: string[], options?: {
+        ordered?: boolean;
+        prefix?: string;
+        color?: CliForegroundColor;
+    }): void;
+    writeKeyValue(entries: Record<string, string> | [string, string][], options?: {
+        separator?: string;
+        keyColor?: CliForegroundColor;
+    }): void;
+    writeColumns(items: string[], options?: {
+        columns?: number;
+        padding?: number;
+    }): void;
+    /**
+     * Returns true if any stdout-equivalent output was captured.
+     */
+    hasOutput(): boolean;
+    /**
+     * Returns the captured data in the most useful form:
+     *
+     * 1. If structured JSON was written (via `writeJson`), return the last
+     *    JSON value (preserving its original type — object, array, etc.).
+     * 2. If objects were written as a table, return the last array of objects.
+     * 3. Otherwise return the captured text lines joined with newlines,
+     *    with ANSI codes stripped and whitespace trimmed.
+     * 4. Returns `undefined` if nothing was captured.
+     */
+    getCapturedData(): any | undefined;
+    /**
+     * Returns true if any stderr-equivalent output was captured.
+     */
+    hasStderr(): boolean;
+    /**
+     * Returns captured stderr text joined with newlines, or undefined if empty.
+     */
+    getCapturedStderr(): string | undefined;
+}
+
+declare const CliProcessRegistry_TOKEN = "cli-process-registry";
+declare class CliProcessRegistry implements ICliProcessRegistry {
+    private nextPid;
+    private processes;
+    private _currentPid;
+    private maxHistory;
+    get currentPid(): number | undefined;
+    register(command: string): {
+        pid: number;
+        abortController: AbortController;
+    };
+    complete(pid: number, exitCode: number): void;
+    fail(pid: number): void;
+    kill(pid: number): boolean;
+    list(): ICliProcessEntry[];
+    private pruneHistory;
+}
+
+/**
+ * Global environment variable store for the CLI session.
+ *
+ * Variables set here are available to all commands via `$VAR` / `${VAR}`
+ * substitution in the executor. Commands can also read/write the store
+ * directly through the service provider.
+ */
+interface ICliEnvironment {
+    /** Get a variable value (undefined if not set). */
+    get(name: string): string | undefined;
+    /** Set a variable. */
+    set(name: string, value: string): void;
+    /** Remove a variable. */
+    unset(name: string): void;
+    /** Get all variables as a record. */
+    getAll(): Record<string, string>;
+    /** Check if a variable is set. */
+    has(name: string): boolean;
+}
+declare const ICliEnvironment_TOKEN = "cli-environment";
+/**
+ * Default in-memory implementation.
+ * Seeded with some standard variables on construction.
+ */
+declare class CliEnvironment implements ICliEnvironment {
+    private readonly vars;
+    constructor();
+    get(name: string): string | undefined;
+    set(name: string, value: string): void;
+    unset(name: string): void;
+    getAll(): Record<string, string>;
+    has(name: string): boolean;
+}
+
+declare class CliDragDropService implements ICliDragDropService {
+    private readonly _container;
+    private readonly _subject;
+    private readonly _dragOver;
+    private readonly _drop;
+    constructor(_container: HTMLElement);
+    get onFileDrop(): Observable<File[]>;
+    destroy(): void;
+}
+
+declare class OverlayAddon implements ITerminalAddon {
+    private terminal;
+    private overlayNode;
+    private overlayTimeout?;
+    constructor();
+    activate(terminal: Terminal): void;
+    dispose(): void;
+    showOverlay(msg: string, timeout?: number): void;
+}
+
+declare const getCliNameArt: (cols: number) => string;
+/** @deprecated Use getCliNameArt(cols) instead */
+declare const CLi_Name_Art = "\n   ____            _       _ _        _____ _      _____\n  / __ \\          | |     | (_)      / ____| |    |_   _|\n | |  | | ___   __| | __ _| |_ ___  | |    | |      | |\n | |  | |/ _ \\ / _` |/ _` | | / __| | |    | |      | |\n | |__| | (_) | (_| | (_| | | \\__ \\ | |____| |____ _| |_\n  \\___\\_\\\\___/ \\__,_|\\__,_|_|_|___/  \\_____|______|_____|\n";
+declare const hotkeysInfo: {
+    key: string;
+    description: string;
+}[];
+
+declare class CliKeyValueStore implements ICliKeyValueStore {
+    private dbName;
+    private storeName;
+    private db;
+    constructor();
+    /**
+     * Initializes the IndexedDB instance.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Retrieves a value by key.
+     * @param key - The key to retrieve the value for.
+     * @returns A promise resolving to the value or undefined if not found.
+     */
+    get<T = any>(key: string): Promise<T | undefined>;
+    /**
+     * Sets a key-value pair in the store.
+     * @param key - The key to set.
+     * @param value - The value to store.
+     * @returns A promise resolving when the value is stored.
+     */
+    set(key: string, value: any): Promise<void>;
+    /**
+     * Removes a key-value pair by key.
+     * @param key - The key to remove.
+     * @returns A promise resolving when the key is removed.
+     */
+    remove(key: string): Promise<void>;
+    /**
+     * Clears all key-value pairs from the store.
+     * @returns A promise resolving when the store is cleared.
+     */
+    clear(): Promise<void>;
+}
+
+declare class CliStateStore implements ICliStateStore {
+    private readonly services;
+    readonly name: string;
+    private readonly initialState;
+    private state$;
+    private storageKey;
+    constructor(services: ICliServiceProvider, name: string, initialState: CliState);
+    getState<T extends CliState = CliState>(): T;
+    updateState(newState: Partial<CliState>): void;
+    select<K>(selector: (state: CliState) => K): Observable<K>;
+    subscribe(callback: (state: CliState) => void): Subscription;
+    reset(): void;
+    persist(): Promise<void>;
+    initialize(): Promise<void>;
+}
+
+interface CliEngineOptions extends CliOptions {
+    terminalOptions?: Partial<ITerminalOptions & ITerminalInitOnlyOptions>;
+    /** Optional snapshot to restore on start() */
+    snapshot?: CliEngineSnapshot;
+}
+declare class CliEngine {
+    private readonly container;
+    private readonly options?;
+    private terminal;
+    private fitAddon;
+    private serializeAddon;
+    private executionContext;
+    private registry;
+    private userModules;
+    private pendingServices;
+    private resizeObserver?;
+    private resizeListener?;
+    private wheelListener?;
+    private resizeVersion;
+    private resizeScheduled;
+    private bootService?;
+    private dragDropService?;
+    constructor(container: HTMLElement, options?: CliEngineOptions | undefined);
+    /**
+     * Register a CLI module to be loaded on start().
+     */
+    registerModule(module: ICliModule): void;
+    /**
+     * Register multiple CLI modules to be loaded on start().
+     */
+    registerModules(modules: ICliModule[]): void;
+    /**
+     * Register a command processor to be loaded on start().
+     * @deprecated Use registerModule() instead.
+     */
+    registerProcessor(processor: ICliCommandProcessor): void;
+    /**
+     * Register multiple command processors to be loaded on start().
+     * @deprecated Use registerModule() instead.
+     */
+    registerProcessors(processors: ICliCommandProcessor[]): void;
+    /**
+     * Register a service to be available in the service container.
+     * Must be called before start().
+     * @deprecated Use registerModule() with services instead.
+     */
+    registerService(token: string, value: any): void;
+    /**
+     * Initialize the terminal, wire up services, boot modules, and show welcome message.
+     */
+    start(): Promise<void>;
+    /**
+     * Clean up terminal and event listeners.
+     */
+    destroy(): void;
+    /**
+     * Focus the terminal and fit to container.
+     */
+    focus(): void;
+    /**
+     * Get the underlying xterm.js Terminal instance.
+     */
+    getTerminal(): Terminal;
+    /**
+     * Get the execution context.
+     */
+    getContext(): CliExecutionContext;
+    /**
+     * Get the command processor registry.
+     */
+    getRegistry(): CliCommandProcessorRegistry;
+    /**
+     * Execute a command programmatically.
+     */
+    execute(command: string): Promise<void>;
+    /**
+     * Capture a snapshot of the current engine state.
+     * Can only be called after start().
+     */
+    snapshot(): CliEngineSnapshot;
+    /**
+     * Restore engine state from a snapshot.
+     * Note: If the target terminal has different dimensions than the snapshot
+     * source, the restored content may reflow differently.
+     */
+    private restoreSnapshot;
+    private getTerminalOptions;
+    private initializeTerminal;
+    private handleResize;
+    /**
+     * Call fitAddon.fit() only when the container has non-zero dimensions.
+     * Prevents xterm from reflowing to minimal columns when the container
+     * is hidden (e.g., via [hidden] or display:none on an ancestor).
+     */
+    private safeFit;
+    /**
+     * Chain write callbacks until the resize version stabilises.
+     * Only the very last callback (version match) applies the fix,
+     * so intermediate resize events cannot leave stale artefacts.
+     */
+    private deferResizeFix;
+    /**
+     * Wait until the container element has non-zero dimensions.
+     * xterm.js requires the host element to be laid out before open() is called.
+     */
+    private waitForLayout;
+}
+
+declare class CliServerConnection {
+    private readonly _config;
+    private readonly _backgroundServices?;
+    private _connected;
+    private _commands;
+    private _capabilities;
+    private _eventSocket;
+    onDisconnect?: () => void;
+    constructor(_config: CliServerConfig, _backgroundServices?: ICliBackgroundServiceRegistry | undefined);
+    get config(): CliServerConfig;
+    get connected(): boolean;
+    get commands(): CliServerCommandDescriptor[];
+    get capabilities(): CliServerCapabilities | null;
+    connect(): Promise<void>;
+    disconnect(): void;
+    fetchCommands(): Promise<CliServerCommandDescriptor[]>;
+    fetchCapabilities(): Promise<CliServerCapabilities | null>;
+    execute(command: CliProcessCommand): Promise<CliServerResponse>;
+    ping(): Promise<boolean>;
+    private connectEventSocket;
+    private connectEventSocketDirect;
+    private handleServerDisconnect;
+    private closeEventSocket;
+    private closeEventSocketDirect;
+    private httpFetch;
+    private normalizeUrl;
+    private toWebSocketUrl;
+}
+
+/**
+ * Execute a command on a specific server connection and render the response.
+ * Shared by both single-proxy and multi-proxy processors.
+ */
+declare function executeOnServer(connection: CliServerConnection, serverName: string, descriptor: CliServerCommandDescriptor, command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+/**
+ * Render a CliServerResponse to the terminal.
+ */
+declare function renderServerResponse(response: CliServerResponse, context: ICliExecutionContext): void;
+declare class CliServerProxyProcessor implements ICliCommandProcessor {
+    private readonly connection;
+    private readonly descriptor;
+    private readonly serverName;
+    command: string;
+    aliases?: string[];
+    description?: string;
+    version?: string;
+    metadata?: CliProcessorMetadata;
+    parameters?: ICliCommandParameterDescriptor[];
+    processors?: ICliCommandProcessor[];
+    constructor(connection: CliServerConnection, descriptor: CliServerCommandDescriptor, serverName: string);
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+}
+
+interface MultiProxyEntry {
+    serverName: string;
+    connection: CliServerConnection;
+    descriptor: CliServerCommandDescriptor;
+}
+interface DefaultServerProvider {
+    readonly defaultServer: string | null;
+}
+/**
+ * Proxy processor registered as a bare alias when the same command
+ * exists on multiple connected servers.  Dispatches to the default
+ * server when one is set, prompts the user otherwise, and falls back
+ * to the next reachable server when the preferred one is down.
+ */
+declare class CliServerMultiProxyProcessor implements ICliCommandProcessor {
+    private readonly entries;
+    private readonly provider;
+    command: string;
+    description?: string;
+    metadata?: CliProcessorMetadata;
+    parameters?: ICliCommandParameterDescriptor[];
+    processors?: ICliCommandProcessor[];
+    constructor(entries: MultiProxyEntry[], provider: DefaultServerProvider);
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+}
+
+declare const CliServerManager_TOKEN = "cli-server-manager";
+declare class CliServerManager implements DefaultServerProvider {
+    private readonly registry;
+    readonly connections: Map<string, CliServerConnection>;
+    private _logger?;
+    private _defaultServer;
+    private _backgroundServices?;
+    constructor(registry: ICliCommandProcessorRegistry);
+    get defaultServer(): string | null;
+    setDefaultServer(name: string | null): void;
+    connectAll(servers: CliServerConfig[], logger?: {
+        warn(msg: string): void;
+        info(msg: string): void;
+    }, backgroundServices?: ICliBackgroundServiceRegistry): Promise<void>;
+    reconnect(name: string): Promise<{
+        success: boolean;
+        commandCount: number;
+    }>;
+    getConnection(name: string): CliServerConnection | undefined;
+    private handleDisconnect;
+    private unregisterServerProcessors;
+    private unregisterBareAliases;
+    private registerProxyProcessors;
+    private registerBareAliases;
+}
+
+declare function createServerModule(): ICliModule;
+
+declare class CliServerCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    metadata: {
+        icon: CliIcon;
+        module: string;
+        sealed: boolean;
+    };
+    processors: ICliCommandChildProcessor[];
+    processCommand(_command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+}
+
+declare class CliSshCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    acceptsRawInput: boolean;
+    valueRequired: boolean;
+    metadata: CliProcessorMetadata;
+    parameters?: ICliCommandParameterDescriptor[];
+    private socket;
+    private context;
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    onData(data: string, context: ICliExecutionContext): Promise<void>;
+    onResize(cols: number, rows: number, _context: ICliExecutionContext): void;
+    onDispose(_context: ICliExecutionContext): void;
+    private resolveServer;
+    private executeInteractive;
+    private executeOneShot;
+    private buildShellUrl;
+    private cleanup;
+}
+
+/**
+ * Result of executing a command through the test harness.
+ */
+interface CliTestResult {
+    /** All stdout-equivalent lines (write, writeln, writeJson, etc.) */
+    stdout: string[];
+    /** All stderr-equivalent lines (writeError, writeWarning) */
+    stderr: string[];
+    /** The full stdout joined with newlines */
+    output: string;
+    /** The exit code of the last command (0 = success) */
+    exitCode: number | undefined;
+    /** Pipeline data produced by process.output() or auto-captured */
+    data: any;
+    /** Captured table outputs from writeTable() calls */
+    tables: {
+        headers: string[];
+        rows: string[][];
+    }[];
+    /** Captured list outputs from writeList() calls */
+    lists: string[][];
+}
+/**
+ * A headless CLI test harness that enables integration testing of the full
+ * command execution pipeline without xterm.js or DOM dependencies.
+ *
+ * Usage:
+ * ```typescript
+ * const harness = new CliTestHarness();
+ * harness.registerProcessor(new MyProcessor());
+ * const result = await harness.execute('mycommand --flag value');
+ * expect(result.output).toContain('expected text');
+ * ```
+ *
+ * For pipes:
+ * ```typescript
+ * const result = await harness.execute('echo hello world | grep hello');
+ * expect(result.output).toContain('hello world');
+ * ```
+ */
+declare class CliTestHarness {
+    readonly registry: CliCommandProcessorRegistry;
+    readonly executor: CliCommandExecutor;
+    readonly services: CliServiceContainer;
+    private readonly stateStoreManager;
+    private readonly processRegistry;
+    /** Current user session — set via setUserSession() */
+    userSession?: ICliUserSession;
+    /** Reader responses — set via setReaderResponses() for interactive commands */
+    private readerResponses;
+    constructor();
+    /**
+     * Register a service in the test container.
+     */
+    registerService(token: any, value: any): void;
+    /**
+     * Register a command processor. If the processor has an `initialize()`
+     * method, it will be called with a context wired to the harness services.
+     */
+    registerProcessor(processor: ICliCommandProcessor): void;
+    /**
+     * Register multiple command processors.
+     */
+    registerProcessors(processors: ICliCommandProcessor[]): void;
+    /**
+     * Initialize all registered processors that have an `initialize()` method.
+     * Call this after registering all services and processors.
+     */
+    initializeProcessors(): Promise<void>;
+    /**
+     * Set the active user session. Commands that check `context.userSession`
+     * will see this session.
+     */
+    setUserSession(session: ICliUserSession): void;
+    /**
+     * Queue reader responses for interactive prompts (readLine, readPassword, etc.).
+     * Responses are consumed in order.
+     */
+    setReaderResponses(...responses: any[]): void;
+    /**
+     * Execute a command string through the full parsing → execution → piping pipeline.
+     * Returns captured stdout, stderr, exit code, and pipeline data.
+     */
+    execute(command: string): Promise<CliTestResult>;
+    private createContext;
+}
+
+interface ICliWasmAccelerator {
+    /** Search for needle starting from (startRow, startCol). Returns [row, col] or [-1, -1]. */
+    textSearch(text: string, needle: string, startRow: number, startCol: number, caseSensitive: boolean, wrap: boolean): [number, number];
+    /** Replace all occurrences. Returns { count, text }. */
+    textReplaceAll(text: string, needle: string, replacement: string, caseSensitive: boolean): {
+        count: number;
+        text: string;
+    };
+    /** Filter candidates by prefix (case-insensitive), return sorted matches. */
+    prefixMatch(candidates: string[], prefix: string): string[];
+    /** Longest common prefix of the given strings. */
+    commonPrefix(strings: string[]): string;
+}
+
+/**
+ * Pure-JS implementation of ICliWasmAccelerator.
+ * Used as the fallback when the WASM module is not available.
+ */
+declare class JsFallbackAccelerator implements ICliWasmAccelerator {
+    textSearch(text: string, needle: string, startRow: number, startCol: number, caseSensitive: boolean, wrap: boolean): [number, number];
+    textReplaceAll(text: string, needle: string, replacement: string, caseSensitive: boolean): {
+        count: number;
+        text: string;
+    };
+    prefixMatch(candidates: string[], prefix: string): string[];
+    commonPrefix(strings: string[]): string;
+}
+
+/**
+ * Attempt to load the WASM accelerator module.
+ * Searches for the .wasm binary at common asset paths.
+ * Falls back silently to JsFallbackAccelerator on failure.
+ * Safe to call multiple times — only the first call performs the load.
+ *
+ * @param wasmUrl Optional explicit URL to the .wasm binary.
+ */
+declare function initWasmAccelerator(wasmUrl?: string): Promise<ICliWasmAccelerator>;
+/**
+ * Synchronously return the cached accelerator.
+ * If not yet initialized, creates a JsFallbackAccelerator immediately.
+ * Intended for use in hot paths where async loading is not acceptable.
+ */
+declare function getAccelerator(): ICliWasmAccelerator;
+/**
+ * Returns true if the WASM accelerator was loaded successfully.
+ * Returns false if using the JS fallback.
+ */
+declare function isWasmAccelerated(): boolean;
+
+export { API_VERSION, type ActiveInputRequest, type ActiveInputRequestType, CLi_Name_Art, CapturingTerminalWriter, type CdnSourceName, CliAliasCommandProcessor, CliArgsParser, CliBackgroundServiceRegistry_TOKEN, CliBase64CommandProcessor, CliBoot, CliCalCommandProcessor, CliCaptureCommandProcessor, CliClearCommandProcessor, CliClipboard, CliClipboardCommandProcessor, CliColorCommandProcessor, CliCommandExecutionContext, CliCommandExecutor, CliCommandHistory, CliCommandHistory_TOKEN, CliCommandProcessorRegistry, CliConfigureCommandProcessor, CliConvertCommandProcessor, CliDebugCommandProcessor, CliDefaultPingServerService, CliDiffCommandProcessor, CliDragDropService, CliEchoCommandProcessor, CliEngine, type CliEngineOptions, CliEnvCommandProcessor, CliEnvironment, CliEvalCommandProcessor, CliExecutionContext, type CliExecutionContextDeps, CliExecutionProcess, CliExportCommandProcessor, CliFeedbackCommandProcessor, CliFontSizeCommandProcessor, CliHashCommandProcessor, CliHelpCommandProcessor, CliHexCommandProcessor, CliHistoryCommandProcessor, CliHotKeysCommandProcessor, CliInputReader, type CliInputReaderHost, CliJsonCommandProcessor, CliJwtCommandProcessor, CliKeyValueStore, CliKillCommandProcessor, CliLogger, CliLoremCommandProcessor, CliModuleRegistry_TOKEN, CliNanoCommandProcessor, CliOpenCommandProcessor, CliPackageManagerService, CliPackageManagerService_TOKEN, CliPackagesCommandProcessor, CliPingCommandProcessor, CliProcessRegistry, CliProcessRegistry_TOKEN, CliProcessorsRegistry_TOKEN, CliPsCommandProcessor, CliRandomCommandProcessor, CliScreenCommandProcessor, CliSeqCommandProcessor, CliServerCommandProcessor, CliServerConnection, CliServerManager, CliServerManager_TOKEN, CliServerMultiProxyProcessor, CliServerProxyProcessor, CliServiceContainer, CliServicesCommandProcessor, CliSleepCommandProcessor, CliSnippetCommandProcessor, CliSshCommandProcessor, CliStateStore, CliStateStoreManager, CliStateStoreManager_TOKEN, CliTerminalProgressBar, CliTerminalSpinner, CliTerminalTextAnimator, CliTerminalWriter, CliTestHarness, type CliTestResult, CliThemeCommandProcessor, CliTimeCommandProcessor, CliTimestampCommandProcessor, CliUnAliasCommandProcessor, CliUnameCommandProcessor, CliUnsetCommandProcessor, CliUptimeCommandProcessor, CliUrlCommandProcessor, CliVersionCommandProcessor, type CliWelcomeMessageConfig, CliYesCommandProcessor, CommandParser, type CommandParserOutput, type CommandPart, type ConfigureState, type DefaultServerProvider, type DiffLine, type DiffType, type ICliEnvironment, ICliEnvironment_TOKEN, type ICliExecutionHost, ICliPingServerService_TOKEN, type ICliStateStoreManager, type ICliWasmAccelerator, JsFallbackAccelerator, LIBRARY_VERSION, type MultiProxyEntry, OverlayAddon, type ParsedArg, type ParsedToken, ProcessExitedError, ScriptLoaderService, type ThemeState, builtinProcessors, computeDiff, contextGlobalParameter, createServerModule, executeOnServer, formatDiff, getAccelerator, getCliNameArt, getGreetingBasedOnTime, groupBy, helpGlobalParameter, hotkeysInfo, initWasmAccelerator, isWasmAccelerated, miscProcessors, openLink, reconcileArgs, renderServerResponse, systemProcessors, themeInfos, themes, versionGlobalParameter, welcomeModule };