@lotagate/cli 0.1.22 → 0.1.23

package/dist/domain/auth/auth-profile.js

@@ -1,39 +0,0 @@
-import { CliError } from '../errors/cli-error.js';
-import { CLI_ERROR_CODES } from '../errors/error-codes.js';
-const PROFILE_NAME_PATTERN = /^[a-z][a-z0-9_-]{0,31}$/;
-export function validateProfileName(name) {
-    const normalized = name.trim().toLowerCase();
-    if (!PROFILE_NAME_PATTERN.test(normalized)) {
-        throw new CliError(CLI_ERROR_CODES.AUTH_PROFILE_NOT_FOUND, `Invalid profile name: ${name}`, {
-            category: 'auth',
-            userMessage: 'Profile names may contain lowercase letters, digits, hyphens, or underscores; maximum 32 characters.',
-        });
-    }
-    return normalized;
-}
-export function validateBaseUrl(value) {
-    let url;
-    try {
-        url = new URL(value);
-    }
-    catch (error) {
-        throw new CliError(CLI_ERROR_CODES.AUTH_BASE_URL_INVALID, 'Base URL is invalid.', {
-            category: 'auth', userMessage: 'Invalid base URL.', cause: error,
-        });
-    }
-    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
-        throw new CliError(CLI_ERROR_CODES.AUTH_BASE_URL_INVALID, 'Base URL must use HTTP or HTTPS.', {
-            category: 'auth', userMessage: 'Base URL must use HTTP or HTTPS.',
-        });
-    }
-    return value.replace(/\/+$/, '');
-}
-export function validateApiKey(apiKey) {
-    const normalized = apiKey.trim();
-    if (normalized.length < 8 || normalized.length > 4096 || /[\r\n]/.test(normalized)) {
-        throw new CliError(CLI_ERROR_CODES.AUTH_API_KEY_INVALID, 'API key has an invalid shape.', {
-            category: 'auth', userMessage: 'API key is invalid or contains a newline.',
-        });
-    }
-    return normalized;
-}

package/dist/domain/config/config-schema.d.ts

@@ -1,17 +0,0 @@
-export declare const CONFIG_SCHEMA_VERSION = 1;
-export interface CliConfig {
-    schemaVersion: 1;
-    baseUrl: string;
-    model: string | null;
-    profile: string | null;
-    theme: 'dark' | 'light' | 'auto';
-    approvalMode: 'ask' | 'auto' | 'deny';
-    sandboxMode: 'workspace' | 'disabled';
-    telemetry: 'off' | 'opt-in';
-    updateChannel: 'stable' | 'preview';
-}
-export type ConfigurableKey = Exclude<keyof CliConfig, 'schemaVersion'>;
-export declare const CONFIGURABLE_KEYS: readonly ConfigurableKey[];
-export declare const DEFAULT_CONFIG: CliConfig;
-export declare function validateConfig(value: unknown): Partial<CliConfig>;
-export declare function mergeConfig(...layers: readonly Partial<CliConfig>[]): CliConfig;

package/dist/domain/config/config-schema.js

@@ -1,105 +0,0 @@
-import { CliError } from '../errors/cli-error.js';
-import { CLI_ERROR_CODES } from '../errors/error-codes.js';
-import { findUnexpectedRecordKey, isRecord } from '../validation/record-schema.js';
-export const CONFIG_SCHEMA_VERSION = 1;
-export const CONFIGURABLE_KEYS = [
-    'baseUrl',
-    'model',
-    'profile',
-    'theme',
-    'approvalMode',
-    'sandboxMode',
-    'telemetry',
-    'updateChannel',
-];
-const CONFIG_KEYS = ['schemaVersion', ...CONFIGURABLE_KEYS];
-export const DEFAULT_CONFIG = {
-    schemaVersion: CONFIG_SCHEMA_VERSION,
-    baseUrl: 'https://api.lotagate.com',
-    model: null,
-    profile: null,
-    theme: 'dark',
-    approvalMode: 'ask',
-    sandboxMode: 'workspace',
-    telemetry: 'off',
-    updateChannel: 'stable',
-};
-function assertString(value, field) {
-    if (typeof value !== 'string' || value.trim().length === 0) {
-        throw new CliError(CLI_ERROR_CODES.CONFIG_SCHEMA_INVALID, `Invalid config field: ${field}`, {
-            category: 'config',
-            userMessage: `Invalid configuration: field \`${field}\` must be a non-empty string.`,
-        });
-    }
-}
-export function validateConfig(value) {
-    if (!isRecord(value)) {
-        throw new CliError(CLI_ERROR_CODES.CONFIG_SCHEMA_INVALID, 'Config must be a JSON object.', {
-            category: 'config',
-            userMessage: 'Configuration file must contain a JSON object.',
-        });
-    }
-    const unexpectedKey = findUnexpectedRecordKey(value, CONFIG_KEYS);
-    if (unexpectedKey !== undefined)
-        throw invalidConfig(`Unsupported configuration field: \`${unexpectedKey}\`.`);
-    if (value['schemaVersion'] !== undefined && value['schemaVersion'] !== CONFIG_SCHEMA_VERSION) {
-        throw new CliError(CLI_ERROR_CODES.CONFIG_SCHEMA_INVALID, 'Unsupported config schema version.', {
-            category: 'config',
-            userMessage: `Unsupported configuration schema version: ${String(value['schemaVersion'])}.`,
-        });
-    }
-    const baseUrl = value['baseUrl'];
-    if (baseUrl !== undefined) {
-        assertString(baseUrl, 'baseUrl');
-        try {
-            new URL(baseUrl);
-        }
-        catch (error) {
-            throw new CliError(CLI_ERROR_CODES.CONFIG_SCHEMA_INVALID, 'baseUrl must be a valid URL.', {
-                category: 'config', userMessage: 'baseUrl must be a valid URL.', cause: error,
-            });
-        }
-    }
-    const modelValue = value['model'];
-    const profileValue = value['profile'];
-    if (modelValue !== undefined && modelValue !== null)
-        assertString(modelValue, 'model');
-    if (profileValue !== undefined && profileValue !== null)
-        assertString(profileValue, 'profile');
-    if (typeof modelValue === 'string' && modelValue.length > 256) {
-        throw new CliError(CLI_ERROR_CODES.CONFIG_SCHEMA_INVALID, 'Model id is too long.', {
-            category: 'config', userMessage: 'Model id must not exceed 256 characters.',
-        });
-    }
-    const theme = parseEnum(value['theme'], 'theme', ['dark', 'light', 'auto']);
-    const approvalMode = parseEnum(value['approvalMode'], 'approvalMode', ['ask', 'auto', 'deny']);
-    const sandboxMode = parseEnum(value['sandboxMode'], 'sandboxMode', ['workspace', 'disabled']);
-    const telemetry = parseEnum(value['telemetry'], 'telemetry', ['off', 'opt-in']);
-    const updateChannel = parseEnum(value['updateChannel'], 'updateChannel', ['stable', 'preview']);
-    return {
-        ...(value['schemaVersion'] === undefined ? {} : { schemaVersion: CONFIG_SCHEMA_VERSION }),
-        ...(baseUrl === undefined ? {} : { baseUrl }),
-        ...(modelValue === undefined ? {} : { model: modelValue }),
-        ...(profileValue === undefined ? {} : { profile: profileValue }),
-        ...(theme === undefined ? {} : { theme }),
-        ...(approvalMode === undefined ? {} : { approvalMode }),
-        ...(sandboxMode === undefined ? {} : { sandboxMode }),
-        ...(telemetry === undefined ? {} : { telemetry }),
-        ...(updateChannel === undefined ? {} : { updateChannel }),
-    };
-}
-export function mergeConfig(...layers) {
-    const merged = layers.reduce((result, layer) => ({ ...result, ...layer }), {});
-    return { ...DEFAULT_CONFIG, ...validateConfig(merged), schemaVersion: CONFIG_SCHEMA_VERSION };
-}
-function parseEnum(value, field, values) {
-    if (value === undefined)
-        return undefined;
-    if (typeof value !== 'string' || !values.includes(value)) {
-        throw invalidConfig(`Invalid configuration: value for \`${field}\` is not supported.`);
-    }
-    return value;
-}
-function invalidConfig(userMessage) {
-    return new CliError(CLI_ERROR_CODES.CONFIG_SCHEMA_INVALID, userMessage, { category: 'config', userMessage });
-}

package/dist/domain/errors/cli-command-hint.d.ts

@@ -1,5 +0,0 @@
-export interface CliCommandHint {
-    /** Runtime command action identifiers, resolved by the shared command catalog. */
-    readonly actionId: string;
-    readonly tuiActionId?: string;
-}

package/dist/domain/errors/cli-command-hint.js

@@ -1 +0,0 @@
-export {};

package/dist/domain/errors/cli-error.d.ts

@@ -1,35 +0,0 @@
-import type { CliErrorCode } from './error-codes.js';
-import type { CliCommandHint } from './cli-command-hint.js';
-export interface CliErrorOptions {
-    category: string;
-    userMessage?: string;
-    retryable?: boolean;
-    exitCode?: number;
-    correlationId?: string;
-    details?: Record<string, unknown>;
-    hint?: CliCommandHint;
-    cause?: unknown;
-}
-export interface CliErrorShape {
-    code: CliErrorCode | string;
-    category: string;
-    message: string;
-    userMessage: string;
-    retryable: boolean;
-    exitCode: number;
-    correlationId?: string;
-    details?: Record<string, unknown>;
-}
-export declare class CliError extends Error {
-    readonly code: CliErrorCode | string;
-    readonly category: string;
-    readonly userMessage: string;
-    readonly retryable: boolean;
-    readonly exitCode: number;
-    readonly correlationId: string | undefined;
-    readonly details: Record<string, unknown> | undefined;
-    readonly hint: CliCommandHint | undefined;
-    constructor(code: CliErrorCode | string, message: string, options: CliErrorOptions);
-    toJSON(): CliErrorShape;
-}
-export declare function asCliError(error: unknown): CliError;

package/dist/domain/errors/cli-error.js

@@ -1,129 +0,0 @@
-import { CLI_ERROR_CODES } from './error-codes.js';
-export class CliError extends Error {
-    code;
-    category;
-    userMessage;
-    retryable;
-    exitCode;
-    correlationId;
-    details;
-    hint;
-    constructor(code, message, options) {
-        super(message, { cause: options.cause });
-        this.name = 'CliError';
-        this.code = code;
-        this.category = options.category;
-        this.userMessage = options.userMessage ?? message;
-        this.retryable = options.retryable ?? false;
-        this.exitCode = options.exitCode ?? 1;
-        this.correlationId = options.correlationId;
-        this.details = options.details;
-        this.hint = options.hint;
-    }
-    toJSON() {
-        return {
-            code: this.code,
-            category: this.category,
-            message: this.message,
-            userMessage: this.userMessage,
-            retryable: this.retryable,
-            exitCode: this.exitCode,
-            ...(this.correlationId !== undefined ? { correlationId: this.correlationId } : {}),
-            ...(this.details !== undefined ? { details: this.details } : {}),
-        };
-    }
-}
-export function asCliError(error) {
-    if (error instanceof CliError)
-        return error;
-    const code = readExternalErrorCode(error);
-    const external = readExternalError(error);
-    if (code === 'REQUEST_ABORTED') {
-        return new CliError(CLI_ERROR_CODES.INTERRUPTED, errorMessage(error), {
-            category: 'media', userMessage: 'The request was interrupted.', retryable: true,
-            ...external, cause: error,
-        });
-    }
-    if (code === 'REQUEST_TIMEOUT' || code === 'NETWORK_ERROR') {
-        return new CliError(CLI_ERROR_CODES.MEDIA_REQUEST_FAILED, errorMessage(error), {
-            category: 'media', userMessage: 'The media request could not be completed. Retry the request; if it persists, check the selected model, credentials, and network connection.', retryable: true,
-            ...external, cause: error,
-        });
-    }
-    if (code === 'REQUEST_VALIDATION_ERROR' || code === 'REQUEST_PAYLOAD_TOO_LARGE') {
-        return new CliError(CLI_ERROR_CODES.INVALID_ARGUMENT, errorMessage(error), {
-            category: 'media', userMessage: 'The media request does not satisfy a gateway validation limit. Review the command options and input file size.',
-            ...external, cause: error,
-        });
-    }
-    if (code === 'RESPONSE_TOO_LARGE') {
-        return new CliError(CLI_ERROR_CODES.MEDIA_RESPONSE_TOO_LARGE, errorMessage(error), {
-            category: 'media', userMessage: 'The generated media exceeds the supported download size.', retryable: false,
-            ...external, cause: error,
-        });
-    }
-    if (code === 'TOOL_ARGUMENTS_INVALID') {
-        return new CliError(CLI_ERROR_CODES.TOOL_ARGUMENT_INVALID, errorMessage(error), {
-            category: 'tool',
-            userMessage: 'The selected model returned malformed tool arguments. Retry the request or choose a model with reliable tool-calling support.',
-            retryable: true,
-            cause: error,
-        });
-    }
-    if (code === 'TOOL_NOT_FOUND') {
-        return new CliError(CLI_ERROR_CODES.MODEL_STREAM_FAILED, errorMessage(error), {
-            category: 'model',
-            userMessage: 'The selected model requested a tool that is unavailable in this CLI session. Retry the request or choose another model.',
-            retryable: true,
-            cause: error,
-        });
-    }
-    if (code === 'AGENT_LIMIT_EXCEEDED') {
-        return new CliError(CLI_ERROR_CODES.AGENT_STUCK, errorMessage(error), {
-            category: 'agent',
-            userMessage: 'The agent reached a safety limit before completing. Narrow the task and try again.',
-            retryable: true,
-            cause: error,
-        });
-    }
-    if (code === 'MODEL_RESPONSE_INVALID' || isProviderFailure(error)) {
-        return new CliError(CLI_ERROR_CODES.MODEL_STREAM_FAILED, errorMessage(error), {
-            category: 'model',
-            userMessage: 'The model provider could not complete the request. Retry; if it persists, check the selected model, credentials, and base URL.',
-            retryable: true,
-            cause: error,
-        });
-    }
-    return new CliError(CLI_ERROR_CODES.INTERNAL_ERROR, error instanceof Error ? error.message : String(error), {
-        category: 'general',
-        userMessage: 'An internal error occurred.',
-        hint: { actionId: 'doctor' },
-        cause: error,
-    });
-}
-function readExternalErrorCode(error) {
-    if (typeof error !== 'object' || error === null)
-        return undefined;
-    const value = error;
-    if (typeof value['code'] === 'string')
-        return value['code'];
-    return typeof value['errorCode'] === 'string' ? value['errorCode'] : undefined;
-}
-function readExternalError(error) {
-    if (typeof error !== 'object' || error === null)
-        return {};
-    const value = error;
-    return {
-        ...(typeof value['correlationId'] === 'string' ? { correlationId: value['correlationId'] } : {}),
-        ...(isDetails(value['details']) ? { details: value['details'] } : {}),
-    };
-}
-function isDetails(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function isProviderFailure(error) {
-    return errorMessage(error) === 'Upstream AI provider request failed.';
-}
-function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/dist/domain/errors/error-codes.d.ts

@@ -1,46 +0,0 @@
-export declare const CLI_ERROR_CODES: {
-    readonly INVALID_ARGUMENT: "CLI_INVALID_ARGUMENT";
-    readonly MISSING_ARGUMENT: "CLI_MISSING_ARGUMENT";
-    readonly INTERRUPTED: "CLI_INTERRUPTED";
-    readonly INTERNAL_ERROR: "CLI_INTERNAL_ERROR";
-    readonly CONFIG_NOT_FOUND: "CONFIG_NOT_FOUND";
-    readonly CONFIG_INVALID_JSON: "CONFIG_INVALID_JSON";
-    readonly CONFIG_SCHEMA_INVALID: "CONFIG_SCHEMA_INVALID";
-    readonly CONFIG_LOCKED: "CONFIG_LOCKED";
-    readonly PROJECT_PATH_INVALID: "PROJECT_PATH_INVALID";
-    readonly AUTH_API_KEY_INVALID: "AUTH_API_KEY_INVALID";
-    readonly AUTH_PROFILE_NOT_FOUND: "AUTH_PROFILE_NOT_FOUND";
-    readonly AUTH_CREDENTIAL_STORE_UNAVAILABLE: "AUTH_CREDENTIAL_STORE_UNAVAILABLE";
-    readonly AUTH_BASE_URL_INVALID: "AUTH_BASE_URL_INVALID";
-    readonly PROJECT_TRUST_REQUIRED: "PROJECT_TRUST_REQUIRED";
-    readonly MODEL_NOT_FOUND: "MODEL_NOT_FOUND";
-    readonly MODEL_STREAM_FAILED: "MODEL_STREAM_FAILED";
-    readonly MODEL_EMPTY_RESPONSE: "MODEL_EMPTY_RESPONSE";
-    readonly MODEL_PROTOCOL_EMPTY_RESPONSE: "MODEL_PROTOCOL_EMPTY_RESPONSE";
-    readonly MEDIA_REQUEST_FAILED: "MEDIA_REQUEST_FAILED";
-    readonly MEDIA_RESPONSE_TOO_LARGE: "MEDIA_RESPONSE_TOO_LARGE";
-    readonly MODEL_EMPTY_FINAL: "MODEL_EMPTY_FINAL";
-    readonly AGENT_STUCK: "AGENT_STUCK";
-    readonly ATTACHMENT_CLIPBOARD_UNAVAILABLE: "ATTACHMENT_CLIPBOARD_UNAVAILABLE";
-    readonly ATTACHMENT_FORMAT_UNSUPPORTED: "ATTACHMENT_FORMAT_UNSUPPORTED";
-    readonly ATTACHMENT_TOO_LARGE: "ATTACHMENT_TOO_LARGE";
-    readonly ATTACHMENT_INVALID_IMAGE: "ATTACHMENT_INVALID_IMAGE";
-    readonly TOOL_ARGUMENT_INVALID: "TOOL_ARGUMENT_INVALID";
-    readonly PROJECT_SYMLINK_ESCAPE: "PROJECT_SYMLINK_ESCAPE";
-    readonly SESSION_NOT_FOUND: "SESSION_NOT_FOUND";
-    readonly SESSION_LOCKED: "SESSION_LOCKED";
-    readonly SESSION_CORRUPTED: "SESSION_CORRUPTED";
-    readonly TASK_DEPENDENCY_CYCLE: "TASK_DEPENDENCY_CYCLE";
-    readonly TASK_SCHEDULER_OVERLOADED: "TASK_SCHEDULER_OVERLOADED";
-    readonly TASK_PLAN_APPROVAL_REQUIRED: "TASK_PLAN_APPROVAL_REQUIRED";
-    readonly PLUGIN_MANIFEST_INVALID: "PLUGIN_MANIFEST_INVALID";
-    readonly PLUGIN_NOT_FOUND: "PLUGIN_NOT_FOUND";
-    readonly SKILL_FRONTMATTER_INVALID: "SKILL_FRONTMATTER_INVALID";
-    readonly SKILL_NOT_FOUND: "SKILL_NOT_FOUND";
-    readonly MCP_CONFIG_INVALID: "MCP_CONFIG_INVALID";
-    readonly MCP_SERVER_NOT_FOUND: "MCP_SERVER_NOT_FOUND";
-    readonly GOAL_NOT_FOUND: "GOAL_NOT_FOUND";
-    readonly GOAL_INVALID_STATE: "GOAL_INVALID_STATE";
-    readonly GOAL_LIMIT_REACHED: "GOAL_LIMIT_REACHED";
-};
-export type CliErrorCode = (typeof CLI_ERROR_CODES)[keyof typeof CLI_ERROR_CODES];

package/dist/domain/errors/error-codes.js

@@ -1,45 +0,0 @@
-export const CLI_ERROR_CODES = {
-    INVALID_ARGUMENT: 'CLI_INVALID_ARGUMENT',
-    MISSING_ARGUMENT: 'CLI_MISSING_ARGUMENT',
-    INTERRUPTED: 'CLI_INTERRUPTED',
-    INTERNAL_ERROR: 'CLI_INTERNAL_ERROR',
-    CONFIG_NOT_FOUND: 'CONFIG_NOT_FOUND',
-    CONFIG_INVALID_JSON: 'CONFIG_INVALID_JSON',
-    CONFIG_SCHEMA_INVALID: 'CONFIG_SCHEMA_INVALID',
-    CONFIG_LOCKED: 'CONFIG_LOCKED',
-    PROJECT_PATH_INVALID: 'PROJECT_PATH_INVALID',
-    AUTH_API_KEY_INVALID: 'AUTH_API_KEY_INVALID',
-    AUTH_PROFILE_NOT_FOUND: 'AUTH_PROFILE_NOT_FOUND',
-    AUTH_CREDENTIAL_STORE_UNAVAILABLE: 'AUTH_CREDENTIAL_STORE_UNAVAILABLE',
-    AUTH_BASE_URL_INVALID: 'AUTH_BASE_URL_INVALID',
-    PROJECT_TRUST_REQUIRED: 'PROJECT_TRUST_REQUIRED',
-    MODEL_NOT_FOUND: 'MODEL_NOT_FOUND',
-    MODEL_STREAM_FAILED: 'MODEL_STREAM_FAILED',
-    MODEL_EMPTY_RESPONSE: 'MODEL_EMPTY_RESPONSE',
-    MODEL_PROTOCOL_EMPTY_RESPONSE: 'MODEL_PROTOCOL_EMPTY_RESPONSE',
-    MEDIA_REQUEST_FAILED: 'MEDIA_REQUEST_FAILED',
-    MEDIA_RESPONSE_TOO_LARGE: 'MEDIA_RESPONSE_TOO_LARGE',
-    MODEL_EMPTY_FINAL: 'MODEL_EMPTY_FINAL',
-    AGENT_STUCK: 'AGENT_STUCK',
-    ATTACHMENT_CLIPBOARD_UNAVAILABLE: 'ATTACHMENT_CLIPBOARD_UNAVAILABLE',
-    ATTACHMENT_FORMAT_UNSUPPORTED: 'ATTACHMENT_FORMAT_UNSUPPORTED',
-    ATTACHMENT_TOO_LARGE: 'ATTACHMENT_TOO_LARGE',
-    ATTACHMENT_INVALID_IMAGE: 'ATTACHMENT_INVALID_IMAGE',
-    TOOL_ARGUMENT_INVALID: 'TOOL_ARGUMENT_INVALID',
-    PROJECT_SYMLINK_ESCAPE: 'PROJECT_SYMLINK_ESCAPE',
-    SESSION_NOT_FOUND: 'SESSION_NOT_FOUND',
-    SESSION_LOCKED: 'SESSION_LOCKED',
-    SESSION_CORRUPTED: 'SESSION_CORRUPTED',
-    TASK_DEPENDENCY_CYCLE: 'TASK_DEPENDENCY_CYCLE',
-    TASK_SCHEDULER_OVERLOADED: 'TASK_SCHEDULER_OVERLOADED',
-    TASK_PLAN_APPROVAL_REQUIRED: 'TASK_PLAN_APPROVAL_REQUIRED',
-    PLUGIN_MANIFEST_INVALID: 'PLUGIN_MANIFEST_INVALID',
-    PLUGIN_NOT_FOUND: 'PLUGIN_NOT_FOUND',
-    SKILL_FRONTMATTER_INVALID: 'SKILL_FRONTMATTER_INVALID',
-    SKILL_NOT_FOUND: 'SKILL_NOT_FOUND',
-    MCP_CONFIG_INVALID: 'MCP_CONFIG_INVALID',
-    MCP_SERVER_NOT_FOUND: 'MCP_SERVER_NOT_FOUND',
-    GOAL_NOT_FOUND: 'GOAL_NOT_FOUND',
-    GOAL_INVALID_STATE: 'GOAL_INVALID_STATE',
-    GOAL_LIMIT_REACHED: 'GOAL_LIMIT_REACHED',
-};

package/dist/domain/extensions/extension-scope.d.ts

@@ -1,3 +0,0 @@
-export type ExtensionScope = 'user' | 'project';
-export declare function parseExtensionScope(value: string | boolean | undefined): ExtensionScope | undefined;
-export declare function requireExtensionScope(value: string | boolean | undefined): ExtensionScope;

package/dist/domain/extensions/extension-scope.js

@@ -1,23 +0,0 @@
-import { CliError } from '../errors/cli-error.js';
-import { CLI_ERROR_CODES } from '../errors/error-codes.js';
-export function parseExtensionScope(value) {
-    if (value === undefined)
-        return undefined;
-    if (typeof value !== 'string' || (value !== 'user' && value !== 'project')) {
-        throw new CliError(CLI_ERROR_CODES.INVALID_ARGUMENT, 'Extension scope must be user or project.', {
-            category: 'arguments',
-            userMessage: 'Invalid scope. Use --scope user or --scope project.',
-        });
-    }
-    return value;
-}
-export function requireExtensionScope(value) {
-    const scope = parseExtensionScope(value);
-    if (scope === undefined) {
-        throw new CliError(CLI_ERROR_CODES.MISSING_ARGUMENT, 'Extension scope is required for non-interactive commands.', {
-            category: 'arguments',
-            userMessage: 'Choose a scope interactively or pass --scope user|project.',
-        });
-    }
-    return scope;
-}

package/dist/domain/extensions/extension-state.d.ts

@@ -1,5 +0,0 @@
-export interface ExtensionStateEntry {
-    enabled: boolean;
-}
-export type ExtensionState = Record<string, ExtensionStateEntry>;
-export declare function parseExtensionState(value: unknown): ExtensionState;

package/dist/domain/extensions/extension-state.js

@@ -1,11 +0,0 @@
-export function parseExtensionState(value) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value))
-        throw new Error('Extension state must be an object.');
-    const state = {};
-    for (const [name, entry] of Object.entries(value)) {
-        if (typeof entry !== 'object' || entry === null || Array.isArray(entry) || typeof entry['enabled'] !== 'boolean')
-            throw new Error(`Invalid extension state entry: ${name}.`);
-        state[name] = { enabled: entry['enabled'] };
-    }
-    return state;
-}

package/dist/domain/extensions/hook-manifest.d.ts

@@ -1,10 +0,0 @@
-export type HookEvent = 'session.start' | 'prompt.before' | 'tool.before' | 'tool.after' | 'response.after' | 'session.end';
-export interface HookDefinition {
-    id: string;
-    event: HookEvent;
-    command: string;
-    args: readonly string[];
-    timeoutMs: number;
-    directory: string;
-}
-export declare function parseHookDefinition(value: unknown, directory: string, id: string): HookDefinition;

package/dist/domain/extensions/hook-manifest.js

@@ -1,23 +0,0 @@
-import { CliError } from '../errors/cli-error.js';
-import { CLI_ERROR_CODES } from '../errors/error-codes.js';
-export function parseHookDefinition(value, directory, id) {
-    if (typeof value !== 'object' || value === null)
-        throw invalidHook('Hook must be a JSON object.');
-    const record = value;
-    const event = record['event'];
-    const command = record['command'];
-    const args = record['args'];
-    const timeoutMs = record['timeoutMs'];
-    if (!isHookEvent(event))
-        throw invalidHook('Hook event is not supported.');
-    if (typeof command !== 'string' || command.trim().length === 0 || /[\r\n]/u.test(command))
-        throw invalidHook('Hook command is invalid.');
-    if (args !== undefined && (!Array.isArray(args) || args.some((item) => typeof item !== 'string')))
-        throw invalidHook('Hook args must be strings.');
-    const timeout = timeoutMs === undefined ? 10_000 : timeoutMs;
-    if (typeof timeout !== 'number' || !Number.isInteger(timeout) || timeout < 100 || timeout > 120_000)
-        throw invalidHook('Hook timeout must be between 100 and 120000 milliseconds.');
-    return { id, event, command, args: (args ?? []), timeoutMs: timeout, directory };
-}
-function isHookEvent(value) { return typeof value === 'string' && ['session.start', 'prompt.before', 'tool.before', 'tool.after', 'response.after', 'session.end'].includes(value); }
-function invalidHook(message) { return new CliError(CLI_ERROR_CODES.PLUGIN_MANIFEST_INVALID, message, { category: 'extension', userMessage: `Invalid hook: ${message}` }); }

package/dist/domain/extensions/mcp-config.d.ts

@@ -1,18 +0,0 @@
-import type { McpServerConfig } from '@lotagate/agent-sdk';
-/** Persistable subset of the public Agent SDK MCP contract. */
-export type CliMcpServerConfig = McpServerConfig;
-export interface CliMcpServerEntry {
-    enabled: boolean;
-    config: CliMcpServerConfig;
-}
-export type CliMcpConfig = Record<string, CliMcpServerEntry>;
-export declare function mergeMcpConfigs(...configs: readonly CliMcpConfig[]): CliMcpConfig;
-/**
- * Combines ordered configuration layers where a later, more specific layer
- * overrides an earlier one. Runtime callers pass user scope before project
- * scope so a trusted project can intentionally override a global server with
- * the same name.
- */
-export declare function mergeMcpConfigsWithOverride(...configs: readonly CliMcpConfig[]): CliMcpConfig;
-export declare function validateMcpName(name: string): string;
-export declare function validateMcpConfig(value: unknown): CliMcpConfig;

package/dist/domain/extensions/mcp-config.js

@@ -1,111 +0,0 @@
-import { CliError } from '../errors/cli-error.js';
-import { CLI_ERROR_CODES } from '../errors/error-codes.js';
-export function mergeMcpConfigs(...configs) {
-    const merged = {};
-    for (const config of configs) {
-        for (const [name, entry] of Object.entries(config)) {
-            if (merged[name] !== undefined)
-                throw invalid(`MCP server is defined more than once: ${name}.`);
-            merged[name] = entry;
-        }
-    }
-    return merged;
-}
-/**
- * Combines ordered configuration layers where a later, more specific layer
- * overrides an earlier one. Runtime callers pass user scope before project
- * scope so a trusted project can intentionally override a global server with
- * the same name.
- */
-export function mergeMcpConfigsWithOverride(...configs) {
-    const merged = {};
-    for (const config of configs)
-        Object.assign(merged, config);
-    return merged;
-}
-export function validateMcpName(name) {
-    const normalized = name.trim().toLowerCase();
-    if (!/^[a-z][a-z0-9_-]{0,63}$/.test(normalized))
-        throw invalid('MCP server name must be lowercase and <= 64 characters.');
-    return normalized;
-}
-export function validateMcpConfig(value) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value))
-        throw invalid('MCP config must be an object.');
-    const result = {};
-    for (const [rawName, rawEntry] of Object.entries(value)) {
-        const name = validateMcpName(rawName);
-        if (typeof rawEntry !== 'object' || rawEntry === null || Array.isArray(rawEntry))
-            throw invalid(`Invalid MCP entry: ${name}.`);
-        const entry = rawEntry;
-        if (typeof entry['enabled'] !== 'boolean' || typeof entry['config'] !== 'object' || entry['config'] === null)
-            throw invalid(`Invalid MCP entry: ${name}.`);
-        result[name] = { enabled: entry['enabled'], config: validateServerConfig(entry['config']) };
-    }
-    return result;
-}
-function validateServerConfig(value) {
-    const config = value;
-    const type = config['type'];
-    if (type === 'stdio') {
-        if (typeof config['command'] !== 'string' || config['command'].trim().length === 0 || /[\r\n]/.test(config['command']))
-            throw invalid('stdio MCP command is invalid.');
-        if (config['args'] !== undefined && (!Array.isArray(config['args']) || config['args'].some((arg) => typeof arg !== 'string')))
-            throw invalid('stdio MCP args must be strings.');
-        return {
-            type,
-            command: config['command'],
-            ...(config['args'] === undefined ? {} : { args: config['args'] }),
-            ...(config['env'] === undefined ? {} : { env: validateStringMap(config['env'], 'stdio env') }),
-            ...(config['cwd'] === undefined ? {} : { cwd: requireString(config['cwd'], 'stdio cwd') }),
-            ...(config['maxBufferSize'] === undefined ? {} : { maxBufferSize: validatePositiveInteger(config['maxBufferSize'], 'stdio maxBufferSize') }),
-        };
-    }
-    if (type === 'http' || type === 'sse') {
-        if (typeof config['url'] !== 'string')
-            throw invalid('HTTP MCP URL is required.');
-        try {
-            const url = new URL(config['url']);
-            if (!['http:', 'https:'].includes(url.protocol))
-                throw new Error('protocol');
-        }
-        catch (error) {
-            throw invalid('HTTP MCP URL must use HTTP or HTTPS.', error);
-        }
-        return {
-            type,
-            url: config['url'],
-            ...(config['headers'] === undefined ? {} : { headers: validateStringMap(config['headers'], 'HTTP headers') }),
-            ...(config['auth'] === undefined ? {} : { auth: validatePersistedAuth(config['auth']) }),
-        };
-    }
-    throw invalid('MCP type must be stdio, http or sse.');
-}
-function requireString(value, field) { if (typeof value !== 'string' || value.length === 0)
-    throw invalid(`${field} must be a non-empty string.`); return value; }
-function validatePositiveInteger(value, field) {
-    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0)
-        throw invalid(`${field} must be a positive integer.`);
-    return value;
-}
-function validatePersistedAuth(value) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value))
-        throw invalid('HTTP auth must be a bearer token configuration.');
-    const auth = value;
-    if (auth['type'] !== 'bearer' || typeof auth['token'] !== 'string' || auth['token'].length === 0 || /[\r\n]/u.test(auth['token'])) {
-        throw invalid('HTTP auth must be a non-empty bearer token configuration.');
-    }
-    return { type: 'bearer', token: auth['token'] };
-}
-function validateStringMap(value, field) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value))
-        throw invalid(`${field} must be an object of strings.`);
-    const result = {};
-    for (const [key, rawValue] of Object.entries(value)) {
-        if (key.length === 0 || typeof rawValue !== 'string' || /[\r\n]/u.test(key) || /[\r\n]/u.test(rawValue))
-            throw invalid(`${field} must contain valid string key/value pairs.`);
-        result[key] = rawValue;
-    }
-    return result;
-}
-function invalid(message, cause) { return new CliError(CLI_ERROR_CODES.MCP_CONFIG_INVALID, message, { category: 'mcp', userMessage: `Invalid MCP configuration: ${message}`, cause }); }

package/dist/domain/extensions/plugin-manifest.d.ts

@@ -1,11 +0,0 @@
-export interface PluginManifest {
-    name: string;
-    version: string;
-    description?: string;
-    directory: string;
-    skillsDirectory?: string;
-    agentsDirectory?: string;
-    hooksDirectory?: string;
-    mcpConfig?: string;
-}
-export declare function parsePluginManifest(value: unknown, directory: string): PluginManifest;