@lotagate/cli 0.1.20 → 0.1.22

package/dist/application/commands/application-command-executor.js

@@ -0,0 +1,66 @@
+import { runAgentCommand } from '../protocol/jsonl-agent-command.js';
+import { runAuthCommand, runConfigCommand, runHookCommand, runMcpCommand, runModelCommand, runPluginCommand, runSkillCommand, runTrustCommand } from './cli-command-services.js';
+import { formatCommandHelp } from './command-presentation.js';
+import { COMMAND_REGISTRY } from './command-runtime.js';
+import { runGoalCommand } from './goal-command-handlers.js';
+import { runChatCommand, runExecCommand, runSessionCommand } from './runtime-command-handlers.js';
+import { runMediaCommand } from './media-command-handlers.js';
+import { runCompletionsCommand, runDoctorCommand, runInspectCommand, runUpdateCommand } from './utility-commands.js';
+import { CLI_VERSION } from '../../version.js';
+const EXECUTORS = {
+    help: async (invocation, host) => requireInformationalCommand(invocation, host.output),
+    version: async (invocation, host) => requireInformationalCommand(invocation, host.output),
+    config: async (invocation, host) => runConfigCommand(invocation.handlerPositionals, host.runtime.configLoader, host.cwd, host.output),
+    auth: async (invocation, host) => runAuthCommand(invocation.handlerPositionals, invocation.options, host.runtime, host.cwd, host.output),
+    trust: async (invocation, host) => runTrustCommand(invocation.handlerPositionals, host.runtime, host.cwd, host.output),
+    inspect: async (_invocation, host) => runInspectCommand(host.runtime, host.cwd, host.output),
+    hook: async (invocation, host) => runHookCommand(invocation.handlerPositionals, host.runtime, host.cwd, host.output),
+    model: async (invocation, host) => runModelCommand(invocation.handlerPositionals, host.runtime, host.cwd, host.output),
+    mcp: async (invocation, host) => runMcpCommand(invocation.handlerPositionals, invocation.options, host.runtime, host.cwd, host.output, scopeInteraction(host)),
+    plugin: async (invocation, host) => runPluginCommand(invocation.handlerPositionals, invocation.options, host.runtime, host.cwd, host.output, scopeInteraction(host)),
+    skill: async (invocation, host) => runSkillCommand(invocation.handlerPositionals, invocation.options, host.runtime, host.cwd, host.output, scopeInteraction(host)),
+    session: async (invocation, host) => runSessionCommand(invocation.handlerPositionals, invocation.options, host.runtime, host.cwd, host.output, host.resumeInteractive),
+    goal: async (invocation, host) => {
+        if (host.writableOutput === undefined)
+            throw new Error('Goal commands require a writable terminal output.');
+        return runGoalCommand(invocation.handlerPositionals, invocation.options, host.runtime, host.cwd, host.writableOutput);
+    },
+    doctor: async (_invocation, host) => runDoctorCommand(host.runtime, host.cwd, host.output),
+    chat: async (invocation, host) => runChatCommand(invocation.handlerPositionals, host.runtime, host.cwd, host.output),
+    exec: async (invocation, host) => runExecCommand(invocation.handlerPositionals, invocation.options, host.runtime, host.cwd, host.output),
+    media: async (invocation, host) => runMediaCommand(invocation, host.runtime, host.cwd, host.output, host.activity, host.signal),
+    agent: async (invocation, host) => {
+        if (host.stdin === undefined || host.writableOutput === undefined)
+            throw new Error('The JSONL agent protocol requires stdin and a writable terminal output.');
+        return runAgentCommand(invocation.handlerPositionals, host.runtime, host.cwd, host.stdin, host.writableOutput);
+    },
+    completions: async (invocation, host) => runCompletionsCommand(invocation.handlerPositionals, host.output),
+    update: async (invocation, host) => runUpdateCommand(invocation.handlerPositionals, host.runtime, host.cwd, host.output),
+};
+export async function executeApplicationCommand(invocation, host) {
+    const executor = EXECUTORS[invocation.action.executor];
+    if (executor === undefined)
+        throw new Error(`Command ${invocation.action.id} requires a ${invocation.surface}-specific executor.`);
+    return executor(invocation, host);
+}
+/** Runs commands that do not require a runtime or any persistent CLI state. */
+export function executeInformationalCommand(invocation, output) {
+    if (invocation.action.executor === 'help') {
+        output.write(`${formatCommandHelp(COMMAND_REGISTRY, invocation.surface)}\n`);
+        return 0;
+    }
+    if (invocation.action.executor === 'version') {
+        output.write(`${CLI_VERSION}\n`);
+        return 0;
+    }
+    return undefined;
+}
+function requireInformationalCommand(invocation, output) {
+    const exitCode = executeInformationalCommand(invocation, output);
+    if (exitCode === undefined)
+        throw new Error(`Command ${invocation.action.id} is not informational.`);
+    return exitCode;
+}
+function scopeInteraction(host) {
+    return host.selectScope === undefined ? {} : { selectScope: host.selectScope };
+}

package/dist/application/commands/cli-args.d.ts

@@ -0,0 +1,6 @@
+export declare function getFlag(flags: ReadonlyMap<string, string | boolean>, name: string): string | boolean | undefined;
+export declare function isFlagEnabled(flags: ReadonlyMap<string, string | boolean>, name: string): boolean;
+export declare function getStringFlag(flags: ReadonlyMap<string, string | boolean>, name: string): string | undefined;
+export declare function requireStringFlag(flags: ReadonlyMap<string, string | boolean>, name: string): string;
+export declare function getPositiveIntegerFlag(flags: ReadonlyMap<string, string | boolean>, name: string, maximum: number): number | undefined;
+export declare function requirePositional(positionals: readonly string[], index: number, label: string): string;

package/dist/application/commands/cli-args.js

@@ -0,0 +1,43 @@
+import { CliError } from '../../domain/errors/cli-error.js';
+import { CLI_ERROR_CODES } from '../../domain/errors/error-codes.js';
+export function getFlag(flags, name) {
+    return flags.get(name);
+}
+export function isFlagEnabled(flags, name) {
+    const value = flags.get(name);
+    return value === true || value === 'true';
+}
+export function getStringFlag(flags, name) {
+    const value = getFlag(flags, name);
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
+}
+export function requireStringFlag(flags, name) {
+    const value = getStringFlag(flags, name);
+    if (value === undefined) {
+        throw new CliError(CLI_ERROR_CODES.MISSING_ARGUMENT, `Missing --${name}.`, {
+            category: 'arguments', userMessage: `Missing required option --${name}.`,
+        });
+    }
+    return value;
+}
+export function getPositiveIntegerFlag(flags, name, maximum) {
+    const value = getFlag(flags, name);
+    if (value === undefined)
+        return undefined;
+    const parsed = typeof value === 'string' && /^\d+$/u.test(value) ? Number(value) : Number.NaN;
+    if (!Number.isSafeInteger(parsed) || parsed <= 0 || parsed > maximum) {
+        throw new CliError(CLI_ERROR_CODES.INVALID_ARGUMENT, `Invalid --${name}.`, {
+            category: 'arguments', userMessage: `--${name} must be a positive integer no greater than ${maximum}.`,
+        });
+    }
+    return parsed;
+}
+export function requirePositional(positionals, index, label) {
+    const value = positionals[index];
+    if (value === undefined || value.trim().length === 0) {
+        throw new CliError(CLI_ERROR_CODES.MISSING_ARGUMENT, `Missing ${label}.`, {
+            category: 'arguments', userMessage: `Missing required argument: ${label}.`,
+        });
+    }
+    return value;
+}

package/dist/application/commands/cli-command-services.d.ts

@@ -0,0 +1,16 @@
+import { type ExtensionScope } from '../../domain/extensions/extension-scope.js';
+import type { ConfigLoader } from '../../infrastructure/config/config-loader.js';
+import type { createCompositionRoot } from '../../bootstrap/composition-root.js';
+import type { CommandOutput } from './command-output.js';
+export type CliRuntime = ReturnType<typeof createCompositionRoot>;
+export interface CommandInteraction {
+    selectScope?: (title: string) => Promise<ExtensionScope | undefined>;
+}
+export declare function runConfigCommand(positionals: readonly string[], loader: ConfigLoader, cwd: string, output: CommandOutput): Promise<number>;
+export declare function runAuthCommand(positionals: readonly string[], flags: ReadonlyMap<string, string | boolean>, runtime: CliRuntime, cwd: string, output: CommandOutput): Promise<number>;
+export declare function runTrustCommand(positionals: readonly string[], runtime: CliRuntime, cwd: string, output: CommandOutput): Promise<number>;
+export declare function runModelCommand(positionals: readonly string[], runtime: CliRuntime, cwd: string, output: CommandOutput): Promise<number>;
+export declare function runMcpCommand(positionals: readonly string[], flags: ReadonlyMap<string, string | boolean>, runtime: CliRuntime, cwd: string, output: CommandOutput, interaction?: CommandInteraction): Promise<number>;
+export declare function runPluginCommand(positionals: readonly string[], flags: ReadonlyMap<string, string | boolean>, runtime: CliRuntime, cwd: string, output: CommandOutput, interaction?: CommandInteraction): Promise<number>;
+export declare function runSkillCommand(positionals: readonly string[], flags: ReadonlyMap<string, string | boolean>, runtime: CliRuntime, cwd: string, output: CommandOutput, interaction?: CommandInteraction): Promise<number>;
+export declare function runHookCommand(positionals: readonly string[], runtime: CliRuntime, cwd: string, output: CommandOutput): Promise<number>;

package/dist/application/commands/cli-command-services.js

@@ -0,0 +1,405 @@
+import path from 'node:path';
+import { AuthenticationService } from '../auth/authentication-service.js';
+import { CONFIGURABLE_KEYS, DEFAULT_CONFIG } from '../../domain/config/config-schema.js';
+import { requirePositional, getFlag, requireStringFlag } from './cli-args.js';
+import { readSecret } from '../../infrastructure/credentials/secret-input.js';
+import { getModelContextWindow } from '../../infrastructure/sdk/model-catalog-adapter.js';
+import { FileMcpConfigStore } from '../../infrastructure/extensions/file-mcp-config-store.js';
+import { McpRuntime } from '../../infrastructure/extensions/mcp-runtime.js';
+import { PluginManager } from '../../infrastructure/extensions/plugin-manager.js';
+import { SkillManager } from '../../infrastructure/extensions/skill-manager.js';
+import { SkillInstaller } from '../../infrastructure/extensions/skill-installer.js';
+import { resolveExtensionSource } from '../../infrastructure/extensions/extension-source-resolver.js';
+import { resolveSkillRootScopes } from '../../infrastructure/extensions/skill-roots.js';
+import { CompositeMcpConfigStore } from '../../infrastructure/extensions/composite-mcp-config-store.js';
+import { PluginContributionRegistry } from '../extensions/plugin-contribution-registry.js';
+import { parseExtensionScope, requireExtensionScope } from '../../domain/extensions/extension-scope.js';
+import { CliError } from '../../domain/errors/cli-error.js';
+import { CLI_ERROR_CODES } from '../../domain/errors/error-codes.js';
+import { createHookListResult, createMcpListResult, createPluginListResult, createSkillListResult, formatExtensionList } from '../extensions/extension-list-formatters.js';
+import { writeExtensionListResult } from '../extensions/extension-list-output.js';
+import { HookRuntime } from '../../infrastructure/extensions/hook-runtime.js';
+import { ShellToolExecutor } from '../../infrastructure/shell/shell-tool-executor.js';
+import { ToolPolicy } from '@lotagate/agent-sdk';
+import { formatMcpDetails } from '../extensions/extension-list-formatters.js';
+import { loadExecutionConfig } from '../config/execution-config.js';
+import { redactLogText } from '../../infrastructure/logging/log-redactor.js';
+import { formatCompactTable } from '../formatting/compact-table.js';
+import { formatCompactNumber } from '../formatting/compact-number.js';
+import { loadModelCatalog } from '../model/model-catalog-service.js';
+const MODEL_LIST_TABLE_OPTIONS = {
+    empty: 'No models are available.',
+    maxWidth: 160,
+    columns: [
+        { key: 'name', header: 'Name', width: 52, minWidth: 16 },
+        { key: 'category', header: 'Model category', width: 16, minWidth: 8 },
+        { key: 'contextWindow', header: 'Context window', width: 14, minWidth: 8 },
+        { key: 'status', header: 'Status', width: 12, minWidth: 6 },
+        { key: 'detail', header: 'Detail', minWidth: 6 },
+    ],
+};
+export async function runConfigCommand(positionals, loader, cwd, output) {
+    const action = positionals[0] ?? 'get';
+    if (action === 'path') {
+        output.write(`${JSON.stringify({ global: loader.platformPaths.globalConfigFile, project: path.join(cwd, '.lotagate') }, null, 2)}\n`);
+        return 0;
+    }
+    if (action === 'get') {
+        const loaded = await loader.load(cwd);
+        const key = positionals[1];
+        output.write(`${JSON.stringify(key === undefined ? loaded.config : loaded.config[key] ?? null, null, 2)}\n`);
+        return 0;
+    }
+    if (action === 'set') {
+        const keyValue = requirePositional(positionals, 1, 'config key');
+        if (!CONFIGURABLE_KEYS.includes(keyValue)) {
+            throw new CliError(CLI_ERROR_CODES.INVALID_ARGUMENT, `Unsupported config key: ${keyValue}`, {
+                category: 'arguments', userMessage: `Unsupported configuration key: ${keyValue}.`,
+            });
+        }
+        await loader.setGlobal(keyValue, parseConfigValue(requirePositional(positionals, 2, 'config value')));
+        return 0;
+    }
+    throw new Error(`Unsupported config action: ${action}`);
+}
+export async function runAuthCommand(positionals, flags, runtime, cwd, output) {
+    const action = positionals[0] ?? 'status';
+    const loaded = await runtime.configLoader.load(cwd, { includeProject: false });
+    const configuredProfile = loaded.config.profile ?? AuthenticationService.defaultProfileName();
+    if (action === 'login') {
+        const profileName = String(getFlag(flags, 'profile') ?? configuredProfile);
+        const baseUrl = String(getFlag(flags, 'base-url') ?? loaded.config.baseUrl ?? DEFAULT_CONFIG.baseUrl);
+        const profile = await runtime.auth.login({ profileName, baseUrl, apiKey: await readSecret('LotaGate API key: ') });
+        await runtime.configLoader.setGlobal('profile', profile.name);
+        output.write(`Logged in profile: ${profile.name}\n`);
+        return 0;
+    }
+    if (action === 'list') {
+        const profiles = await runtime.auth.list();
+        output.write(`${formatCompactTable(profiles.map((profile) => ({ name: profile.name, status: profile.name === configuredProfile ? 'ACTIVE' : 'READY', detail: redactLogText(profile.baseUrl) })), { empty: 'No authentication profiles.' })}\n`);
+        return 0;
+    }
+    if (action === 'status') {
+        const credential = await runtime.credentialStore.get(configuredProfile);
+        output.write(`${JSON.stringify(credential === undefined ? { authenticated: false, profile: configuredProfile } : {
+            authenticated: true,
+            profile: credential.profile.name,
+            baseUrl: credential.profile.baseUrl,
+            credentialRef: credential.profile.credentialRef,
+        }, null, 2)}\n`);
+        return 0;
+    }
+    if (action === 'logout') {
+        const profile = positionals[1] ?? configuredProfile;
+        const deleted = await runtime.auth.logout(profile);
+        output.write(`${deleted ? `Logged out profile: ${profile}` : `Profile not found: ${profile}`}\n`);
+        return deleted ? 0 : 1;
+    }
+    if (action === 'use') {
+        const profile = requirePositional(positionals, 1, 'profile name');
+        await runtime.auth.requireCredential(profile);
+        await runtime.configLoader.setGlobal('profile', profile);
+        output.write(`Active profile: ${profile}\n`);
+        return 0;
+    }
+    throw new Error(`Unsupported auth action: ${action}`);
+}
+export async function runTrustCommand(positionals, runtime, cwd, output) {
+    const action = positionals[0] ?? 'status';
+    if (action === 'list') {
+        output.write(`${formatCompactTable((await runtime.projectTrust.list()).map((project) => ({ name: project.canonicalPath, status: 'TRUSTED', detail: project.fingerprint })), { empty: 'No trusted projects.' })}\n`);
+        return 0;
+    }
+    const identity = await runtime.projectTrust.inspect(cwd);
+    if (action === 'status') {
+        output.write(`${JSON.stringify({ ...identity, trusted: await runtime.projectTrust.isTrusted(identity) }, null, 2)}\n`);
+        return 0;
+    }
+    if (action === 'grant') {
+        await runtime.projectTrust.grant(identity);
+        await runtime.workspaceSettings.ensureInitialized(identity.canonicalPath);
+        output.write(`Trusted project: ${identity.canonicalPath}\n`);
+        return 0;
+    }
+    if (action === 'revoke') {
+        const revoked = await runtime.projectTrust.revoke(identity);
+        output.write(`${revoked ? `Revoked project: ${identity.canonicalPath}` : 'Project was not trusted.'}\n`);
+        return revoked ? 0 : 1;
+    }
+    throw new Error(`Unsupported trust action: ${action}`);
+}
+export async function runModelCommand(positionals, runtime, cwd, output) {
+    const action = positionals[0] ?? 'current';
+    const loaded = await loadExecutionConfig(runtime, cwd);
+    if (action === 'current') {
+        output.write(`${JSON.stringify({ model: loaded.config.model, profile: loaded.config.profile }, null, 2)}\n`);
+        return 0;
+    }
+    if (action === 'use') {
+        const model = requirePositional(positionals, 1, 'model id');
+        await runtime.configLoader.setGlobal('model', model);
+        output.write(`Active model: ${model}\n`);
+        return 0;
+    }
+    if (action === 'list' || action === 'refresh') {
+        const models = await loadModelCatalog(runtime, cwd, action === 'refresh');
+        output.write(`${formatCompactTable(models.data.map((model) => ({
+            name: model.id,
+            status: model.id === loaded.config.model ? 'ACTIVE' : 'AVAILABLE',
+            ...(typeof model['owned_by'] === 'string' ? { detail: model['owned_by'] } : {}),
+            values: {
+                category: typeof model['model_category'] === 'string' ? model['model_category'] : '-',
+                contextWindow: formatModelContextWindow(model),
+            },
+        })), MODEL_LIST_TABLE_OPTIONS)}\n`);
+        return 0;
+    }
+    if (action === 'doctor') {
+        const profileName = loaded.config.profile ?? AuthenticationService.defaultProfileName();
+        const credential = await runtime.auth.status(profileName);
+        output.write(`${JSON.stringify({ profile: profileName, authenticated: credential !== undefined, model: loaded.config.model, baseUrl: credential?.baseUrl ?? loaded.config.baseUrl }, null, 2)}\n`);
+        return 0;
+    }
+    throw new Error(`Unsupported model action: ${action}`);
+}
+function formatModelContextWindow(model) {
+    const contextWindow = getModelContextWindow(model);
+    return contextWindow === undefined ? '-' : formatCompactNumber(contextWindow);
+}
+export async function runMcpCommand(positionals, flags, runtime, cwd, output, interaction = {}) {
+    const projectStore = FileMcpConfigStore.forScope(cwd, runtime.paths.globalConfigDir, 'project');
+    const userStore = FileMcpConfigStore.forScope(cwd, runtime.paths.globalConfigDir, 'user');
+    const action = positionals[0] ?? 'list';
+    if (action === 'list') {
+        const result = createMcpListResult([{ scope: 'user', config: await userStore.list() }, { scope: 'project', config: await projectStore.list() }]);
+        writeExtensionListResult(output, result, formatExtensionList(result));
+        return 0;
+    }
+    if (action === 'reload' || action === 'doctor') {
+        const mcpRuntime = new McpRuntime(() => new CompositeMcpConfigStore([userStore, projectStore]));
+        try {
+            const identity = await runtime.projectTrust.inspect(cwd);
+            const summaries = await mcpRuntime.connectConfigured(cwd, await runtime.projectTrust.isTrusted(identity));
+            output.write(`${formatCompactTable(summaries.map(({ serverId, status, protocolEra, protocolVersion, error }) => ({
+                name: serverId,
+                status: status === 'connected' ? 'OK' : status.toUpperCase(),
+                detail: error === undefined ? [protocolEra, protocolVersion].filter(Boolean).join(' · ') : redactLogText(error.message),
+            })), { empty: 'No MCP servers configured.' })}\n`);
+            return summaries.some((summary) => summary.status === 'failed') ? 1 : 0;
+        }
+        finally {
+            await mcpRuntime.close();
+        }
+    }
+    const name = requirePositional(positionals, 1, 'MCP server name');
+    const selectedScope = await resolveCommandScope(flags, interaction, 'MCP server scope', true);
+    if (selectedScope === undefined)
+        throw new Error('MCP server scope was not selected.');
+    const target = { store: selectedScope === 'project' ? projectStore : userStore, scope: selectedScope };
+    const store = target.store;
+    if (action === 'get') {
+        const entry = await store.get(name);
+        output.write(`${formatMcpDetails(name, target.scope, entry)}\n`);
+        return 0;
+    }
+    if (action === 'remove') {
+        await requireTrustedProjectForScope(runtime, cwd, target.scope);
+        const removed = await store.remove(name);
+        runtime.logger.info('MCP server removal completed.', { name, scope: target.scope, removed });
+        output.write(`${removed ? `Removed MCP server: ${name}` : `MCP server not found: ${name}`}\n`);
+        return removed ? 0 : 1;
+    }
+    if (action === 'enable' || action === 'disable') {
+        await requireTrustedProjectForScope(runtime, cwd, target.scope);
+        await store.setEnabled(name, action === 'enable');
+        runtime.logger.info('MCP server state changed.', { name, scope: target.scope, enabled: action === 'enable' });
+        output.write(`${action === 'enable' ? 'Enabled' : 'Disabled'} MCP server: ${name}\n`);
+        return 0;
+    }
+    if (action === 'add') {
+        await requireTrustedProjectForScope(runtime, cwd, selectedScope ?? 'project');
+        const type = String(getFlag(flags, 'type') ?? 'stdio');
+        if (type === 'stdio') {
+            const command = requireStringFlag(flags, 'command');
+            const rawArgs = getFlag(flags, 'args');
+            await store.add(name, { type: 'stdio', command, ...(typeof rawArgs === 'string' ? { args: rawArgs.split(',').map((arg) => arg.trim()).filter(Boolean) } : {}) });
+        }
+        else if (type === 'http' || type === 'sse') {
+            await store.add(name, { type, url: requireStringFlag(flags, 'url') });
+        }
+        else
+            throw new CliError(CLI_ERROR_CODES.INVALID_ARGUMENT, `Unsupported MCP type: ${type}`, { category: 'arguments', userMessage: 'MCP type must be stdio, http, or sse.' });
+        runtime.logger.info('MCP server added.', { name, scope: selectedScope ?? 'project', type });
+        output.write(`Added MCP server successfully: ${name}\n`);
+        return 0;
+    }
+    throw new Error(`Unsupported MCP action: ${action}`);
+}
+export async function runPluginCommand(positionals, flags, runtime, cwd, output, interaction = {}) {
+    const userManager = new PluginManager(runtime.paths.pluginsDir);
+    const projectManager = new PluginManager(path.join(path.resolve(cwd), '.lotagate', 'plugins'));
+    const action = positionals[0] ?? 'list';
+    if (action === 'list') {
+        const result = createPluginListResult([{ scope: 'user', plugins: await userManager.list(undefined, { verifyIntegrity: false }) }, { scope: 'project', plugins: await projectManager.list(undefined, { verifyIntegrity: false }) }]);
+        writeExtensionListResult(output, result, formatExtensionList(result));
+        return 0;
+    }
+    if (action === 'install') {
+        const source = requirePositional(positionals, 1, 'plugin or skill source');
+        const scope = await resolveCommandScope(flags, interaction, 'Plugin installation scope', true);
+        if (scope === undefined)
+            throw new Error('Plugin installation scope was not selected.');
+        await requireTrustedProjectForScope(runtime, cwd, scope);
+        const sha256 = getFlag(flags, 'sha256');
+        const signature = getFlag(flags, 'signature');
+        const publicKey = getFlag(flags, 'public-key');
+        const manager = scope === 'project' ? projectManager : userManager;
+        const skillRoot = scope === 'project' ? path.join(path.resolve(cwd), '.lotagate', 'skills') : runtime.paths.skillsDir;
+        const resolved = await resolveExtensionSource(source, runtime.platform);
+        try {
+            const installedSkill = await new SkillInstaller().install(resolved.directory, skillRoot);
+            if (installedSkill !== undefined) {
+                runtime.logger.info('Skill installed.', { name: installedSkill.manifest.name, scope });
+                output.write(`Added skill successfully: ${installedSkill.manifest.name}\n`);
+                return 0;
+            }
+            const installedPlugin = await manager.install(resolved.directory, {
+                ...(typeof sha256 === 'string' ? { sha256 } : {}),
+                ...(typeof signature === 'string' ? { signature } : {}),
+                ...(typeof publicKey === 'string' ? { publicKeyPem: publicKey } : {}),
+            });
+            runtime.logger.info('Plugin installed.', { name: installedPlugin.manifest.name, scope });
+            output.write(`Added plugin successfully: ${installedPlugin.manifest.name}\n`);
+            return 0;
+        }
+        finally {
+            await resolved.cleanup();
+        }
+    }
+    const name = requirePositional(positionals, 1, 'plugin name');
+    const selectedScope = await resolveCommandScope(flags, interaction, 'Plugin scope', true);
+    if (selectedScope === undefined)
+        throw new Error('Plugin scope was not selected.');
+    const target = { manager: selectedScope === 'project' ? projectManager : userManager, scope: selectedScope };
+    const manager = target.manager;
+    if ((await manager.list(undefined, { verifyIntegrity: false })).every((plugin) => plugin.manifest.name !== name)) {
+        throw new CliError(CLI_ERROR_CODES.PLUGIN_NOT_FOUND, `Plugin not found: ${name}`, { category: 'extension', userMessage: `Plugin not found: ${name}.` });
+    }
+    if (action === 'enable' || action === 'disable') {
+        await requireTrustedProjectForScope(runtime, cwd, target.scope);
+        await manager.setEnabled(name, action === 'enable');
+        runtime.logger.info('Plugin state changed.', { name, scope: target.scope, enabled: action === 'enable' });
+        output.write(`${action === 'enable' ? 'Enabled' : 'Disabled'} plugin: ${name}\n`);
+        return 0;
+    }
+    if (action === 'uninstall') {
+        await requireTrustedProjectForScope(runtime, cwd, target.scope);
+        const removed = await manager.uninstall(name);
+        runtime.logger.info('Plugin uninstallation completed.', { name, scope: target.scope, removed });
+        output.write(`${removed ? `Uninstalled plugin: ${name}` : `Plugin not found: ${name}`}\n`);
+        return removed ? 0 : 1;
+    }
+    throw new Error(`Unsupported plugin action: ${action}`);
+}
+async function resolveCommandScope(flags, interaction, title, required) {
+    const explicit = parseExtensionScope(getFlag(flags, 'scope'));
+    if (explicit !== undefined)
+        return explicit;
+    const selected = interaction.selectScope === undefined ? undefined : await interaction.selectScope(title);
+    if (selected !== undefined)
+        return selected;
+    return required ? requireExtensionScope(undefined) : undefined;
+}
+async function requireTrustedProjectForScope(runtime, cwd, scope) {
+    if (scope !== 'project')
+        return;
+    const identity = await runtime.projectTrust.inspect(cwd);
+    if (!await runtime.projectTrust.isTrusted(identity)) {
+        throw new CliError(CLI_ERROR_CODES.PROJECT_TRUST_REQUIRED, 'Project scope requires trust.', {
+            category: 'project',
+            userMessage: 'Trust the project before writing project-scoped extensions.',
+        });
+    }
+}
+export async function runSkillCommand(positionals, flags, runtime, cwd, output, interaction = {}) {
+    const identity = await runtime.projectTrust.inspect(cwd);
+    const contributions = await new PluginContributionRegistry(runtime.paths.globalConfigDir).resolve(cwd, await runtime.projectTrust.isTrusted(identity));
+    const scopes = resolveSkillRootScopes(cwd, runtime.paths.globalConfigDir, contributions.skillRoots);
+    const manager = new SkillManager(path.join(runtime.paths.globalConfigDir, 'skills-state.json'));
+    const action = positionals[0] ?? 'list';
+    if (action === 'list') {
+        const result = createSkillListResult(await manager.listScoped(scopes, { includeShadowed: true }));
+        writeExtensionListResult(output, result, formatExtensionList(result));
+        return 0;
+    }
+    const name = requirePositional(positionals, 1, 'skill name');
+    const requestedScope = await resolveCommandScope(flags, interaction, 'Skill scope', true);
+    if (requestedScope === undefined)
+        throw new Error('Skill scope was not selected.');
+    const skill = (await manager.listScoped(scopes, { includeShadowed: true })).find((item) => item.skillKey === name && item.scope === requestedScope);
+    if (skill === undefined)
+        throw new CliError(CLI_ERROR_CODES.SKILL_NOT_FOUND, `Skill not found: ${name}`, { category: 'extension', userMessage: `Skill not found: ${name}.` });
+    if (action === 'remove' && skill.scope !== 'user' && skill.scope !== 'project') {
+        throw new CliError(CLI_ERROR_CODES.INVALID_ARGUMENT, `Skill cannot be removed from the ${skill.scope} scope: ${name}`, { category: 'arguments', userMessage: 'Only user- and project-scoped skills can be removed.' });
+    }
+    const isProjectSkill = skill.scope === 'project';
+    if (action === 'remove' || action === 'enable' || action === 'disable')
+        await requireTrustedProjectForScope(runtime, cwd, isProjectSkill ? 'project' : 'user');
+    if (action === 'info') {
+        output.write(`${JSON.stringify(toPublicSkill(skill), null, 2)}\n`);
+        return 0;
+    }
+    if (action === 'enable' || action === 'disable') {
+        await manager.setEnabled(skill.skillKey, action === 'enable', skill.statePath);
+        runtime.logger.info('Skill state changed.', { name, scope: skill.scope, enabled: action === 'enable' });
+        output.write(`${action === 'enable' ? 'Enabled' : 'Disabled'} skill: ${name}\n`);
+        return 0;
+    }
+    if (action === 'remove') {
+        const removed = await manager.remove(skill.skillKey, skill.root, skill.statePath);
+        runtime.logger.info('Skill removal completed.', { name, scope: skill.scope, removed });
+        output.write(`${removed ? `Removed skill: ${name}` : `Skill not found: ${name}`}\n`);
+        return removed ? 0 : 1;
+    }
+    if (action === 'run') {
+        if (!skill.enabled)
+            throw new CliError(CLI_ERROR_CODES.SKILL_NOT_FOUND, `Skill is disabled: ${name}`, { category: 'extension', userMessage: `Skill is disabled: ${name}.` });
+        output.write(`${skill.body}\n`);
+        return 0;
+    }
+    throw new Error(`Unsupported skill action: ${action}`);
+}
+export async function runHookCommand(positionals, runtime, cwd, output) {
+    const action = positionals[0] ?? 'list';
+    if (action !== 'list')
+        throw new Error(`Unsupported hook action: ${action}`);
+    const identity = await runtime.projectTrust.inspect(cwd);
+    if (!await runtime.projectTrust.isTrusted(identity)) {
+        const result = createHookListResult([]);
+        writeExtensionListResult(output, result, formatExtensionList(result));
+        return 0;
+    }
+    const hookRuntime = new HookRuntime(new ShellToolExecutor({ platform: runtime.platform }), { trustedProject: true, enabled: true, toolPolicy: new ToolPolicy() });
+    const contributions = await new PluginContributionRegistry(runtime.paths.globalConfigDir).resolve(cwd, true);
+    const hooks = [...await hookRuntime.loadProject(identity.canonicalPath)];
+    for (const plugin of contributions.plugins)
+        hooks.push(...await hookRuntime.load(plugin));
+    const result = createHookListResult(hooks);
+    writeExtensionListResult(output, result, formatExtensionList(result));
+    return 0;
+}
+function parseConfigValue(value) {
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    if (value === 'null')
+        return null;
+    return value;
+}
+function toPublicSkill(skill) {
+    const { root, statePath, ...publicSkill } = skill;
+    void root;
+    void statePath;
+    return publicSkill;
+}

package/dist/application/commands/command-catalog.d.ts

@@ -0,0 +1,6 @@
+import type { CommandActionSpec } from './command-contract.js';
+/**
+ * Executable command contract for every public direct and slash command.
+ * Presentation layers consume this catalog; application handlers remain separate.
+ */
+export declare const COMMAND_ACTIONS: readonly CommandActionSpec[];