@qodalis/cli-core 2.0.0-beta.17 → 2.0.0-beta.18

package/public-api.d.ts

@@ -22,9 +22,18 @@ type CliProcessCommand = {
      */
     rawCommand: string;
     /**
-     * The value of the command
+     * The value of the command: the text after the command (and sub-command)
+     * words, flags removed, as typed (quotes included). Prefer `positionals`
+     * to read arguments.
      */
     value?: string;
+    /**
+     * The positional arguments, split like a shell: quotes removed
+     * (`"my file.txt"` is one argument), backslash escapes applied, flags
+     * excluded. `cat "a b.txt" c.txt` has `['a b.txt', 'c.txt']`. Set by the
+     * engine for every command; empty when there are none.
+     */
+    positionals?: string[];
     /**
      * The arguments that were entered
      */
@@ -366,6 +375,11 @@ interface ICliCommandExecutorService {
      * @param context The context in which the command is executed
      */
     executeCommand(command: string, context: ICliExecutionContext): Promise<void>;
+    /**
+     * Run a command line and return its output as text instead of showing it
+     * (as `$(...)` does); its errors and warnings are still shown.
+     */
+    capture?(command: string, context: ICliExecutionContext): Promise<string>;
     /**
      * Register a global parameter handler.
      * Global parameters (e.g. --help, --version) are evaluated for every
@@ -539,8 +553,22 @@ interface ICliKeyValueStore {
  *
  * State is a plain object (`Record<string, any>`). Updates are shallow-merged
  * (top-level keys are replaced, nested objects are not deep-merged).
- * `getState()` returns a snapshot — mutating the returned object has no effect;
- * always use `updateState()` to change state.
+ * `getState()` returns a shallow copy: assigning its top-level keys has no
+ * effect, and nested objects must not be mutated in place either; always use
+ * `updateState()` to change state.
+ *
+ * Saved state is loaded once, before the store's command first runs (or by
+ * `initialize()`), and merged over the initial state, so keys added to the
+ * initial state later are present. Changes are saved with `persist()`, or
+ * after every change with `autoPersist`.
+ *
+ * A store is global by default: one saved state shared by every terminal and
+ * tab of the browser. A save writes only the top-level keys this terminal
+ * changed (merged into what is saved, under a cross-tab lock), so terminals
+ * changing different keys never overwrite each other; for the same key the
+ * last save wins. Changes saved elsewhere are applied here, except keys
+ * changed here and not saved yet. A store with `scope: 'session'` belongs to
+ * one terminal and is never saved.
  */
 interface ICliStateStore {
     /**
@@ -555,6 +583,17 @@ interface ICliStateStore {
      * @param newState Partial state to merge with the current state
      */
     updateState(newState: Partial<CliState>): void;
+    /**
+     * Change the state from its latest saved value and save it, atomically
+     * (under a lock shared by all tabs): use it for read-modify-write changes
+     * such as adding an item to a list, so terminals changing the same key at
+     * once never lose each other's change.
+     *
+     * ```ts
+     * await context.state.update((s) => ({ todos: [...s.todos, todo] }));
+     * ```
+     */
+    update(change: (state: CliState) => Partial<CliState>): Promise<void>;
     /**
      * Select a specific property or computed value from the state.
      * @param selector A function to project a slice of the state.
@@ -572,13 +611,16 @@ interface ICliStateStore {
      */
     reset(): void;
     /**
-     * Persist the state to storage.
+     * Persist the state to storage (does nothing when no storage is available).
      */
     persist(): Promise<void>;
     /**
-     * Initialize the state from storage.
+     * Load the saved state, once: later calls resolve when that first load
+     * is done and keep changes made since.
      */
     initialize(): Promise<void>;
+    /** Read the saved state again, replacing the current state. */
+    reload?(): Promise<void>;
 }
 
 /** Ownership metadata attached to files, directories, or other resources */
@@ -593,96 +635,159 @@ declare const DEFAULT_FILE_PERMISSIONS = "rw-r--r--";
 /** Default directory permissions: rwxr-xr-x (755) */
 declare const DEFAULT_DIR_PERMISSIONS = "rwxr-xr-x";
 
+/** A single audit log entry */
+interface ICliAuditEntry {
+    /** Entry id (server-assigned in server mode) */
+    id?: string;
+    /** When the event occurred */
+    timestamp: number;
+    /** Event type (e.g., 'login', 'logout', 'login_failed') */
+    event: string;
+    /** Username involved */
+    username: string;
+    /** Optional additional details */
+    details?: string;
+    /** Id of the user the entry is about, when known */
+    userId?: string;
+    /** The user who performed the action, when different from `username` */
+    actor?: string;
+    /** Id of the acting user, when different from the subject */
+    actorId?: string;
+    /** Extra data (e.g. remote address) */
+    metadata?: Record<string, unknown>;
+}
+/** Service for persistent audit logging */
+interface ICliAuditService {
+    /** Log an audit entry (timestamp is added automatically) */
+    log(entry: Omit<ICliAuditEntry, 'timestamp'>): Promise<void>;
+    /** Retrieve audit entries with optional filtering */
+    getEntries(options?: {
+        limit?: number;
+        event?: string;
+        username?: string;
+    }): Promise<ICliAuditEntry[]>;
+    /** Clear all audit entries */
+    clear(): Promise<void>;
+}
+
 /**
- * Token for the CLI user session service.
- */
-declare const ICliUserSessionService_TOKEN = "cli-user-session-service";
-/**
- * Token for the CLI users store service.
- */
-declare const ICliUsersStoreService_TOKEN = "cli-users-store-service";
-/**
- * Token for the CLI groups store service.
- */
-declare const ICliGroupsStoreService_TOKEN = "cli-groups-store-service";
-/**
- * Token for the CLI auth service.
- */
-declare const ICliAuthService_TOKEN = "cli-auth-service";
-/**
- * Token for registering completion providers via module services (multi: true).
- */
-declare const ICliCompletionProvider_TOKEN = "cli-completion-provider";
-/**
- * Token for the drag-and-drop service.
- */
-declare const ICliDragDropService_TOKEN = "cli-drag-drop-service";
-/**
- * Token for the file transfer service.
- */
-declare const ICliFileTransferService_TOKEN = "cli-file-transfer-service";
-/**
- * Token for the translation service.
- */
-declare const ICliTranslationService_TOKEN = "cli-translation-service";
-/**
- * Token for the permission service.
- */
-declare const ICliPermissionService_TOKEN = "cli-permission-service";
-/**
- * Token for the file picker provider.
- */
-declare const ICliFilePickerProvider_TOKEN = "cli-file-picker-provider";
-/**
- * Token for the HTTP client service.
- */
-declare const ICliHttpClient_TOKEN = "cli-http-client";
-/**
- * Token for the user event service (lifecycle events).
+ * A permission an extension uses, declared so tools (`perms --list`,
+ * `groupmod --grant` completion, docs) can show it. Declaring is optional:
+ * any `resource:action` string can be granted and checked.
  */
-declare const ICliUserEventService_TOKEN = "cli-user-event-service";
+interface CliPermissionDefinition {
+    /** Permission string, `resource:action` (e.g. `files:chown`). */
+    name: string;
+    /** Human readable description. */
+    description?: string;
+    /** Module that declared it (filled in at registration). */
+    module?: string;
+}
+/** Registry of permissions declared by modules (`ICliModule.permissions`). */
+interface ICliPermissionRegistry {
+    register(definitions: CliPermissionDefinition[], module?: string): void;
+    list(): CliPermissionDefinition[];
+    get(name: string): CliPermissionDefinition | undefined;
+    /** Remove the permissions registered by `module` (when it is unloaded). */
+    unregister?(module: string): void;
+}
+/** The identity checks are made against. */
+interface ICliPrincipal {
+    /** User id */
+    id: string;
+    /** Login name (used as file owner) */
+    name: string;
+    /** Group (role) names */
+    groups: string[];
+    /** Effective permissions (union of the groups' permissions) */
+    permissions: string[];
+}
+/** rwx-style protected resource (files, directories, or anything an extension owns). */
+interface ICliProtectedResource {
+    ownership?: ICliOwnership;
+    /** 9-char mode string, e.g. `rwxr-x---` */
+    permissions?: string;
+}
+type CliAccessAction = 'read' | 'write' | 'execute';
 /**
- * Token for the audit service (persistent event logging).
+ * Authorization service. Provided by an auth module (the users module provides
+ * one in local and in server mode). Extensions should use the helpers
+ * {@link cliAuthorize} / {@link cliCanAccess}, which allow everything when no
+ * authorization service is registered.
  */
-declare const ICliAuditService_TOKEN = "cli-audit-service";
+interface ICliAuthorizationService {
+    /** The signed-in principal, or undefined when nobody is signed in. */
+    getPrincipal(): ICliPrincipal | undefined;
+    /** Does the current principal hold `permission` (wildcards honoured)? */
+    can(permission: string): boolean;
+    /**
+     * rwx check on a resource for the current principal (owner / group / other).
+     * Principals holding `*` or any of `bypassPermissions` are always allowed.
+     * Resources without a mode or ownership are allowed.
+     */
+    canAccess(resource: ICliProtectedResource, action: CliAccessAction, bypassPermissions?: string[]): boolean;
+}
+/** Thrown when an operation is not permitted. The message is user facing. */
+declare class CliAccessDeniedError extends Error {
+    readonly code = "EACCES";
+    constructor(message?: string);
+}
+/** True for {@link CliAccessDeniedError} (also across bundle copies). */
+declare function isCliAccessDeniedError(error: unknown): error is CliAccessDeniedError;
 /**
- * Token for the authorization service ({@link ICliAuthorizationService}).
- * Provided by an auth module (e.g. `@qodalis/cli-users`); absent otherwise.
+ * Check a permission for the current principal. Returns `true` when no
+ * authorization service is registered (no auth module loaded).
  */
-declare const ICliAuthorizationService_TOKEN = "cli-authorization-service";
+declare function cliAuthorize(context: Pick<ICliExecutionContext, 'services'>, permission: string): boolean;
 /**
- * Token for the permission registry ({@link ICliPermissionRegistry}).
- * Always provided by the CLI engine.
+ * rwx check for the current principal. Returns `true` when no authorization
+ * service is registered.
  */
-declare const ICliPermissionRegistry_TOKEN = "cli-permission-registry";
+declare function cliCanAccess(context: Pick<ICliExecutionContext, 'services'>, resource: ICliProtectedResource, action: CliAccessAction, bypassPermissions?: string[]): boolean;
 /**
- * Token for the sessions service ({@link ICliSessionsService}).
+ * Reference rwx evaluation shared by implementations of
+ * {@link ICliAuthorizationService.canAccess}.
  */
-declare const ICliSessionsService_TOKEN = "cli-sessions-service";
+declare function cliEvaluateAccess(principal: ICliPrincipal | undefined, resource: ICliProtectedResource, action: CliAccessAction, bypassPermissions?: string[]): boolean;
+
 /**
- * Token for the persistent key-value store used by modules (setup state, etc.).
+ * Context passed to completion providers describing the current input state.
  */
-declare const ICliKeyValueStore_TOKEN = "cli-key-value-store";
-
+interface ICliCompletionContext {
+    /** Full current line text */
+    input: string;
+    /** Cursor position in the line */
+    cursor: number;
+    /** The token (word) being completed at the cursor position */
+    token: string;
+    /** Start index of the token in the input string */
+    tokenStart: number;
+    /** Index of the token among all tokens (0 = command, 1+ = arguments) */
+    tokenIndex: number;
+    /** All tokens parsed from the input */
+    tokens: string[];
+}
 /**
- * Abstract permission service for checking rwx permissions on resources.
- * The default implementation lives in @qodalis/cli-users; consumers can
- * replace it via the DI container.
+ * Provides tab-completion candidates for CLI input.
+ * Plugins can register providers to extend completion (e.g. file paths, custom values).
  */
-interface ICliPermissionService {
+interface ICliCompletionProvider {
     /**
-     * Check whether a user may perform an action on a resource.
-     * @param user        The acting user.
-     * @param action      The requested operation.
-     * @param ownership   Owner/group of the resource.
-     * @param permissions Permission string (e.g. "rwxr-xr-x").
-     * @returns true if allowed.
+     * Priority order. Lower values are checked first.
+     * Built-in defaults: 100 (commands), 200 (parameters).
+     * Plugins should use lower values (e.g. 50) to take precedence for specific commands.
      */
-    check(user: ICliUser, action: 'read' | 'write' | 'execute', ownership: ICliOwnership, permissions: string): boolean;
-    /** Parse octal (e.g. "755") to a permission string (e.g. "rwxr-xr-x"). */
-    parseOctal(octal: string): string;
-    /** Convert a permission string (e.g. "rwxr-xr-x") to octal (e.g. "755"). */
-    toOctal(permissions: string): string;
+    priority: number;
+    /**
+     * Return completion candidates for the current input context.
+     * Return an empty array if this provider does not apply.
+     */
+    getCompletions(context: ICliCompletionContext): string[] | Promise<string[]>;
+}
+
+interface ICliDragDropService {
+    /** Emits an array of dropped File objects each time files are dropped onto the terminal */
+    readonly onFileDrop: Observable<File[]>;
 }
 
 /**
@@ -749,591 +854,733 @@ interface ICliFilePickerProvider {
 }
 
 /**
- * Represents an option for the readSelect and readSelectInline prompts.
+ * Represents an entry in a file listing.
  */
-interface CliSelectOption {
-    /** Display text shown to the user */
-    label: string;
-    /** Value returned when this option is selected */
-    value: string;
-    /** Optional description shown as dimmed italic text after the label */
-    description?: string;
-    /** Group name — options sharing the same group are displayed under a group header */
-    group?: string;
-    /** When true, the option is visible but cannot be selected (rendered dimmed) */
-    disabled?: boolean;
+interface ICliFileEntry {
+    name: string;
+    type: 'file' | 'directory';
+    size: number;
+    modified: string;
 }
+
 /**
- * Represents an option for the readMultiSelect prompt.
+ * Abstraction for file transfer operations.
+ * Default implementation uses browser-native APIs (file picker, download dialog).
+ * @qodalis/cli-files overrides with virtual FS backed by IndexedDB.
  */
-interface CliMultiSelectOption extends CliSelectOption {
-    /** Whether the option is pre-selected */
-    checked?: boolean;
+interface ICliFileTransferService {
+    readFile(path: string): Promise<string | null>;
+    writeFile(path: string, content: string): Promise<void>;
+    listFiles(path: string): Promise<ICliFileEntry[]>;
+    exists(path: string): Promise<boolean>;
+    downloadToBrowser(filename: string, content: string | Blob): void;
+    uploadFromBrowser(accept?: string): Promise<{
+        name: string;
+        content: string;
+    } | null>;
 }
+
 /**
- * Options for readLine input.
+ * Options for HTTP client requests.
+ * Extends standard RequestInit with convenience fields.
  */
-interface CliLineOptions {
-    /**
-     * Pre-filled default value. Shown in the buffer when the prompt opens.
-     * The cursor starts at the end of the default text.
-     */
-    default?: string;
+interface CliHttpRequestOptions extends Omit<RequestInit, 'method' | 'body'> {
     /**
-     * Validation function called on Enter.
-     * Return an error message string to reject the input and display the error.
-     * Return null to accept the input.
+     * Request timeout in milliseconds. When set, the request is automatically
+     * aborted after this duration. Combines with any existing abort signal.
      */
-    validate?: (value: string) => string | null;
-    /** Placeholder text shown dimmed when the buffer is empty */
-    placeholder?: string;
-}
-/**
- * Options for readSelect and readSelectInline.
- */
-interface CliSelectOptions {
-    /** Pre-select an option by its value */
-    default?: string;
-    /** Enable type-to-filter. When true, printable keystrokes filter the option list. Default: false. */
-    searchable?: boolean;
-    /** Callback invoked each time the highlighted option changes */
-    onChange?: (value: string) => void;
-}
-/**
- * Options for readMultiSelect.
- */
-interface CliMultiSelectOptions {
-    /** Enable type-to-filter. When true, printable keystrokes filter the option list. Default: false. */
-    searchable?: boolean;
-    /** Callback invoked each time the set of checked options changes */
-    onChange?: (values: string[]) => void;
-}
-/**
- * Options for readNumber input.
- */
-interface CliNumberOptions {
-    /** Minimum allowed value */
-    min?: number;
-    /** Maximum allowed value */
-    max?: number;
-    /** Pre-filled default value */
-    default?: number;
-}
-/**
- * Options for readDate input.
- */
-interface CliDateOptions {
-    /**
-     * Date format string. Supported tokens: YYYY (4-digit year), MM (2-digit month),
-     * DD (2-digit day). Separators can be `-`, `/`, or `.`.
-     * @default 'YYYY-MM-DD'
-     */
-    format?: string;
-    /** Minimum allowed date in the same format as `format` */
-    min?: string;
-    /** Maximum allowed date in the same format as `format` */
-    max?: string;
-    /** Pre-filled default value */
-    default?: string;
+    timeout?: number;
 }
 /**
- * Provides interactive input reading from the terminal.
- * All methods resolve with `null` when the user aborts (Ctrl+C or Escape).
+ * HTTP client for making requests from command processors.
+ *
+ * Automatically merges the command's abort signal so that requests are
+ * cancelled when the user presses Ctrl+C. Provides typed convenience
+ * methods for common HTTP verbs as well as a raw `fetch()` for cases
+ * that need full Response access (streaming, progress, etc.).
+ *
+ * Available on the execution context as `context.http`.
+ *
+ * @example
+ * ```ts
+ * // Typed JSON response
+ * const users = await context.http.get<User[]>('https://api.example.com/users');
+ *
+ * // POST with body
+ * await context.http.post('https://api.example.com/users', { name: 'John' });
+ *
+ * // Raw fetch for streaming
+ * const response = await context.http.fetch('https://example.com/file.zip');
+ * const reader = response.body?.getReader();
+ * ```
  */
-interface ICliInputReader {
-    /**
-     * Read a line of text input.
-     * @param prompt - The prompt text displayed to the user
-     * @param options - Optional configuration for default value, validation, and placeholder
-     * @returns The entered text, or null if aborted
-     */
-    readLine(prompt: string, options?: CliLineOptions): Promise<string | null>;
+interface ICliHttpClient {
     /**
-     * Read a password (masked input).
-     * @param prompt - The prompt text displayed to the user
-     * @returns The entered password, or null if aborted
+     * Make a raw HTTP request. Returns the full Response object for cases
+     * that need streaming, headers, or status inspection.
+     * The command's abort signal is automatically merged.
      */
-    readPassword(prompt: string): Promise<string | null>;
+    fetch(url: string, init?: RequestInit): Promise<Response>;
     /**
-     * Read a yes/no confirmation.
-     * @param prompt - The prompt text displayed to the user
-     * @param defaultValue - Default value when Enter is pressed without input
-     * @returns true for yes, false for no, or null if aborted
+     * HTTP GET request. Returns the parsed JSON response body.
      */
-    readConfirm(prompt: string, defaultValue?: boolean): Promise<boolean | null>;
+    get<T = any>(url: string, options?: CliHttpRequestOptions): Promise<T>;
     /**
-     * Read a selection from a vertical list of options.
-     * @param prompt - The prompt text displayed to the user
-     * @param options - Array of options to choose from
-     * @param selectOptions - Optional configuration for default, search, onChange
-     * @returns The selected option's value, or null if aborted
+     * HTTP POST request. Automatically serializes the body as JSON
+     * (unless body is FormData, Blob, string, or ArrayBuffer).
+     * Returns the parsed JSON response body.
      */
-    readSelect(prompt: string, options: CliSelectOption[], selectOptions?: CliSelectOptions): Promise<string | null>;
+    post<T = any>(url: string, body?: any, options?: CliHttpRequestOptions): Promise<T>;
     /**
-     * Read a selection from an inline horizontal list.
-     * @param prompt - The prompt text displayed to the user
-     * @param options - Array of options to choose from
-     * @param selectOptions - Optional configuration for default, search, onChange
-     * @returns The selected option's value, or null if aborted
+     * HTTP PUT request. Automatically serializes the body as JSON.
+     * Returns the parsed JSON response body.
      */
-    readSelectInline(prompt: string, options: CliSelectOption[], selectOptions?: CliSelectOptions): Promise<string | null>;
+    put<T = any>(url: string, body?: any, options?: CliHttpRequestOptions): Promise<T>;
     /**
-     * Read multiple selections from a checkbox list.
-     * @param prompt - The prompt text displayed to the user
-     * @param options - Array of options with optional pre-checked state
-     * @param selectOptions - Optional configuration for search, onChange
-     * @returns Array of selected option values, or null if aborted
+     * HTTP PATCH request. Automatically serializes the body as JSON.
+     * Returns the parsed JSON response body.
      */
-    readMultiSelect(prompt: string, options: CliMultiSelectOption[], selectOptions?: CliMultiSelectOptions): Promise<string[] | null>;
+    patch<T = any>(url: string, body?: any, options?: CliHttpRequestOptions): Promise<T>;
     /**
-     * Read a number input.
-     * @param prompt - The prompt text displayed to the user
-     * @param options - Optional configuration for min, max, and default value
-     * @returns The entered number, or null if aborted
+     * HTTP DELETE request. Returns the parsed JSON response body (if any).
      */
-    readNumber(prompt: string, options?: CliNumberOptions): Promise<number | null>;
+    delete<T = any>(url: string, options?: CliHttpRequestOptions): Promise<T>;
     /**
-     * Read a date input with format validation.
-     * @param prompt - The prompt text displayed to the user
-     * @param options - Optional configuration for format, min/max range, default
-     * @returns The date string in the specified format, or null if aborted
+     * HTTP HEAD request. Returns the full Response (no body parsing).
      */
-    readDate(prompt: string, options?: CliDateOptions): Promise<string | null>;
+    head(url: string, options?: CliHttpRequestOptions): Promise<Response>;
     /**
-     * Read file(s) via the environment's file picker dialog.
-     * @param prompt - The prompt text displayed to the user
-     * @param options - Optional configuration for multiple, accept filter, directory mode
-     * @returns Array of selected files with content, or null if cancelled/unsupported
+     * HTTP OPTIONS request. Returns the parsed JSON response body.
      */
-    readFile(prompt: string, options?: CliFilePickerOptions): Promise<CliFileResult[] | null>;
-}
-
-/**
- * Context passed to completion providers describing the current input state.
- */
-interface ICliCompletionContext {
-    /** Full current line text */
-    input: string;
-    /** Cursor position in the line */
-    cursor: number;
-    /** The token (word) being completed at the cursor position */
-    token: string;
-    /** Start index of the token in the input string */
-    tokenStart: number;
-    /** Index of the token among all tokens (0 = command, 1+ = arguments) */
-    tokenIndex: number;
-    /** All tokens parsed from the input */
-    tokens: string[];
+    options<T = any>(url: string, options?: CliHttpRequestOptions): Promise<T>;
 }
 /**
- * Provides tab-completion candidates for CLI input.
- * Plugins can register providers to extend completion (e.g. file paths, custom values).
+ * Error thrown by `ICliHttpClient` JSON helpers (`get`, `post`, `put`,
+ * `patch`, `delete`, `options`) when the server responds with a non-2xx status.
+ *
+ * Exposes the HTTP status so callers can react to specific responses
+ * (for example, clearing a stored session token on `401`).
+ *
+ * @example
+ * ```ts
+ * try {
+ *     await context.http.get(url);
+ * } catch (e) {
+ *     if (e instanceof CliHttpError && e.status === 401) {
+ *         // token expired or revoked
+ *     }
+ * }
+ * ```
  */
-interface ICliCompletionProvider {
-    /**
-     * Priority order. Lower values are checked first.
-     * Built-in defaults: 100 (commands), 200 (parameters).
-     * Plugins should use lower values (e.g. 50) to take precedence for specific commands.
-     */
-    priority: number;
-    /**
-     * Return completion candidates for the current input context.
-     * Return an empty array if this provider does not apply.
-     */
-    getCompletions(context: ICliCompletionContext): string[] | Promise<string[]>;
+declare class CliHttpError extends Error {
+    /** HTTP status code of the failed response */
+    readonly status: number;
+    /** HTTP status text of the failed response */
+    readonly statusText: string;
+    /** Parsed JSON error body, when the server returned one */
+    readonly body?: unknown | undefined;
+    constructor(message: string, 
+    /** HTTP status code of the failed response */
+    status: number, 
+    /** HTTP status text of the failed response */
+    statusText?: string, 
+    /** Parsed JSON error body, when the server returned one */
+    body?: unknown | undefined);
 }
 
-interface ICliProgressBar {
-    /**
-     * Indicates if the progress bar is running
-     */
-    isRunning: boolean;
-    /**
-     * Show the progress bar
-     */
-    show: (text?: string) => void;
-    /**
-     * Hide the progress bar
-     */
-    hide: () => void;
+/** A sign-in session as listed by {@link ICliSessionsService}. Never carries a token. */
+interface ICliSessionInfo {
+    id: string;
+    userId: string;
+    userName: string;
+    createdAt: number;
+    lastActivity: number;
+    /** When the session expires if idle; undefined when there is no timeout */
+    expiresAt?: number;
+    /** True for the caller's own session */
+    current?: boolean;
+    metadata?: {
+        userAgent?: string;
+        remoteAddress?: string;
+        [key: string]: unknown;
+    };
 }
 /**
- * Represents a spinner for the CLI
+ * Lists and revokes sign-in sessions. Implemented locally (sessions of this
+ * browser) and by servers (all sessions). Used by `sessions` / `session-kick`.
  */
-interface ICliSpinner extends ICliProgressBar {
-    /**
-     * Set the text of the spinner
-     * @param text The text to set
-     */
-    setText: (text: string) => void;
-}
-type CliPercentageProgressBarUpdateValueOptions = {
-    /**
-     * The type of update to perform
-     * @default 'replace'
-     */
-    type?: 'replace' | 'increment';
-};
-/**
- * Represents a progress bar for the CLI
+interface ICliSessionsService {
+    /** All sessions visible to the caller */
+    list(): Promise<ICliSessionInfo[]>;
+    /** Revoke a session by id */
+    revoke(sessionId: string, reason?: string): Promise<void>;
+    /** Revoke every session of a user (optionally keeping one) */
+    revokeUser(userId: string, options?: {
+        exceptSessionId?: string;
+        reason?: string;
+    }): Promise<void>;
+}
+
+/** Represents a user lifecycle event */
+interface ICliUserEvent {
+    /** The type of event that occurred */
+    type: 'login' | 'logout' | 'login_failed' | 'user_created' | 'user_deleted' | 'user_updated' | 'password_changed' | 'user_switched' | 'user_disabled' | 'user_enabled' | 'group_created' | 'group_updated' | 'group_deleted' | 'group_member_added' | 'group_member_removed' | 'session_revoked' | 'audit_cleared';
+    /** The user involved in the event (for group events: the acting user) */
+    user: ICliUser;
+    /** The acting user's name, when different from `user` (e.g. an admin) */
+    actor?: string;
+    /** When the event occurred */
+    timestamp: number;
+    /** Optional additional details */
+    details?: string;
+    /** `user_updated`: the user's name before a rename (set only when the name changed) */
+    previousName?: string;
+}
+/** Service that emits user lifecycle events for plugins to subscribe to */
+interface ICliUserEventService {
+    /** Observable stream of user events */
+    readonly events$: Observable<ICliUserEvent>;
+    /** Emit a user event */
+    emit(event: ICliUserEvent): void;
+}
+
+/**
+ * Represents a service that manages user sessions in the CLI
  */
-interface ICliPercentageProgressBar extends ICliProgressBar {
-    /**
-     * Update the progress of the progress bar.
-     * @param progress The progress value (0–100). Values outside this range are clamped.
-     * @param options Optional: update type ('replace' or 'increment')
-     */
-    update: (progress: number, options?: CliPercentageProgressBarUpdateValueOptions) => void;
-    /**
-     * Complete the progress bar
-     * @returns void
-     */
-    complete: () => void;
-    /**
-     * Set the text of the spinner
-     * @param text The text to set
-     */
-    setText: (text: string) => void;
+interface ICliUserSessionService {
+    /** Gets the current user session as a reactive stream */
+    getUserSession(): Observable<ICliUserSession | undefined>;
+    /** Sets the current user session */
+    setUserSession(session: ICliUserSession): Promise<void>;
+    /** Clears the current session (logout) */
+    clearSession(): Promise<void>;
+    /** Persists the current session to storage */
+    persistSession(): Promise<void>;
+    /** Restores a session from storage (called on boot) */
+    restoreSession(): Promise<ICliUserSession | undefined>;
 }
-type CliTextAnimatorOptions = {
+/**
+ * Represents a service that manages users in the CLI
+ */
+interface ICliUsersStoreService {
+    /** Gets users with optional filtering and pagination */
+    getUsers(options?: {
+        query?: string;
+        skip?: number;
+        take?: number;
+    }): Observable<ICliUser[]>;
+    /** Creates a new user */
+    createUser(user: CliAddUser): Promise<ICliUser>;
+    /** Gets a user by id, name, or email */
+    getUser(id: string): Observable<ICliUser | undefined>;
+    /** Updates an existing user */
+    updateUser(id: string, updates: CliUpdateUser): Promise<ICliUser>;
+    /** Deletes a user by id */
+    deleteUser(id: string): Promise<void>;
+}
+/**
+ * Represents a service that manages groups in the CLI
+ */
+interface ICliGroupsStoreService {
+    /** Gets all groups */
+    getGroups(): Observable<ICliGroup[]>;
+    /** Gets a group by id or name */
+    getGroup(id: string): Observable<ICliGroup | undefined>;
+    /** Creates a new group (role), optionally with permissions */
+    createGroup(name: string, description?: string, permissions?: string[]): Promise<ICliGroup>;
+    /** Updates a group's description and/or permissions (by id or name) */
+    updateGroup(id: string, updates: {
+        description?: string;
+        permissions?: string[];
+    }): Promise<ICliGroup>;
+    /** Adds a user (id or name) to a group (id or name) */
+    addMember(groupId: string, userId: string): Promise<void>;
+    /** Removes a user (id or name) from a group (id or name) */
+    removeMember(groupId: string, userId: string): Promise<void>;
+    /** Deletes a group by id */
+    deleteGroup(id: string): Promise<void>;
+    /** Gets all users that belong to a group */
+    getGroupMembers(groupId: string): Observable<ICliUser[]>;
+}
+/**
+ * Represents a service that handles authentication in the CLI
+ */
+interface ICliAuthService {
     /**
-     * The speed of the animation
-     * @default 100
+     * Authenticates a user and returns a session. `password` may be omitted
+     * only when the implementation allows passwordless sign-in.
      */
-    speed?: number;
+    login(username: string, password?: string): Promise<ICliUserSession>;
+    /** Ends the current session (the CLI is left signed out) */
+    logout(): Promise<void>;
     /**
-     * The text will be removed after typing
+     * Switch to another user (`su`). Requires the target's password unless
+     * the caller may skip it (implementation-defined, e.g. `users:update`).
+     * Goes through the same lockout, events and audit as `login`.
      */
-    removeAfterTyping?: boolean;
-};
-interface ICliTextAnimator extends ICliProgressBar {
+    switchUser?(username: string, password?: string): Promise<ICliUserSession>;
     /**
-     * Show animated text in a typing and erasing effect.
-     * @param text The text to animate
-     * @param options Optional: speed (ms per character), removeAfterTyping
-     * @returns A promise that resolves when the animation completes
+     * Sets or updates a user's password.
+     * @param currentPassword The user's current password, when changing one's own
+     * password. Server-backed implementations forward it so the server can
+     * re-check it; local implementations may ignore it.
      */
-    showText: (text: string, options?: CliTextAnimatorOptions) => Promise<void>;
+    setPassword(userId: string, password: string, currentPassword?: string): Promise<void>;
+    /** Verifies a password against stored credentials */
+    verifyPassword(userId: string, password: string): Promise<boolean>;
+    /** Hashes a password with a salt using Web Crypto SHA-256 */
+    hashPassword(password: string, salt: string): Promise<string>;
+    /** Validate password against policy. Returns error message or null if valid. */
+    validatePassword?(password: string): string | null;
 }
 
 /**
- * Result of a guard check.
- *
- * - `true` or `undefined`: allow the command.
- * - `false`: block it with the generic message `<command>: permission denied`.
- * - a non-empty `string`: block it and print this message.
- * - `{ allowed, message }`: explicit form; `message` is used when `allowed` is false.
+ * Token for the CLI user session service.
  */
-type CliCommandGuardResult = boolean | string | void | {
-    allowed: boolean;
-    message?: string;
-};
+declare const ICliUserSessionService_TOKEN: CliToken<ICliUserSessionService>;
 /**
- * A global command guard: a check that runs before **every** command, across
- * all processors and modules, and can block it.
- *
- * Use guards for cross-cutting policies such as authentication, permission
- * checks, feature flags, maintenance windows or rate limiting, instead of
- * repeating the check inside each processor.
- *
- * ## When guards run
- *
- * For each command the executor:
- * 1. parses the input and resolves the processor (and sub-processor);
- * 2. handles global parameters such as `--help` (help is never guarded);
- * 3. extracts the positional value into `command.value`;
- * 4. **runs the guards**;
- * 5. validates required values/parameters, runs processor hooks and finally
- *    calls `processCommand`.
- *
- * Guards run in ascending `priority` (default `0`). For each guard the executor
- * calls `appliesTo` (if defined) and skips the guard when it returns `false`;
- * otherwise it awaits `canActivate`. The **first** guard that blocks stops the
- * chain: its message is written as an error and the command exits with code
- * `-1`. A guard that throws (in `appliesTo` or `canActivate`) also blocks the
- * command, so a broken guard fails closed.
- *
- * ## Access to the context
- *
- * Both `appliesTo` and `canActivate` receive the {@link ICliExecutionContext}
- * of the command about to run, so a guard can:
- * - resolve services with `context.services.get(...)` / `getRequired(...)`
- *   (e.g. a policy, feature-flag or permission service registered by any
- *   module) to decide **what** should be guarded and **whether** it may run;
- * - inspect `context.userSession` for the signed-in user and their groups;
- * - read the processor's `metadata` (for example `requireAuth` or
- *   `requiredGroups`) and the parsed `command` (`command.value`, `command.args`);
- * - prompt the user via `context.reader` (e.g. a confirmation guard).
- *
- * Guards should not write to the terminal to report a denial; return a message
- * instead so the executor prints it consistently.
- *
- * ## Registering guards
- *
- * The preferred way is the module's `guards` array; the boot sequence
- * registers each entry as a multi-provider under {@link ICliCommandGuard_TOKEN}.
- * Several modules can contribute guards; all of them run.
- *
- * ```ts
- * const billingModule: ICliModule = {
- *     apiVersion: 2,
- *     name: 'billing',
- *     processors: [new InvoiceProcessor()],
- *     guards: [billingGuard],
- * };
- * ```
- *
- * Guards can also be added at runtime (e.g. from `onInit`):
- *
- * ```ts
- * context.services.set({ provide: ICliCommandGuard_TOKEN, useValue: myGuard, multi: true });
- * ```
- *
- * ## Example: policy resolved from a service
- *
- * ```ts
- * const featureFlagGuard: ICliCommandGuard = {
- *     name: 'feature-flags',
- *     // Only guard commands that are behind a flag; the flag list comes from a service
- *     appliesTo: (processor, _command, context) =>
- *         context.services.get<FeatureFlags>(FeatureFlags_TOKEN)?.isFlagged(processor.command) ?? false,
- *     canActivate: async (_command, processor, context) => {
- *         const flags = context.services.getRequired<FeatureFlags>(FeatureFlags_TOKEN);
- *         return (await flags.isEnabled(processor.command, context.userSession?.user))
- *             ? true
- *             : `${processor.command}: not available for your account`;
- *     },
- * };
- * ```
- *
- * ## Without a guard-providing module
- *
- * Guards are opt-in. When no guard is registered every command runs as before.
- * The engine registers three built-in guards that enforce the processor access
- * metadata (`requireAuth`, `requiredGroups`, `requiredPermissions`); they stay
- * inactive until an auth module (e.g. `@qodalis/cli-users`) registers an
- * `ICliAuthorizationService`, so without one that metadata is informational.
+ * Token for the CLI users store service.
  */
-interface ICliCommandGuard {
-    /** Unique name, shown in diagnostics when the guard throws. */
-    name: string;
-    /** Execution order; lower runs first. Defaults to `0`. */
-    priority?: number;
-    /**
-     * Optional filter deciding whether this guard is relevant for the command.
-     * Return `false` to skip the guard. When omitted the guard applies to
-     * every command. May be async, and may use `context` to resolve services.
-     */
-    appliesTo?(processor: ICliCommandProcessor, command: CliProcessCommand, context: ICliExecutionContext): boolean | Promise<boolean>;
+declare const ICliUsersStoreService_TOKEN: CliToken<ICliUsersStoreService>;
+/**
+ * Token for the CLI groups store service.
+ */
+declare const ICliGroupsStoreService_TOKEN: CliToken<ICliGroupsStoreService>;
+/**
+ * Token for the CLI auth service.
+ */
+declare const ICliAuthService_TOKEN: CliToken<ICliAuthService>;
+/**
+ * Token for registering completion providers via module services (multi: true).
+ */
+declare const ICliCompletionProvider_TOKEN: CliToken<ICliCompletionProvider>;
+/**
+ * Token for the drag-and-drop service.
+ */
+declare const ICliDragDropService_TOKEN: CliToken<ICliDragDropService>;
+/**
+ * Token for the file transfer service.
+ */
+declare const ICliFileTransferService_TOKEN: CliToken<ICliFileTransferService>;
+/**
+ * Token for the translation service.
+ */
+declare const ICliTranslationService_TOKEN: CliToken<ICliTranslationService>;
+/**
+ * Token for the permission service.
+ */
+declare const ICliPermissionService_TOKEN: CliToken<ICliPermissionService>;
+/**
+ * Token for the file picker provider.
+ */
+declare const ICliFilePickerProvider_TOKEN: CliToken<ICliFilePickerProvider>;
+/**
+ * Token for the HTTP client service.
+ */
+declare const ICliHttpClient_TOKEN: CliToken<ICliHttpClient>;
+/**
+ * Token for the user event service (lifecycle events).
+ */
+declare const ICliUserEventService_TOKEN: CliToken<ICliUserEventService>;
+/**
+ * Token for the audit service (persistent event logging).
+ */
+declare const ICliAuditService_TOKEN: CliToken<ICliAuditService>;
+/**
+ * Token for the authorization service ({@link ICliAuthorizationService}).
+ * Provided by an auth module (e.g. `@qodalis/cli-users`); absent otherwise.
+ */
+declare const ICliAuthorizationService_TOKEN: CliToken<ICliAuthorizationService>;
+/**
+ * Token for the permission registry ({@link ICliPermissionRegistry}).
+ * Always provided by the CLI engine.
+ */
+declare const ICliPermissionRegistry_TOKEN: CliToken<ICliPermissionRegistry>;
+/**
+ * Token for the sessions service ({@link ICliSessionsService}).
+ */
+declare const ICliSessionsService_TOKEN: CliToken<ICliSessionsService>;
+/**
+ * Token for the persistent key-value store used by modules (setup state, etc.).
+ */
+declare const ICliKeyValueStore_TOKEN: CliToken<ICliKeyValueStore>;
+
+/**
+ * Abstract permission service for checking rwx permissions on resources.
+ * The default implementation lives in @qodalis/cli-users; consumers can
+ * replace it via the DI container.
+ */
+interface ICliPermissionService {
     /**
-     * Decide whether the command may run. See {@link CliCommandGuardResult}
-     * for the accepted return values.
+     * Check whether a user may perform an action on a resource.
+     * @param user        The acting user.
+     * @param action      The requested operation.
+     * @param ownership   Owner/group of the resource.
+     * @param permissions Permission string (e.g. "rwxr-xr-x").
+     * @returns true if allowed.
      */
-    canActivate(command: CliProcessCommand, processor: ICliCommandProcessor, context: ICliExecutionContext): CliCommandGuardResult | Promise<CliCommandGuardResult>;
+    check(user: ICliUser, action: 'read' | 'write' | 'execute', ownership: ICliOwnership, permissions: string): boolean;
+    /** Parse octal (e.g. "755") to a permission string (e.g. "rwxr-xr-x"). */
+    parseOctal(octal: string): string;
+    /** Convert a permission string (e.g. "rwxr-xr-x") to octal (e.g. "755"). */
+    toOctal(permissions: string): string;
 }
-/** DI token for {@link ICliCommandGuard}; register guards as multi-providers. */
-declare const ICliCommandGuard_TOKEN = "cli-command-guard";
 
 /**
- * A permission an extension uses, declared so tools (`perms --list`,
- * `groupmod --grant` completion, docs) can show it. Declaring is optional:
- * any `resource:action` string can be granted and checked.
+ * Represents an option for the readSelect and readSelectInline prompts.
  */
-interface CliPermissionDefinition {
-    /** Permission string, `resource:action` (e.g. `files:chown`). */
-    name: string;
-    /** Human readable description. */
+interface CliSelectOption {
+    /** Display text shown to the user */
+    label: string;
+    /** Value returned when this option is selected */
+    value: string;
+    /** Optional description shown as dimmed italic text after the label */
     description?: string;
-    /** Module that declared it (filled in at registration). */
-    module?: string;
-}
-/** Registry of permissions declared by modules (`ICliModule.permissions`). */
-interface ICliPermissionRegistry {
-    register(definitions: CliPermissionDefinition[], module?: string): void;
-    list(): CliPermissionDefinition[];
-    get(name: string): CliPermissionDefinition | undefined;
-}
-/** The identity checks are made against. */
-interface ICliPrincipal {
-    /** User id */
-    id: string;
-    /** Login name (used as file owner) */
-    name: string;
-    /** Group (role) names */
-    groups: string[];
-    /** Effective permissions (union of the groups' permissions) */
-    permissions: string[];
+    /** Group name — options sharing the same group are displayed under a group header */
+    group?: string;
+    /** When true, the option is visible but cannot be selected (rendered dimmed) */
+    disabled?: boolean;
 }
-/** rwx-style protected resource (files, directories, or anything an extension owns). */
-interface ICliProtectedResource {
-    ownership?: ICliOwnership;
-    /** 9-char mode string, e.g. `rwxr-x---` */
-    permissions?: string;
+/**
+ * Represents an option for the readMultiSelect prompt.
+ */
+interface CliMultiSelectOption extends CliSelectOption {
+    /** Whether the option is pre-selected */
+    checked?: boolean;
 }
-type CliAccessAction = 'read' | 'write' | 'execute';
 /**
- * Authorization service. Provided by an auth module (the users module provides
- * one in local and in server mode). Extensions should use the helpers
- * {@link cliAuthorize} / {@link cliCanAccess}, which allow everything when no
- * authorization service is registered.
+ * Options for readLine input.
  */
-interface ICliAuthorizationService {
-    /** The signed-in principal, or undefined when nobody is signed in. */
-    getPrincipal(): ICliPrincipal | undefined;
-    /** Does the current principal hold `permission` (wildcards honoured)? */
-    can(permission: string): boolean;
+interface CliLineOptions {
     /**
-     * rwx check on a resource for the current principal (owner / group / other).
-     * Principals holding `*` or any of `bypassPermissions` are always allowed.
-     * Resources without a mode or ownership are allowed.
+     * Pre-filled default value. Shown in the buffer when the prompt opens.
+     * The cursor starts at the end of the default text.
      */
-    canAccess(resource: ICliProtectedResource, action: CliAccessAction, bypassPermissions?: string[]): boolean;
-}
-/** Thrown when an operation is not permitted. The message is user facing. */
-declare class CliAccessDeniedError extends Error {
-    readonly code = "EACCES";
-    constructor(message?: string);
+    default?: string;
+    /**
+     * Validation function called on Enter.
+     * Return an error message string to reject the input and display the error.
+     * Return null to accept the input.
+     */
+    validate?: (value: string) => string | null;
+    /** Placeholder text shown dimmed when the buffer is empty */
+    placeholder?: string;
 }
-/** True for {@link CliAccessDeniedError} (also across bundle copies). */
-declare function isCliAccessDeniedError(error: unknown): error is CliAccessDeniedError;
 /**
- * Check a permission for the current principal. Returns `true` when no
- * authorization service is registered (no auth module loaded).
- */
-declare function cliAuthorize(context: Pick<ICliExecutionContext, 'services'>, permission: string): boolean;
-/**
- * rwx check for the current principal. Returns `true` when no authorization
- * service is registered.
+ * Options for readSelect and readSelectInline.
  */
-declare function cliCanAccess(context: Pick<ICliExecutionContext, 'services'>, resource: ICliProtectedResource, action: CliAccessAction, bypassPermissions?: string[]): boolean;
+interface CliSelectOptions {
+    /** Pre-select an option by its value */
+    default?: string;
+    /** Enable type-to-filter. When true, printable keystrokes filter the option list. Default: false. */
+    searchable?: boolean;
+    /** Callback invoked each time the highlighted option changes */
+    onChange?: (value: string) => void;
+}
 /**
- * Reference rwx evaluation shared by implementations of
- * {@link ICliAuthorizationService.canAccess}.
+ * Options for readMultiSelect.
  */
-declare function cliEvaluateAccess(principal: ICliPrincipal | undefined, resource: ICliProtectedResource, action: CliAccessAction, bypassPermissions?: string[]): boolean;
-
-/** A sign-in session as listed by {@link ICliSessionsService}. Never carries a token. */
-interface ICliSessionInfo {
-    id: string;
-    userId: string;
-    userName: string;
-    createdAt: number;
-    lastActivity: number;
-    /** When the session expires if idle; undefined when there is no timeout */
-    expiresAt?: number;
-    /** True for the caller's own session */
-    current?: boolean;
-    metadata?: {
-        userAgent?: string;
-        remoteAddress?: string;
-        [key: string]: unknown;
-    };
+interface CliMultiSelectOptions {
+    /** Enable type-to-filter. When true, printable keystrokes filter the option list. Default: false. */
+    searchable?: boolean;
+    /** Callback invoked each time the set of checked options changes */
+    onChange?: (values: string[]) => void;
 }
 /**
- * Lists and revokes sign-in sessions. Implemented locally (sessions of this
- * browser) and by servers (all sessions). Used by `sessions` / `session-kick`.
+ * Options for readNumber input.
  */
-interface ICliSessionsService {
-    /** All sessions visible to the caller */
-    list(): Promise<ICliSessionInfo[]>;
-    /** Revoke a session by id */
-    revoke(sessionId: string, reason?: string): Promise<void>;
-    /** Revoke every session of a user (optionally keeping one) */
-    revokeUser(userId: string, options?: {
-        exceptSessionId?: string;
-        reason?: string;
-    }): Promise<void>;
+interface CliNumberOptions {
+    /** Minimum allowed value */
+    min?: number;
+    /** Maximum allowed value */
+    max?: number;
+    /** Pre-filled default value */
+    default?: number;
 }
-
 /**
- * Represents a service that manages user sessions in the CLI
+ * Options for readDate input.
  */
-interface ICliUserSessionService {
-    /** Gets the current user session as a reactive stream */
-    getUserSession(): Observable<ICliUserSession | undefined>;
-    /** Sets the current user session */
-    setUserSession(session: ICliUserSession): Promise<void>;
-    /** Clears the current session (logout) */
-    clearSession(): Promise<void>;
-    /** Persists the current session to storage */
-    persistSession(): Promise<void>;
-    /** Restores a session from storage (called on boot) */
-    restoreSession(): Promise<ICliUserSession | undefined>;
+interface CliDateOptions {
+    /**
+     * Date format string. Supported tokens: YYYY (4-digit year), MM (2-digit month),
+     * DD (2-digit day). Separators can be `-`, `/`, or `.`.
+     * @default 'YYYY-MM-DD'
+     */
+    format?: string;
+    /** Minimum allowed date in the same format as `format` */
+    min?: string;
+    /** Maximum allowed date in the same format as `format` */
+    max?: string;
+    /** Pre-filled default value */
+    default?: string;
 }
 /**
- * Represents a service that manages users in the CLI
+ * Provides interactive input reading from the terminal.
+ * All methods resolve with `null` when the user aborts (Ctrl+C or Escape).
  */
-interface ICliUsersStoreService {
-    /** Gets users with optional filtering and pagination */
-    getUsers(options?: {
-        query?: string;
-        skip?: number;
-        take?: number;
-    }): Observable<ICliUser[]>;
-    /** Creates a new user */
-    createUser(user: CliAddUser): Promise<ICliUser>;
-    /** Gets a user by id, name, or email */
-    getUser(id: string): Observable<ICliUser | undefined>;
-    /** Updates an existing user */
-    updateUser(id: string, updates: CliUpdateUser): Promise<ICliUser>;
-    /** Deletes a user by id */
-    deleteUser(id: string): Promise<void>;
+interface ICliInputReader {
+    /**
+     * Read a line of text input.
+     * @param prompt - The prompt text displayed to the user
+     * @param options - Optional configuration for default value, validation, and placeholder
+     * @returns The entered text, or null if aborted
+     */
+    readLine(prompt: string, options?: CliLineOptions): Promise<string | null>;
+    /**
+     * Read a password (masked input).
+     * @param prompt - The prompt text displayed to the user
+     * @returns The entered password, or null if aborted
+     */
+    readPassword(prompt: string): Promise<string | null>;
+    /**
+     * Read a yes/no confirmation.
+     * @param prompt - The prompt text displayed to the user
+     * @param defaultValue - Default value when Enter is pressed without input
+     * @returns true for yes, false for no, or null if aborted
+     */
+    readConfirm(prompt: string, defaultValue?: boolean): Promise<boolean | null>;
+    /**
+     * Read a selection from a vertical list of options.
+     * @param prompt - The prompt text displayed to the user
+     * @param options - Array of options to choose from
+     * @param selectOptions - Optional configuration for default, search, onChange
+     * @returns The selected option's value, or null if aborted
+     */
+    readSelect(prompt: string, options: CliSelectOption[], selectOptions?: CliSelectOptions): Promise<string | null>;
+    /**
+     * Read a selection from an inline horizontal list.
+     * @param prompt - The prompt text displayed to the user
+     * @param options - Array of options to choose from
+     * @param selectOptions - Optional configuration for default, search, onChange
+     * @returns The selected option's value, or null if aborted
+     */
+    readSelectInline(prompt: string, options: CliSelectOption[], selectOptions?: CliSelectOptions): Promise<string | null>;
+    /**
+     * Read multiple selections from a checkbox list.
+     * @param prompt - The prompt text displayed to the user
+     * @param options - Array of options with optional pre-checked state
+     * @param selectOptions - Optional configuration for search, onChange
+     * @returns Array of selected option values, or null if aborted
+     */
+    readMultiSelect(prompt: string, options: CliMultiSelectOption[], selectOptions?: CliMultiSelectOptions): Promise<string[] | null>;
+    /**
+     * Read a number input.
+     * @param prompt - The prompt text displayed to the user
+     * @param options - Optional configuration for min, max, and default value
+     * @returns The entered number, or null if aborted
+     */
+    readNumber(prompt: string, options?: CliNumberOptions): Promise<number | null>;
+    /**
+     * Read a date input with format validation.
+     * @param prompt - The prompt text displayed to the user
+     * @param options - Optional configuration for format, min/max range, default
+     * @returns The date string in the specified format, or null if aborted
+     */
+    readDate(prompt: string, options?: CliDateOptions): Promise<string | null>;
+    /**
+     * Read file(s) via the environment's file picker dialog.
+     * @param prompt - The prompt text displayed to the user
+     * @param options - Optional configuration for multiple, accept filter, directory mode
+     * @returns Array of selected files with content, or null if cancelled/unsupported
+     */
+    readFile(prompt: string, options?: CliFilePickerOptions): Promise<CliFileResult[] | null>;
+}
+
+interface ICliProgressBar {
+    /**
+     * Indicates if the progress bar is running
+     */
+    isRunning: boolean;
+    /**
+     * Show the progress bar
+     */
+    show: (text?: string) => void;
+    /**
+     * Hide the progress bar
+     */
+    hide: () => void;
 }
 /**
- * Represents a service that manages groups in the CLI
+ * Represents a spinner for the CLI
  */
-interface ICliGroupsStoreService {
-    /** Gets all groups */
-    getGroups(): Observable<ICliGroup[]>;
-    /** Gets a group by id or name */
-    getGroup(id: string): Observable<ICliGroup | undefined>;
-    /** Creates a new group (role), optionally with permissions */
-    createGroup(name: string, description?: string, permissions?: string[]): Promise<ICliGroup>;
-    /** Updates a group's description and/or permissions (by id or name) */
-    updateGroup(id: string, updates: {
-        description?: string;
-        permissions?: string[];
-    }): Promise<ICliGroup>;
-    /** Adds a user (id or name) to a group (id or name) */
-    addMember(groupId: string, userId: string): Promise<void>;
-    /** Removes a user (id or name) from a group (id or name) */
-    removeMember(groupId: string, userId: string): Promise<void>;
-    /** Deletes a group by id */
-    deleteGroup(id: string): Promise<void>;
-    /** Gets all users that belong to a group */
-    getGroupMembers(groupId: string): Observable<ICliUser[]>;
+interface ICliSpinner extends ICliProgressBar {
+    /**
+     * Set the text of the spinner
+     * @param text The text to set
+     */
+    setText: (text: string) => void;
 }
+type CliPercentageProgressBarUpdateValueOptions = {
+    /**
+     * The type of update to perform
+     * @default 'replace'
+     */
+    type?: 'replace' | 'increment';
+};
 /**
- * Represents a service that handles authentication in the CLI
+ * Represents a progress bar for the CLI
  */
-interface ICliAuthService {
+interface ICliPercentageProgressBar extends ICliProgressBar {
     /**
-     * Authenticates a user and returns a session. `password` may be omitted
-     * only when the implementation allows passwordless sign-in.
+     * Update the progress of the progress bar.
+     * @param progress The progress value (0–100). Values outside this range are clamped.
+     * @param options Optional: update type ('replace' or 'increment')
      */
-    login(username: string, password?: string): Promise<ICliUserSession>;
-    /** Ends the current session (the CLI is left signed out) */
-    logout(): Promise<void>;
+    update: (progress: number, options?: CliPercentageProgressBarUpdateValueOptions) => void;
     /**
-     * Switch to another user (`su`). Requires the target's password unless
-     * the caller may skip it (implementation-defined, e.g. `users:update`).
-     * Goes through the same lockout, events and audit as `login`.
+     * Complete the progress bar
+     * @returns void
      */
-    switchUser?(username: string, password?: string): Promise<ICliUserSession>;
+    complete: () => void;
     /**
-     * Sets or updates a user's password.
-     * @param currentPassword The user's current password, when changing one's own
-     * password. Server-backed implementations forward it so the server can
-     * re-check it; local implementations may ignore it.
+     * Set the text of the spinner
+     * @param text The text to set
      */
-    setPassword(userId: string, password: string, currentPassword?: string): Promise<void>;
-    /** Verifies a password against stored credentials */
-    verifyPassword(userId: string, password: string): Promise<boolean>;
-    /** Hashes a password with a salt using Web Crypto SHA-256 */
-    hashPassword(password: string, salt: string): Promise<string>;
-    /** Validate password against policy. Returns error message or null if valid. */
-    validatePassword?(password: string): string | null;
+    setText: (text: string) => void;
+}
+type CliTextAnimatorOptions = {
+    /**
+     * The speed of the animation
+     * @default 100
+     */
+    speed?: number;
+    /**
+     * The text will be removed after typing
+     */
+    removeAfterTyping?: boolean;
+};
+interface ICliTextAnimator extends ICliProgressBar {
+    /**
+     * Show animated text in a typing and erasing effect.
+     * @param text The text to animate
+     * @param options Optional: speed (ms per character), removeAfterTyping
+     * @returns A promise that resolves when the animation completes
+     */
+    showText: (text: string, options?: CliTextAnimatorOptions) => Promise<void>;
+    /**
+     * Stop the running animation, erase what it wrote and resolve the
+     * `showText` promise. Optional for backward compatibility.
+     */
+    cancel?: () => void;
+}
+
+/**
+ * Result of a guard check.
+ *
+ * - `true` or `undefined`: allow the command.
+ * - `false`: block it with the generic message `<command>: permission denied`.
+ * - a non-empty `string`: block it and print this message.
+ * - `{ allowed, message }`: explicit form; `message` is used when `allowed` is false.
+ */
+type CliCommandGuardResult = boolean | string | void | {
+    allowed: boolean;
+    message?: string;
+};
+/**
+ * A global command guard: a check that runs before **every** command, across
+ * all processors and modules, and can block it.
+ *
+ * Use guards for cross-cutting policies such as authentication, permission
+ * checks, feature flags, maintenance windows or rate limiting, instead of
+ * repeating the check inside each processor.
+ *
+ * ## When guards run
+ *
+ * For each command the executor:
+ * 1. parses the input and resolves the processor (and sub-processor);
+ * 2. handles global parameters such as `--help` (help is never guarded);
+ * 3. extracts the positional value into `command.value`;
+ * 4. **runs the guards**;
+ * 5. validates required values/parameters, runs processor hooks and finally
+ *    calls `processCommand`.
+ *
+ * Guards run in ascending `priority` (default `0`). For each guard the executor
+ * calls `appliesTo` (if defined) and skips the guard when it returns `false`;
+ * otherwise it awaits `canActivate`. The **first** guard that blocks stops the
+ * chain: its message is written as an error and the command exits with code
+ * `-1`. A guard that throws (in `appliesTo` or `canActivate`) also blocks the
+ * command, so a broken guard fails closed.
+ *
+ * ## Access to the context
+ *
+ * Both `appliesTo` and `canActivate` receive the {@link ICliExecutionContext}
+ * of the command about to run, so a guard can:
+ * - resolve services with `context.services.get(...)` / `getRequired(...)`
+ *   (e.g. a policy, feature-flag or permission service registered by any
+ *   module) to decide **what** should be guarded and **whether** it may run;
+ * - inspect `context.userSession` for the signed-in user and their groups;
+ * - read the processor's `metadata` (for example `requireAuth` or
+ *   `requiredGroups`) and the parsed `command` (`command.value`, `command.args`);
+ * - prompt the user via `context.reader` (e.g. a confirmation guard).
+ *
+ * Guards should not write to the terminal to report a denial; return a message
+ * instead so the executor prints it consistently.
+ *
+ * ## Registering guards
+ *
+ * The preferred way is the module's `guards` array; the boot sequence
+ * registers each entry as a multi-provider under {@link ICliCommandGuard_TOKEN}.
+ * Several modules can contribute guards; all of them run.
+ *
+ * ```ts
+ * const billingModule: ICliModule = {
+ *     apiVersion: 2,
+ *     name: 'billing',
+ *     processors: [new InvoiceProcessor()],
+ *     guards: [billingGuard],
+ * };
+ * ```
+ *
+ * Guards can also be added at runtime (e.g. from `onInit`):
+ *
+ * ```ts
+ * context.services.set({ provide: ICliCommandGuard_TOKEN, useValue: myGuard, multi: true });
+ * ```
+ *
+ * ## Example: policy resolved from a service
+ *
+ * ```ts
+ * const featureFlagGuard: ICliCommandGuard = {
+ *     name: 'feature-flags',
+ *     // Only guard commands that are behind a flag; the flag list comes from a service
+ *     appliesTo: (processor, _command, context) =>
+ *         context.services.get<FeatureFlags>(FeatureFlags_TOKEN)?.isFlagged(processor.command) ?? false,
+ *     canActivate: async (_command, processor, context) => {
+ *         const flags = context.services.getRequired<FeatureFlags>(FeatureFlags_TOKEN);
+ *         return (await flags.isEnabled(processor.command, context.userSession?.user))
+ *             ? true
+ *             : `${processor.command}: not available for your account`;
+ *     },
+ * };
+ * ```
+ *
+ * ## Without a guard-providing module
+ *
+ * Guards are opt-in. When no guard is registered every command runs as before.
+ * The engine registers three built-in guards that enforce the processor access
+ * metadata (`requireAuth`, `requiredGroups`, `requiredPermissions`); they stay
+ * inactive until an auth module (e.g. `@qodalis/cli-users`) registers an
+ * `ICliAuthorizationService`, so without one that metadata is informational.
+ */
+interface ICliCommandGuard {
+    /** Unique name, shown in diagnostics when the guard throws. */
+    name: string;
+    /** Execution order; lower runs first. Defaults to `0`. */
+    priority?: number;
+    /**
+     * Optional filter deciding whether this guard is relevant for the command.
+     * Return `false` to skip the guard. When omitted the guard applies to
+     * every command. May be async, and may use `context` to resolve services.
+     */
+    appliesTo?(processor: ICliCommandProcessor, command: CliProcessCommand, context: ICliExecutionContext): boolean | Promise<boolean>;
+    /**
+     * Decide whether the command may run. See {@link CliCommandGuardResult}
+     * for the accepted return values.
+     */
+    canActivate(command: CliProcessCommand, processor: ICliCommandProcessor, context: ICliExecutionContext): CliCommandGuardResult | Promise<CliCommandGuardResult>;
 }
+/** DI token for {@link ICliCommandGuard}; register guards as multi-providers. */
+declare const ICliCommandGuard_TOKEN: CliToken<ICliCommandGuard>;
 
 /**
  * Represents a serialized snapshot of a CLI engine's state.
@@ -1496,6 +1743,210 @@ interface ICliBackgroundServiceRegistry {
     destroyAll(): Promise<void>;
 }
 
+/**
+ * One event on the CLI event bus.
+ */
+interface CliEvent<T = unknown> {
+    /** Namespaced type, e.g. `package:installed` or `todo:added`. */
+    type: string;
+    /** Event payload. */
+    data: T;
+    /** Who emitted it (module or command name), when known. */
+    source?: string;
+    /** When it was emitted (ms since epoch). */
+    timestamp: number;
+}
+type CliEventHandler<T = unknown> = (event: CliEvent<T>) => void;
+/**
+ * Payload types of the known events, keyed by event type. The built-in
+ * events are listed here; plugins add their own with declaration merging:
+ *
+ * ```ts
+ * declare module '@qodalis/cli-core' {
+ *     interface CliEventMap {
+ *         'todo:added': { id: number; text: string };
+ *     }
+ * }
+ * ```
+ *
+ * Events not listed can still be emitted and received; their payload is
+ * then `unknown`.
+ */
+interface CliEventMap {
+    /** Boot finished: modules are set up and the terminal accepts input. */
+    'boot:completed': {
+        durationMs: number;
+        modules: number;
+        commands: number;
+    };
+    /** A command line finished running (typed, or run with `engine.execute`). */
+    'command:executed': {
+        command: string;
+        exitCode: number;
+        durationMs: number;
+    };
+    /** A module (plugin) was booted, at startup or later (e.g. `pkg add`). */
+    'module:loaded': {
+        name: string;
+        version?: string;
+        commands: number;
+    };
+    /** A module was unloaded (e.g. `pkg remove`, or before `pkg update`). */
+    'module:unloaded': {
+        name: string;
+    };
+    /** `pkg add` installed a package. */
+    'package:installed': {
+        name: string;
+        version: string;
+    };
+    /** `pkg update` changed a package's version. */
+    'package:updated': {
+        name: string;
+        version: string;
+        previousVersion: string;
+    };
+    /** `pkg remove` removed a package. */
+    'package:removed': {
+        name: string;
+        version: string;
+    };
+    /** A server connected (at boot, or after a reconnect). */
+    'server:connected': {
+        name: string;
+        url: string;
+        commands: number;
+        reconnected: boolean;
+    };
+    /** A server could not be reached at boot. */
+    'server:unavailable': {
+        name: string;
+        url: string;
+    };
+    /** A connected server went away. */
+    'server:disconnected': {
+        name: string;
+    };
+    /** An event pushed by a server over its event socket. */
+    'server:event': {
+        server: string;
+        type: string;
+        data: unknown;
+    };
+    /** Background service lifecycle (`service:registered`, `service:started`, ...). */
+    'service:registered': {
+        name: string;
+        [key: string]: unknown;
+    };
+    'service:started': {
+        name: string;
+        [key: string]: unknown;
+    };
+    'service:stopped': {
+        name: string;
+        [key: string]: unknown;
+    };
+    'service:completed': {
+        name: string;
+        [key: string]: unknown;
+    };
+    'service:failed': {
+        name: string;
+        error?: string;
+        [key: string]: unknown;
+    };
+    'service:status': {
+        name: string;
+        [key: string]: unknown;
+    };
+    /** A custom event emitted by a background service with `context.emit()`. */
+    'service:event': {
+        service: string;
+        type: string;
+        data: unknown;
+    };
+    /** A setting changed with `configure` (`category` is `system` or a plugin key). */
+    'config:changed': {
+        category: string;
+        key: string;
+        value: unknown;
+    };
+    /** A configuration category was reset to its defaults. */
+    'config:reset': {
+        category: string;
+    };
+    /** The signed-in user changed (sign-in, sign-out, `su`). */
+    'session:changed': {
+        user?: string;
+    };
+}
+/** Event types with a known payload. */
+type CliEventType = keyof CliEventMap;
+/** Payload of event `K`: from {@link CliEventMap}, or `unknown`. */
+type CliEventData<K extends string> = K extends CliEventType ? CliEventMap[K] : unknown;
+/**
+ * Publish/subscribe bus shared by the system, modules and commands of one
+ * terminal. Handlers run synchronously in subscription order; a failing
+ * handler is logged and does not affect the others or the emitter.
+ *
+ * Patterns: an exact type (`package:installed`), a namespace wildcard
+ * (`package:*`) or `*` for everything.
+ *
+ * Events live in memory: each terminal has its own bus for its lifetime,
+ * with a short recent history, and nothing is persisted.
+ *
+ * Get it from a command or module with `context.events`, or from the
+ * services container with {@link ICliEventBus_TOKEN}.
+ */
+interface ICliEventBus {
+    /**
+     * Emit an event to every matching handler.
+     *
+     * ```ts
+     * bus.emit('package:installed', { name, version }); // checked against CliEventMap
+     * bus.emit<TodoAdded>('todo:added', { id, text });   // explicit payload type
+     * bus.emit('todo:refresh');                          // custom event, no payload
+     * ```
+     */
+    emit<K extends CliEventType>(type: K, data: CliEventMap[K], options?: CliEmitOptions): void;
+    emit<T = unknown, K extends string = string>(type: K & CustomEventType<K>, data?: T, options?: CliEmitOptions): void;
+    /**
+     * Handle events matching `pattern`. Returns a function that unsubscribes.
+     *
+     * ```ts
+     * bus.on('package:installed', (e) => e.data.version); // typed from CliEventMap
+     * bus.on<TodoAdded>('todo:added', (e) => e.data.text); // explicit payload type
+     * bus.on('server:*', (e) => console.log(e.type));      // anonymous: data is unknown
+     * ```
+     */
+    on<K extends CliEventType>(pattern: K, handler: CliEventHandler<CliEventMap[K]>): () => void;
+    on<T = unknown>(pattern: string, handler: CliEventHandler<T>): () => void;
+    /** Like `on`, but only for the next matching event. */
+    once<K extends CliEventType>(pattern: K, handler: CliEventHandler<CliEventMap[K]>): () => void;
+    once<T = unknown>(pattern: string, handler: CliEventHandler<T>): () => void;
+    /**
+     * Recent events matching `pattern`, oldest first. The bus keeps the last
+     * events in memory only: events are not persisted across reloads (state
+     * that must survive a reload belongs in a state store).
+     */
+    history<K extends CliEventType>(pattern: K, limit?: number): CliEvent<CliEventMap[K]>[];
+    history<T = unknown>(pattern?: string, limit?: number): CliEvent<T>[];
+    /** Matching events as an observable (completes when the bus is disposed). */
+    events$<K extends CliEventType>(pattern: K): Observable<CliEvent<CliEventMap[K]>>;
+    events$<T = unknown>(pattern?: string): Observable<CliEvent<T>>;
+}
+interface CliEmitOptions {
+    /** Who emits the event (module or command name). */
+    source?: string;
+}
+/**
+ * A type that is not a key of {@link CliEventMap}. Keeps `emit` from accepting
+ * a known event with an unchecked payload.
+ */
+type CustomEventType<K extends string> = K extends CliEventType ? never : K;
+/** Service token of the terminal's {@link ICliEventBus}. */
+declare const ICliEventBus_TOKEN: CliToken<ICliEventBus>;
+
 /**
  * Messages sent from the main thread to a background service Worker.
  */
@@ -1529,38 +1980,6 @@ type CliWorkerOutboundMessage = {
     stack?: string;
 };
 
-/**
- * Represents an entry in a file listing.
- */
-interface ICliFileEntry {
-    name: string;
-    type: 'file' | 'directory';
-    size: number;
-    modified: string;
-}
-
-/**
- * Abstraction for file transfer operations.
- * Default implementation uses browser-native APIs (file picker, download dialog).
- * @qodalis/cli-files overrides with virtual FS backed by IndexedDB.
- */
-interface ICliFileTransferService {
-    readFile(path: string): Promise<string | null>;
-    writeFile(path: string, content: string): Promise<void>;
-    listFiles(path: string): Promise<ICliFileEntry[]>;
-    exists(path: string): Promise<boolean>;
-    downloadToBrowser(filename: string, content: string | Blob): void;
-    uploadFromBrowser(accept?: string): Promise<{
-        name: string;
-        content: string;
-    } | null>;
-}
-
-interface ICliDragDropService {
-    /** Emits an array of dropped File objects each time files are dropped onto the terminal */
-    readonly onFileDrop: Observable<File[]>;
-}
-
 /**
  * Opaque state value carried between lines during syntax highlighting.
  * Encodes context such as "inside a multi-line string" or "inside a block comment"
@@ -1618,10 +2037,37 @@ declare enum CliLogLevel {
     WARN = 4,
     ERROR = 5
 }
+/**
+ * How the CLI reports its startup.
+ */
+interface CliBootOptions {
+    /**
+     * Report each boot step (terminal, services, servers, modules) in the
+     * terminal while the CLI starts. When `false`, a spinner is shown instead.
+     * Users can override it with `configure set system.bootLogs false`.
+     * @default true
+     */
+    showLogs?: boolean;
+    /**
+     * Keep the boot report on screen after startup instead of clearing it
+     * when the terminal is ready. Warnings and errors are kept either way.
+     * @default false
+     */
+    keepLogs?: boolean;
+    /**
+     * Steps taking at least this many milliseconds are highlighted as slow.
+     * @default 500
+     */
+    slowStepMs?: number;
+}
 /**
  * Options for the CLI
  */
 type CliOptions = Record<string, any> & {
+    /**
+     * How the CLI reports its startup (boot log, spinner).
+     */
+    boot?: CliBootOptions;
     /**
      * Custom terminal options
      */
@@ -1692,6 +2138,13 @@ type CliProcessorMetadata = Record<string, any> & {
      * Sealed processors can still be extended (wrapped) by processors with `extendsProcessor = true`.
      */
     sealed?: boolean;
+    /**
+     * The command's text is code or other literal input (`eval`): the engine
+     * passes the whole line as typed, without operators (`|`, `;`, `&&`,
+     * `>`) or expansion of `$(...)`, `$VAR`, braces and wildcards, so
+     * `eval [1,2].map(x => x * 2)` keeps its `=>`, `*` and `${...}`.
+     */
+    literalInput?: boolean;
     /**
      * If true, the processor requires the server to be running
      */
@@ -1751,7 +2204,45 @@ type CliStateConfiguration = {
      * @remarks If the store identifier is not set, the processor command name is used
      */
     storeName?: string;
+    /**
+     * Save the state after every change, so `persist()` does not have to be
+     * called. Changes made in the same tick are saved together.
+     * @default false
+     */
+    autoPersist?: boolean;
+    /**
+     * Version of the state's shape. When the saved state has an older
+     * version, `migrate` converts it while it is loaded. Saved state without
+     * a version counts as version 0.
+     */
+    version?: number;
+    /**
+     * Convert saved state of version `fromVersion` to the current
+     * {@link version}. The result is merged over `initialState`.
+     */
+    migrate?: (state: CliState, fromVersion: number) => CliState;
+    /**
+     * Apply changes saved by other tabs and terminals of the same browser.
+     * @default true
+     */
+    syncAcrossTabs?: boolean;
+    /**
+     * Where the state lives:
+     * - `'global'`: saved in the browser and shared by every terminal and tab
+     *   (each save merges the keys it changed, so terminals changing
+     *   different keys never overwrite each other).
+     * - `'user'`: like `'global'`, but saved separately for each signed-in
+     *   user (signed out, the state is shared); it switches when the user
+     *   signs in or out.
+     * - `'session'`: this terminal only, in memory; never saved or shared.
+     * @default 'global'
+     */
+    scope?: CliStateScope;
 };
+/** See {@link CliStateConfiguration.scope}. */
+type CliStateScope = 'global' | 'user' | 'session';
+/** Options of a state store (see {@link CliStateConfiguration}). */
+type CliStateStoreOptions = Pick<CliStateConfiguration, 'autoPersist' | 'version' | 'migrate' | 'syncAcrossTabs' | 'scope'>;
 type CliState = Record<string, any>;
 /**
  * Position of the CLI panel relative to the viewport edge.
@@ -1894,114 +2385,6 @@ interface CliPanelPaneState {
     widthPercent: number;
 }
 
-/**
- * Options for HTTP client requests.
- * Extends standard RequestInit with convenience fields.
- */
-interface CliHttpRequestOptions extends Omit<RequestInit, 'method' | 'body'> {
-    /**
-     * Request timeout in milliseconds. When set, the request is automatically
-     * aborted after this duration. Combines with any existing abort signal.
-     */
-    timeout?: number;
-}
-/**
- * HTTP client for making requests from command processors.
- *
- * Automatically merges the command's abort signal so that requests are
- * cancelled when the user presses Ctrl+C. Provides typed convenience
- * methods for common HTTP verbs as well as a raw `fetch()` for cases
- * that need full Response access (streaming, progress, etc.).
- *
- * Available on the execution context as `context.http`.
- *
- * @example
- * ```ts
- * // Typed JSON response
- * const users = await context.http.get<User[]>('https://api.example.com/users');
- *
- * // POST with body
- * await context.http.post('https://api.example.com/users', { name: 'John' });
- *
- * // Raw fetch for streaming
- * const response = await context.http.fetch('https://example.com/file.zip');
- * const reader = response.body?.getReader();
- * ```
- */
-interface ICliHttpClient {
-    /**
-     * Make a raw HTTP request. Returns the full Response object for cases
-     * that need streaming, headers, or status inspection.
-     * The command's abort signal is automatically merged.
-     */
-    fetch(url: string, init?: RequestInit): Promise<Response>;
-    /**
-     * HTTP GET request. Returns the parsed JSON response body.
-     */
-    get<T = any>(url: string, options?: CliHttpRequestOptions): Promise<T>;
-    /**
-     * HTTP POST request. Automatically serializes the body as JSON
-     * (unless body is FormData, Blob, string, or ArrayBuffer).
-     * Returns the parsed JSON response body.
-     */
-    post<T = any>(url: string, body?: any, options?: CliHttpRequestOptions): Promise<T>;
-    /**
-     * HTTP PUT request. Automatically serializes the body as JSON.
-     * Returns the parsed JSON response body.
-     */
-    put<T = any>(url: string, body?: any, options?: CliHttpRequestOptions): Promise<T>;
-    /**
-     * HTTP PATCH request. Automatically serializes the body as JSON.
-     * Returns the parsed JSON response body.
-     */
-    patch<T = any>(url: string, body?: any, options?: CliHttpRequestOptions): Promise<T>;
-    /**
-     * HTTP DELETE request. Returns the parsed JSON response body (if any).
-     */
-    delete<T = any>(url: string, options?: CliHttpRequestOptions): Promise<T>;
-    /**
-     * HTTP HEAD request. Returns the full Response (no body parsing).
-     */
-    head(url: string, options?: CliHttpRequestOptions): Promise<Response>;
-    /**
-     * HTTP OPTIONS request. Returns the parsed JSON response body.
-     */
-    options<T = any>(url: string, options?: CliHttpRequestOptions): Promise<T>;
-}
-/**
- * Error thrown by `ICliHttpClient` JSON helpers (`get`, `post`, `put`,
- * `patch`, `delete`, `options`) when the server responds with a non-2xx status.
- *
- * Exposes the HTTP status so callers can react to specific responses
- * (for example, clearing a stored session token on `401`).
- *
- * @example
- * ```ts
- * try {
- *     await context.http.get(url);
- * } catch (e) {
- *     if (e instanceof CliHttpError && e.status === 401) {
- *         // token expired or revoked
- *     }
- * }
- * ```
- */
-declare class CliHttpError extends Error {
-    /** HTTP status code of the failed response */
-    readonly status: number;
-    /** HTTP status text of the failed response */
-    readonly statusText: string;
-    /** Parsed JSON error body, when the server returned one */
-    readonly body?: unknown | undefined;
-    constructor(message: string, 
-    /** HTTP status code of the failed response */
-    status: number, 
-    /** HTTP status text of the failed response */
-    statusText?: string, 
-    /** Parsed JSON error body, when the server returned one */
-    body?: unknown | undefined);
-}
-
 type CliNotificationLevel = 'info' | 'success' | 'warn' | 'error';
 interface CliNotification {
     level: CliNotificationLevel;
@@ -2026,64 +2409,6 @@ interface ICliNotifier {
     readonly change$: Observable<CliNotification | undefined>;
 }
 
-/** Represents a user lifecycle event */
-interface ICliUserEvent {
-    /** The type of event that occurred */
-    type: 'login' | 'logout' | 'login_failed' | 'user_created' | 'user_deleted' | 'user_updated' | 'password_changed' | 'user_switched' | 'user_disabled' | 'user_enabled' | 'group_created' | 'group_updated' | 'group_deleted' | 'group_member_added' | 'group_member_removed' | 'session_revoked' | 'audit_cleared';
-    /** The user involved in the event (for group events: the acting user) */
-    user: ICliUser;
-    /** The acting user's name, when different from `user` (e.g. an admin) */
-    actor?: string;
-    /** When the event occurred */
-    timestamp: number;
-    /** Optional additional details */
-    details?: string;
-    /** `user_updated`: the user's name before a rename (set only when the name changed) */
-    previousName?: string;
-}
-/** Service that emits user lifecycle events for plugins to subscribe to */
-interface ICliUserEventService {
-    /** Observable stream of user events */
-    readonly events$: Observable<ICliUserEvent>;
-    /** Emit a user event */
-    emit(event: ICliUserEvent): void;
-}
-
-/** A single audit log entry */
-interface ICliAuditEntry {
-    /** Entry id (server-assigned in server mode) */
-    id?: string;
-    /** When the event occurred */
-    timestamp: number;
-    /** Event type (e.g., 'login', 'logout', 'login_failed') */
-    event: string;
-    /** Username involved */
-    username: string;
-    /** Optional additional details */
-    details?: string;
-    /** Id of the user the entry is about, when known */
-    userId?: string;
-    /** The user who performed the action, when different from `username` */
-    actor?: string;
-    /** Id of the acting user, when different from the subject */
-    actorId?: string;
-    /** Extra data (e.g. remote address) */
-    metadata?: Record<string, unknown>;
-}
-/** Service for persistent audit logging */
-interface ICliAuditService {
-    /** Log an audit entry (timestamp is added automatically) */
-    log(entry: Omit<ICliAuditEntry, 'timestamp'>): Promise<void>;
-    /** Retrieve audit entries with optional filtering */
-    getEntries(options?: {
-        limit?: number;
-        event?: string;
-        username?: string;
-    }): Promise<ICliAuditEntry[]>;
-    /** Clear all audit entries */
-    clear(): Promise<void>;
-}
-
 /**
  * A managed timer handle returned by createInterval/createTimeout.
  * Managed timers are automatically cleared when full-screen mode exits
@@ -2130,6 +2455,16 @@ interface ICliExecutionContext {
      * The progress bar to use for showing progress
      */
     progressBar: ICliPercentageProgressBar;
+    /**
+     * The terminal's event bus: emit and subscribe to events shared by the
+     * system, modules and commands. Optional for backward compatibility.
+     */
+    readonly events?: ICliEventBus;
+    /**
+     * `true` once the CLI has finished booting (modules set up, terminal
+     * ready). Optional for backward compatibility; `undefined` means unknown.
+     */
+    readonly isBooted?: boolean;
     /**
      * A subject that emits when the command is aborted
      */
@@ -2768,6 +3103,7 @@ interface ICliServiceProvider {
      * @param service The token (typically a `*_TOKEN` constant) identifying the service
      * @returns The service instance cast to `T`, or `undefined` if not registered
      */
+    get<T>(service: CliToken<T>): T | undefined;
     get<T = unknown>(service: any): T | undefined;
     /**
      * Retrieve all registered services for a multi-provider token.
@@ -2775,6 +3111,7 @@ interface ICliServiceProvider {
      * @param service The token (typically a `*_TOKEN` constant) identifying the service
      * @returns Array of all resolved service instances
      */
+    getAll<T>(service: CliToken<T>): T[];
     getAll<T = unknown>(service: any): T[];
     /**
      * Retrieve a service by its injection token, throwing if not registered.
@@ -2784,6 +3121,7 @@ interface ICliServiceProvider {
      * @returns The service instance, cast to `T`
      * @throws If no service is registered for the given token
      */
+    getRequired<T>(service: CliToken<T>): T;
     getRequired<T = unknown>(service: any): T;
     /**
      * Check whether a service is registered for the given token.
@@ -2796,11 +3134,20 @@ interface ICliServiceProvider {
      * @param definition A single provider or an array of providers to register
      */
     set(definition: CliProvider | CliProvider[]): void;
+    /**
+     * Remove a registration. With `provider` (the provider object passed to
+     * `set`, or the registered value), only that registration is removed: for
+     * a single token the previous registration becomes active again, for a
+     * multi token the others remain. Without it, every registration of the
+     * token is removed. Sealed tokens cannot be removed.
+     * @returns Whether something was removed
+     */
+    remove?(service: any, provider?: unknown): boolean;
 }
 /** DI token for `ICliServerAuthTokenProvider` (multi-provider) */
-declare const ICliServerAuthTokenProvider_TOKEN = "cli-server-auth-token-provider";
+declare const ICliServerAuthTokenProvider_TOKEN: CliToken<ICliServerAuthTokenProvider>;
 /** DI token for `ICliServerAuthService` */
-declare const ICliServerAuthService_TOKEN = "cli-server-auth-service";
+declare const ICliServerAuthService_TOKEN: CliToken<ICliServerAuthService>;
 /**
  * Integrators implement this interface to supply auth credentials
  * for server requests. Multiple providers can be registered — the
@@ -2863,7 +3210,7 @@ interface ICliServerManager {
     preferredServer?(): string | null;
 }
 /** Token for {@link ICliServerManager} */
-declare const ICliServerManager_TOKEN = "cli-server-manager";
+declare const ICliServerManager_TOKEN: CliToken<ICliServerManager>;
 /**
  * Internal service that resolves auth headers for a server by merging:
  * 1. Static/dynamic headers from `CliServerConfig.headers`
@@ -3001,6 +3348,22 @@ type CliServerCapabilities = {
     streaming?: boolean;
 };
 
+/**
+ * A DI token that carries the type of the service it identifies, so
+ * `services.get(TOKEN)` is typed without a type argument:
+ *
+ * ```ts
+ * export const ITodoStore_TOKEN = createCliToken<ITodoStore>('todo-store');
+ * const store = context.services.get(ITodoStore_TOKEN); // ITodoStore | undefined
+ * ```
+ *
+ * At runtime it is the plain string, so it works anywhere a string token does.
+ */
+type CliToken<T> = string & {
+    readonly __cliTokenType?: T;
+};
+/** Create a typed {@link CliToken}. */
+declare function createCliToken<T>(name: string): CliToken<T>;
 type MultiServices = {
     /**
      * When true, injector returns an array of instances. This is useful to allow multiple
@@ -3017,10 +3380,15 @@ type CliTypeProvider = MultiServices & {
     deps?: any[];
 };
 type CliFactoryProvider = MultiServices & {
-    useFactory: Function;
+    useFactory: (...args: any[]) => any;
     /** DI tokens resolved from the container and passed as factory arguments. */
     deps?: any[];
 };
+/**
+ * Service registration. `useFactory` and `useClass` providers are created
+ * lazily, on the first `get()` of their token (or of a token depending on
+ * them), so their `deps` may be registered after them.
+ */
 type CliProvider = {
     provide: any;
     /** When true, this token is sealed after registration and cannot be overwritten. */
@@ -3135,6 +3503,9 @@ declare const enums: {
 declare class CliModuleRegistry {
     private readonly modules;
     private readonly bootHandlers;
+    private readonly unregisterHandlers;
+    /** Registrations whose boot handlers are still running. */
+    private readonly inFlight;
     /** Optional warning callback — set by the engine to route through ICliLogger */
     onWarn?: (message: string) => void;
     /**
@@ -3147,6 +3518,23 @@ declare class CliModuleRegistry {
      * skipped with a warning — this ensures only compatible frontend plugins load.
      */
     register(module: ICliModule): Promise<void>;
+    /**
+     * Resolve once every registration in progress (including ones started
+     * meanwhile, e.g. a plugin loading another) has finished booting.
+     */
+    whenIdle(): Promise<void>;
+    private registerInternal;
+    /**
+     * Register a handler that is called when a module is unregistered,
+     * e.g. so its processors can be removed.
+     */
+    onModuleUnregister(handler: (module: ICliModule) => void): void;
+    /**
+     * Unregister a module and notify all unregister handlers. A module
+     * registered again afterwards (e.g. a newer version) boots again.
+     * Returns the removed module, or `undefined` when it was not registered.
+     */
+    unregister(name: string): ICliModule | undefined;
     /**
      * Get a module by name.
      */
@@ -3286,7 +3674,10 @@ declare class ServerVersionNegotiator {
      * Returns the negotiated API version and the base path for all subsequent calls,
      * or null if the server is unreachable or incompatible.
      */
-    static discover(baseUrl: string, headers?: CliHeadersProvider): Promise<{
+    static discover(baseUrl: string, headers?: CliHeadersProvider, options?: {
+        /** Rethrow when the server cannot be reached (instead of `null`, "no discovery") */
+        rethrowNetworkErrors?: boolean;
+    }): Promise<{
         apiVersion: number;
         basePath: string;
     } | null>;
@@ -3462,6 +3853,45 @@ declare const cliAccessMetadataGuards: ICliCommandGuard[];
  */
 declare function cliDefaultServer(context: Pick<ICliExecutionContext, 'services' | 'options'>): CliServerConfig | undefined;
 
+/** A help row: the left column and its description. */
+type CliHelpRow = readonly [string, string];
+/** Write a `📋 Usage:` block with aligned, highlighted commands. */
+declare function writeUsage(context: ICliExecutionContext, rows: readonly CliHelpRow[]): void;
+/** Write a `📝 Examples:` block with aligned `# comments`. */
+declare function writeExamples(context: ICliExecutionContext, rows: readonly CliHelpRow[]): void;
+/**
+ * Write a paragraph wrapped at word boundaries to the terminal width (at
+ * most 100 columns), so long help text never breaks inside a word.
+ */
+declare function writeWrapped(context: ICliExecutionContext, text: string, indent?: number): void;
+/** `💡 Use <command> to <action>` hint. */
+declare function writeHint(context: ICliExecutionContext, command: string, action: string): void;
+
+/**
+ * Split text into arguments like a POSIX shell: spaces separate words,
+ * quotes are removed (`"a b"` is one word), single quotes keep everything
+ * literally, and a backslash escapes the next character outside quotes
+ * (`my\ file`) or `"`, `\`, `$` and `` ` `` inside double quotes. A quote
+ * without a closing one is ordinary text (`it's`).
+ */
+declare function splitShellWords(text: string): string[];
+/**
+ * The arguments as a shell's echo prints them: {@link splitShellWords}
+ * joined by one space. Inside double quotes, a backslash before other
+ * characters stays (`"a\nb"`) for echo's escape step.
+ */
+declare function joinShellWords(text: string): string;
+/** Quote a value so {@link splitShellWords} reads it back as one word. */
+declare function quoteShellWord(value: string): string;
+
+/**
+ * Text given as one free-form argument (JSON, code, a query) without one
+ * pair of quotes wrapping all of it: `'{"a": 1}'` -> `{"a": 1}`, and
+ * `"say \"hi\""` -> `say "hi"`. Anything else is kept as typed, so quotes
+ * and backslashes inside the text are never touched.
+ */
+declare function unquoteRawArgument(text: string): string;
+
 /**
  * Retrieve a parameter's value from the parsed arguments, checking aliases.
  * @param p The parameter descriptor
@@ -3614,7 +4044,7 @@ interface CliThemeInfo {
 
 declare const DefaultThemeInfos: Record<string, CliThemeInfo>;
 
-declare const LIBRARY_VERSION = "2.0.0-beta.17";
+declare const LIBRARY_VERSION = "2.0.0-beta.18";
 declare const API_VERSION = 2;
 
 /**
@@ -3675,4 +4105,5 @@ declare class BrowserFileTransferService implements ICliFileTransferService {
     private _pickFile;
 }
 
-export { API_VERSION, BrowserFileTransferService, CANCELLATION_ERROR_MESSAGE, CLI_CONFIGURE_STORE_NAME, CancellablePromise, type CliAccessAction, CliAccessDeniedError, type CliAddUser, CliBackgroundColor, type CliBackgroundServiceStatus, type CliBackgroundServiceType, type CliCommandGuardResult, type CliDateOptions, type CliEngineSnapshot, type CliFactoryProvider, type CliFilePickerOptions, type CliFileResult, CliForegroundColor, type CliFullScreenOptions, type CliHeadersProvider, CliHttpError, type CliHttpRequestOptions, CliIcon, type CliLineOptions, CliLogLevel, CliModuleRegistry, type CliMultiSelectOption, type CliMultiSelectOptions, type CliNotification, type CliNotificationLevel, type CliNumberOptions, type CliOptions, type CliPackageSource, type CliPanelConfig, type CliPanelHideAlignment, type CliPanelPaneState, type CliPanelPosition, type CliPanelState, type CliPanelTabState, type CliPercentageProgressBarUpdateValueOptions, type CliPermissionDefinition, type CliProcessCommand, type CliProcessorMetadata, type CliProvider, type CliSelectOption, type CliSelectOptions, type CliServerCapabilities, type CliServerCommandDescriptor, type CliServerConfig, type CliServerOutput, CliServerPermissions, type CliServerResponse, type CliServiceEventHandler, type CliServiceExecutionMode, type CliServiceLogLevel, type CliState, type CliStateConfiguration, type CliTableOptions, type CliTextAnimatorOptions, type CliTheme, type CliThemeCategory, type CliThemeInfo, type CliTypeProvider, type CliUpdateUser, CliUsersPermissions, type CliValueProvider, type CliWorkerInboundMessage, type CliWorkerOutboundMessage, DEFAULT_DIR_PERMISSIONS, DEFAULT_FILE_PERMISSIONS, DefaultLibraryAuthor, DefaultThemeInfos, DefaultThemes, type DefaultThemesType, type ICliAuditEntry, type ICliAuditService, ICliAuditService_TOKEN, type ICliAuthService, ICliAuthService_TOKEN, type ICliAuthorizationService, ICliAuthorizationService_TOKEN, type ICliBackgroundService, type ICliBackgroundServiceInfo, type ICliBackgroundServiceRegistry, type ICliClipboard, type ICliCommandAuthor, type ICliCommandChildProcessor, type ICliCommandExecutorService, type ICliCommandGuard, ICliCommandGuard_TOKEN, type ICliCommandParameterDescriptor, type ICliCommandProcessor, type ICliCommandProcessorRegistry, type ICliCompletionContext, type ICliCompletionProvider, ICliCompletionProvider_TOKEN, type ICliConfigurableModule, type ICliConfigurationOption, type ICliDragDropService, ICliDragDropService_TOKEN, type ICliExecutionContext, type ICliExecutionProcess, type ICliFileEntry, type ICliFilePickerProvider, ICliFilePickerProvider_TOKEN, type ICliFileTransferService, ICliFileTransferService_TOKEN, type ICliGlobalParameterHandler, type ICliGroup, type ICliGroupsStoreService, ICliGroupsStoreService_TOKEN, type ICliHttpClient, ICliHttpClient_TOKEN, type ICliInputReader, type ICliKeyValueStore, ICliKeyValueStore_TOKEN, type ICliLogger, type ICliManagedInterval, type ICliManagedTimer, type ICliModule, type ICliNotifier, type ICliOwnership, type ICliPanelRef, type ICliPercentageProgressBar, type ICliPermissionRegistry, ICliPermissionRegistry_TOKEN, type ICliPermissionService, ICliPermissionService_TOKEN, type ICliPingServerService, type ICliPrincipal, type ICliProcessEntry, type ICliProcessRegisterOptions, type ICliProcessRegistry, type ICliProcessorHook, type ICliProgressBar, type ICliProtectedResource, type ICliServerAuthService, ICliServerAuthService_TOKEN, type ICliServerAuthTokenProvider, ICliServerAuthTokenProvider_TOKEN, type ICliServerManager, ICliServerManager_TOKEN, type ICliServiceContext, type ICliServiceEvent, type ICliServiceLogEntry, type ICliServiceProvider, type ICliSessionInfo, type ICliSessionsService, ICliSessionsService_TOKEN, type ICliSpinner, type ICliStateStore, type ICliTerminalWriter, type ICliTextAnimator, type ICliTranslationService, ICliTranslationService_TOKEN, type ICliUmdModule, type ICliUser, type ICliUserCredentials, type ICliUserEvent, type ICliUserEventService, ICliUserEventService_TOKEN, type ICliUserSession, type ICliUserSessionService, ICliUserSessionService_TOKEN, type ICliUsersStoreService, ICliUsersStoreService_TOKEN, type ISyntaxHighlightRule, type ISyntaxHighlighter, type ISyntaxTheme, LIBRARY_VERSION, type LineState, ObjectDescriber, type Package, type ServerVersionInfo, ServerVersionNegotiator, type WorkerServiceContext, appendQueryParams, bootCliModule, bootUmdModule, buildAuthenticatedWebSocketUrl, clearTerminalLine, cliAccessMetadataGuards, cliAuthorize, cliCanAccess, cliDefaultServer, cliEvaluateAccess, cliHasPermission, cliMergePermissions, cliMissingPermissions, cliPermissionMatches, cliRequireAuthGuard, cliRequiredGroupsGuard, cliRequiredPermissionsGuard, colorFirstWord, colorizeJson, compareVersions, constants, createWorkerService, delay, derivePanelThemeStyles, enums, formatJson, getConfigValue, getParameterValue, getPluginConfigValue, getRightOfWord, highlightTextWithBg, initializeBrowserEnvironment, isCliAccessDeniedError, loadPanelPosition, nextPanelPosition, resolveConfigurationCategories, resolveHeaders, resolveServerHeaders, resolveServerWebSocketUrl, satisfiesMinVersion, satisfiesVersionRange, savePanelPosition, stripAnsi, toQueryString, truncateToWidth, utils, visibleLength };
+export { API_VERSION, BrowserFileTransferService, CANCELLATION_ERROR_MESSAGE, CLI_CONFIGURE_STORE_NAME, CancellablePromise, CliAccessDeniedError, CliBackgroundColor, CliForegroundColor, CliHttpError, CliIcon, CliLogLevel, CliModuleRegistry, CliServerPermissions, CliUsersPermissions, DEFAULT_DIR_PERMISSIONS, DEFAULT_FILE_PERMISSIONS, DefaultLibraryAuthor, DefaultThemeInfos, DefaultThemes, ICliAuditService_TOKEN, ICliAuthService_TOKEN, ICliAuthorizationService_TOKEN, ICliCommandGuard_TOKEN, ICliCompletionProvider_TOKEN, ICliDragDropService_TOKEN, ICliEventBus_TOKEN, ICliFilePickerProvider_TOKEN, ICliFileTransferService_TOKEN, ICliGroupsStoreService_TOKEN, ICliHttpClient_TOKEN, ICliKeyValueStore_TOKEN, ICliPermissionRegistry_TOKEN, ICliPermissionService_TOKEN, ICliServerAuthService_TOKEN, ICliServerAuthTokenProvider_TOKEN, ICliServerManager_TOKEN, ICliSessionsService_TOKEN, ICliTranslationService_TOKEN, ICliUserEventService_TOKEN, ICliUserSessionService_TOKEN, ICliUsersStoreService_TOKEN, LIBRARY_VERSION, ObjectDescriber, ServerVersionNegotiator, appendQueryParams, bootCliModule, bootUmdModule, buildAuthenticatedWebSocketUrl, clearTerminalLine, cliAccessMetadataGuards, cliAuthorize, cliCanAccess, cliDefaultServer, cliEvaluateAccess, cliHasPermission, cliMergePermissions, cliMissingPermissions, cliPermissionMatches, cliRequireAuthGuard, cliRequiredGroupsGuard, cliRequiredPermissionsGuard, colorFirstWord, colorizeJson, compareVersions, constants, createCliToken, createWorkerService, delay, derivePanelThemeStyles, enums, formatJson, getConfigValue, getParameterValue, getPluginConfigValue, getRightOfWord, highlightTextWithBg, initializeBrowserEnvironment, isCliAccessDeniedError, joinShellWords, loadPanelPosition, nextPanelPosition, quoteShellWord, resolveConfigurationCategories, resolveHeaders, resolveServerHeaders, resolveServerWebSocketUrl, satisfiesMinVersion, satisfiesVersionRange, savePanelPosition, splitShellWords, stripAnsi, toQueryString, truncateToWidth, unquoteRawArgument, utils, visibleLength, writeExamples, writeHint, writeUsage, writeWrapped };
+export type { CliAccessAction, CliAddUser, CliBackgroundServiceStatus, CliBackgroundServiceType, CliBootOptions, CliCommandGuardResult, CliDateOptions, CliEmitOptions, CliEngineSnapshot, CliEvent, CliEventData, CliEventHandler, CliEventMap, CliEventType, CliFactoryProvider, CliFilePickerOptions, CliFileResult, CliFullScreenOptions, CliHeadersProvider, CliHelpRow, CliHttpRequestOptions, CliLineOptions, CliMultiSelectOption, CliMultiSelectOptions, CliNotification, CliNotificationLevel, CliNumberOptions, CliOptions, CliPackageSource, CliPanelConfig, CliPanelHideAlignment, CliPanelPaneState, CliPanelPosition, CliPanelState, CliPanelTabState, CliPercentageProgressBarUpdateValueOptions, CliPermissionDefinition, CliProcessCommand, CliProcessorMetadata, CliProvider, CliSelectOption, CliSelectOptions, CliServerCapabilities, CliServerCommandDescriptor, CliServerConfig, CliServerOutput, CliServerResponse, CliServiceEventHandler, CliServiceExecutionMode, CliServiceLogLevel, CliState, CliStateConfiguration, CliStateScope, CliStateStoreOptions, CliTableOptions, CliTextAnimatorOptions, CliTheme, CliThemeCategory, CliThemeInfo, CliToken, CliTypeProvider, CliUpdateUser, CliValueProvider, CliWorkerInboundMessage, CliWorkerOutboundMessage, CustomEventType, DefaultThemesType, ICliAuditEntry, ICliAuditService, ICliAuthService, ICliAuthorizationService, ICliBackgroundService, ICliBackgroundServiceInfo, ICliBackgroundServiceRegistry, ICliClipboard, ICliCommandAuthor, ICliCommandChildProcessor, ICliCommandExecutorService, ICliCommandGuard, ICliCommandParameterDescriptor, ICliCommandProcessor, ICliCommandProcessorRegistry, ICliCompletionContext, ICliCompletionProvider, ICliConfigurableModule, ICliConfigurationOption, ICliDragDropService, ICliEventBus, ICliExecutionContext, ICliExecutionProcess, ICliFileEntry, ICliFilePickerProvider, ICliFileTransferService, ICliGlobalParameterHandler, ICliGroup, ICliGroupsStoreService, ICliHttpClient, ICliInputReader, ICliKeyValueStore, ICliLogger, ICliManagedInterval, ICliManagedTimer, ICliModule, ICliNotifier, ICliOwnership, ICliPanelRef, ICliPercentageProgressBar, ICliPermissionRegistry, ICliPermissionService, ICliPingServerService, ICliPrincipal, ICliProcessEntry, ICliProcessRegisterOptions, ICliProcessRegistry, ICliProcessorHook, ICliProgressBar, ICliProtectedResource, ICliServerAuthService, ICliServerAuthTokenProvider, ICliServerManager, ICliServiceContext, ICliServiceEvent, ICliServiceLogEntry, ICliServiceProvider, ICliSessionInfo, ICliSessionsService, ICliSpinner, ICliStateStore, ICliTerminalWriter, ICliTextAnimator, ICliTranslationService, ICliUmdModule, ICliUser, ICliUserCredentials, ICliUserEvent, ICliUserEventService, ICliUserSession, ICliUserSessionService, ICliUsersStoreService, ISyntaxHighlightRule, ISyntaxHighlighter, ISyntaxTheme, LineState, Package, ServerVersionInfo, WorkerServiceContext };