@lotagate/cli 0.1.22 → 0.1.24

package/dist/infrastructure/credentials/encrypted-file-credential-store.js

@@ -1,181 +0,0 @@
-import crypto from 'node:crypto';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { CliError } from '../../domain/errors/cli-error.js';
-import { CLI_ERROR_CODES } from '../../domain/errors/error-codes.js';
-import { validateApiKey, validateBaseUrl, validateProfileName } from '../../domain/auth/auth-profile.js';
-import { withFileLock } from '../filesystem/atomic-file-store.js';
-import { isAlreadyExists, isFileNotFound } from '../filesystem/fs-errors.js';
-export class EncryptedFileCredentialStore {
-    paths;
-    secret;
-    constructor(paths, secret = process.env['LOTAGATE_CREDENTIAL_SECRET']) {
-        this.paths = paths;
-        this.secret = secret;
-    }
-    async list() {
-        const payload = await this.readPayload();
-        return payload.credentials.map(({ profile }) => profile);
-    }
-    async get(profileName) {
-        const name = validateProfileName(profileName);
-        const payload = await this.readPayload();
-        return payload.credentials.find((credential) => credential.profile.name === name);
-    }
-    async set(credential) {
-        const normalized = {
-            profile: {
-                ...credential.profile,
-                name: validateProfileName(credential.profile.name),
-                baseUrl: validateBaseUrl(credential.profile.baseUrl),
-                credentialRef: `file:${validateProfileName(credential.profile.name)}`,
-            },
-            apiKey: validateApiKey(credential.apiKey),
-        };
-        await withFileLock(this.paths.credentialsFile, async () => {
-            const payload = await this.readPayload();
-            const credentials = payload.credentials.filter(({ profile }) => profile.name !== normalized.profile.name);
-            credentials.push(normalized);
-            await this.writePayload({ version: 1, credentials });
-        });
-    }
-    async delete(profileName) {
-        const name = validateProfileName(profileName);
-        return withFileLock(this.paths.credentialsFile, async () => {
-            const payload = await this.readPayload();
-            const credentials = payload.credentials.filter(({ profile }) => profile.name !== name);
-            if (credentials.length === payload.credentials.length)
-                return false;
-            await this.writePayload({ version: 1, credentials });
-            return true;
-        });
-    }
-    async readPayload() {
-        const encrypted = await this.readFile();
-        if (encrypted === undefined)
-            return { version: 1, credentials: [] };
-        const key = await this.deriveKey(encrypted.salt);
-        try {
-            const decipher = crypto.createDecipheriv('aes-256-gcm', key, Buffer.from(encrypted.iv, 'base64'));
-            decipher.setAuthTag(Buffer.from(encrypted.authTag, 'base64'));
-            const plaintext = Buffer.concat([decipher.update(Buffer.from(encrypted.ciphertext, 'base64')), decipher.final()]).toString('utf8');
-            const value = JSON.parse(plaintext);
-            if (!isCredentialPayload(value))
-                throw new Error('Invalid credential payload.');
-            return value;
-        }
-        catch (error) {
-            throw new CliError(CLI_ERROR_CODES.AUTH_CREDENTIAL_STORE_UNAVAILABLE, 'Credential file cannot be decrypted.', {
-                category: 'auth', userMessage: 'Unable to decrypt the credential store. Check LOTAGATE_CREDENTIAL_SECRET.', cause: error,
-            });
-        }
-    }
-    async writePayload(payload) {
-        const salt = crypto.randomBytes(16);
-        const iv = crypto.randomBytes(12);
-        const key = await this.deriveKey(salt.toString('base64'));
-        const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
-        const ciphertext = Buffer.concat([cipher.update(JSON.stringify(payload), 'utf8'), cipher.final()]);
-        const file = {
-            version: 1,
-            salt: salt.toString('base64'),
-            iv: iv.toString('base64'),
-            authTag: cipher.getAuthTag().toString('base64'),
-            ciphertext: ciphertext.toString('base64'),
-        };
-        await fs.mkdir(this.paths.globalConfigDir, { recursive: true });
-        const tempPath = path.join(this.paths.globalConfigDir, `.credentials.${process.pid}.${crypto.randomUUID()}.tmp`);
-        try {
-            await fs.writeFile(tempPath, `${JSON.stringify(file, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
-            await fs.rename(tempPath, this.paths.credentialsFile);
-        }
-        finally {
-            await fs.rm(tempPath, { force: true });
-        }
-    }
-    async readFile() {
-        try {
-            return parseEncryptedFile(await fs.readFile(this.paths.credentialsFile, 'utf8'));
-        }
-        catch (error) {
-            if (isFileNotFound(error))
-                return undefined;
-            if (error instanceof CliError)
-                throw error;
-            throw new CliError(CLI_ERROR_CODES.AUTH_CREDENTIAL_STORE_UNAVAILABLE, 'Credential file cannot be read.', {
-                category: 'auth', userMessage: 'Unable to read the credential store.', cause: error,
-            });
-        }
-    }
-    async deriveKey(salt) {
-        return crypto.scryptSync(await this.resolveSecret(), salt, 32);
-    }
-    async resolveSecret() {
-        if (this.secret !== undefined && this.secret.length >= 16)
-            return this.secret;
-        await fs.mkdir(this.paths.globalConfigDir, { recursive: true });
-        try {
-            const existing = (await fs.readFile(this.paths.credentialKeyFile, 'utf8')).trim();
-            if (existing.length >= 16)
-                return existing;
-            throw new Error('Credential key file is invalid.');
-        }
-        catch (error) {
-            if (!isFileNotFound(error)) {
-                throw new CliError(CLI_ERROR_CODES.AUTH_CREDENTIAL_STORE_UNAVAILABLE, 'Credential key cannot be read.', {
-                    category: 'auth', userMessage: 'Unable to read the local credential key.', cause: error,
-                });
-            }
-        }
-        const generated = crypto.randomBytes(32).toString('base64url');
-        try {
-            await fs.writeFile(this.paths.credentialKeyFile, `${generated}\n`, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
-            return generated;
-        }
-        catch (error) {
-            if (!isAlreadyExists(error)) {
-                throw new CliError(CLI_ERROR_CODES.AUTH_CREDENTIAL_STORE_UNAVAILABLE, 'Credential key cannot be created.', {
-                    category: 'auth', userMessage: 'Unable to initialize secure local credential storage.', cause: error,
-                });
-            }
-            try {
-                const existing = (await fs.readFile(this.paths.credentialKeyFile, 'utf8')).trim();
-                if (existing.length >= 16)
-                    return existing;
-            }
-            catch (readError) {
-                throw new CliError(CLI_ERROR_CODES.AUTH_CREDENTIAL_STORE_UNAVAILABLE, 'Credential key cannot be read after initialization.', {
-                    category: 'auth', userMessage: 'Unable to initialize secure local credential storage.', cause: readError,
-                });
-            }
-            throw new CliError(CLI_ERROR_CODES.AUTH_CREDENTIAL_STORE_UNAVAILABLE, 'Credential key file is invalid.', {
-                category: 'auth', userMessage: 'Unable to initialize secure local credential storage.',
-            });
-        }
-    }
-}
-function parseEncryptedFile(raw) {
-    try {
-        const value = JSON.parse(raw);
-        if (typeof value !== 'object' || value === null)
-            throw new Error('Expected object.');
-        const record = value;
-        if (record['version'] !== 1 || typeof record['salt'] !== 'string' || typeof record['iv'] !== 'string' || typeof record['authTag'] !== 'string' || typeof record['ciphertext'] !== 'string') {
-            throw new Error('Invalid encrypted credential file.');
-        }
-        return { version: 1, salt: record['salt'], iv: record['iv'], authTag: record['authTag'], ciphertext: record['ciphertext'] };
-    }
-    catch (error) {
-        if (error instanceof CliError)
-            throw error;
-        throw new CliError(CLI_ERROR_CODES.AUTH_CREDENTIAL_STORE_UNAVAILABLE, 'Credential file is invalid.', {
-            category: 'auth', userMessage: 'Credential store is corrupted or has an invalid format.', cause: error,
-        });
-    }
-}
-function isCredentialPayload(value) {
-    if (typeof value !== 'object' || value === null)
-        return false;
-    const record = value;
-    return record['version'] === 1 && Array.isArray(record['credentials']);
-}

package/dist/infrastructure/credentials/environment-credential-store.d.ts

@@ -1,11 +0,0 @@
-import { type AuthProfile, type StoredCredential } from '../../domain/auth/auth-profile.js';
-import type { CredentialStore } from '../../ports/credential-store.js';
-export declare class EnvironmentCredentialStore implements CredentialStore {
-    private readonly env;
-    constructor(env?: Readonly<Record<string, string | undefined>>);
-    list(): Promise<readonly AuthProfile[]>;
-    get(profileName: string): Promise<StoredCredential | undefined>;
-    set(): Promise<void>;
-    delete(): Promise<boolean>;
-    private read;
-}

package/dist/infrastructure/credentials/environment-credential-store.js

@@ -1,37 +0,0 @@
-import { DEFAULT_CONFIG } from '../../domain/config/config-schema.js';
-import { validateApiKey, validateBaseUrl, validateProfileName } from '../../domain/auth/auth-profile.js';
-export class EnvironmentCredentialStore {
-    env;
-    constructor(env = process.env) {
-        this.env = env;
-    }
-    async list() {
-        const credential = this.read();
-        return credential === undefined ? [] : [credential.profile];
-    }
-    async get(profileName) {
-        const credential = this.read();
-        return credential?.profile.name === validateProfileName(profileName) ? credential : undefined;
-    }
-    async set() {
-        throw new Error('Environment credentials are read-only.');
-    }
-    async delete() { return false; }
-    read() {
-        const apiKey = this.env['LOTAGATE_API_KEY'];
-        if (apiKey === undefined || apiKey.trim().length === 0)
-            return undefined;
-        const profileName = validateProfileName(this.env['LOTAGATE_PROFILE'] ?? 'default');
-        const now = new Date().toISOString();
-        return {
-            apiKey: validateApiKey(apiKey),
-            profile: {
-                name: profileName,
-                baseUrl: validateBaseUrl(this.env['LOTAGATE_BASE_URL'] ?? DEFAULT_CONFIG.baseUrl),
-                credentialRef: 'env:LOTAGATE_API_KEY',
-                createdAt: now,
-                updatedAt: now,
-            },
-        };
-    }
-}

package/dist/infrastructure/credentials/secret-input.d.ts

@@ -1,7 +0,0 @@
-import type { Readable, Writable } from 'node:stream';
-interface RawInput extends Readable {
-    isTTY?: boolean;
-    setRawMode?: (mode: boolean) => void;
-}
-export declare function readSecret(prompt: string, input?: RawInput, output?: Writable): Promise<string>;
-export {};

package/dist/infrastructure/credentials/secret-input.js

@@ -1,44 +0,0 @@
-export async function readSecret(prompt, input = process.stdin, output = process.stderr) {
-    if (input.isTTY !== true || input.setRawMode === undefined)
-        return readStream(input);
-    const setRawMode = input.setRawMode;
-    return new Promise((resolve, reject) => {
-        let value = '';
-        const onData = (chunk) => {
-            const text = chunk.toString('utf8');
-            for (const character of text) {
-                if (character === '\u0003') {
-                    cleanup();
-                    reject(new Error('Input interrupted.'));
-                    return;
-                }
-                if (character === '\r' || character === '\n') {
-                    cleanup();
-                    output.write('\n');
-                    resolve(value);
-                    return;
-                }
-                if (character === '\u0008' || character === '\u007f') {
-                    value = value.slice(0, -1);
-                    continue;
-                }
-                value += character;
-            }
-        };
-        const cleanup = () => {
-            setRawMode(false);
-            input.pause();
-            input.off('data', onData);
-        };
-        output.write(prompt);
-        setRawMode(true);
-        input.resume();
-        input.on('data', onData);
-    });
-}
-async function readStream(input) {
-    const chunks = [];
-    for await (const chunk of input)
-        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
-    return Buffer.concat(chunks).toString('utf8').trim();
-}

package/dist/infrastructure/extensions/composite-mcp-config-store.d.ts

@@ -1,9 +0,0 @@
-import type { CliMcpConfig } from '../../domain/extensions/mcp-config.js';
-export interface McpConfigReader {
-    list(): Promise<CliMcpConfig>;
-}
-export declare class CompositeMcpConfigStore implements McpConfigReader {
-    private readonly stores;
-    constructor(stores: readonly McpConfigReader[]);
-    list(): Promise<CliMcpConfig>;
-}

package/dist/infrastructure/extensions/composite-mcp-config-store.js

@@ -1,10 +0,0 @@
-import { mergeMcpConfigsWithOverride } from '../../domain/extensions/mcp-config.js';
-export class CompositeMcpConfigStore {
-    stores;
-    constructor(stores) {
-        this.stores = stores;
-    }
-    async list() {
-        return mergeMcpConfigsWithOverride(...await Promise.all(this.stores.map((store) => store.list())));
-    }
-}

package/dist/infrastructure/extensions/extension-directory-reader.d.ts

@@ -1,2 +0,0 @@
-/** Lists direct extension directories while keeping missing optional roots harmless. */
-export declare function listExtensionDirectories(root: string): Promise<readonly string[]>;

package/dist/infrastructure/extensions/extension-directory-reader.js

@@ -1,15 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { isFileNotFound } from '../filesystem/fs-errors.js';
-/** Lists direct extension directories while keeping missing optional roots harmless. */
-export async function listExtensionDirectories(root) {
-    try {
-        const entries = await fs.readdir(root, { withFileTypes: true });
-        return entries.filter((entry) => entry.isDirectory()).map((entry) => path.join(root, entry.name));
-    }
-    catch (error) {
-        if (isFileNotFound(error))
-            return [];
-        throw error;
-    }
-}

package/dist/infrastructure/extensions/extension-source-resolver.d.ts

@@ -1,6 +0,0 @@
-import { type HostPlatformContext } from '../platform/host-platform.js';
-export interface ResolvedExtensionSource {
-    directory: string;
-    cleanup(): Promise<void>;
-}
-export declare function resolveExtensionSource(source: string, platform?: HostPlatformContext): Promise<ResolvedExtensionSource>;

package/dist/infrastructure/extensions/extension-source-resolver.js

@@ -1,126 +0,0 @@
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { CliError } from '../../domain/errors/cli-error.js';
-import { CLI_ERROR_CODES } from '../../domain/errors/error-codes.js';
-import { isFileNotFound } from '../filesystem/fs-errors.js';
-import { detectHostPlatform } from '../platform/host-platform.js';
-import { execPlatformCommand } from '../platform/host-process.js';
-export async function resolveExtensionSource(source, platform = detectHostPlatform()) {
-    const local = await resolveLocalSource(source);
-    if (local !== undefined)
-        return { directory: local, cleanup: async () => { } };
-    if (isGitSource(source))
-        return resolveGitSource(source, platform);
-    if (isNpmSource(source))
-        return resolveNpmSource(source, platform);
-    throw invalidSource('Source must be a local directory, HTTPS Git repository, or npm package.');
-}
-async function resolveLocalSource(source) {
-    const candidate = source.startsWith('file://') ? fileURLToPath(source) : path.resolve(source);
-    try {
-        const stat = await fs.stat(candidate);
-        if (!stat.isDirectory())
-            throw invalidSource('Extension source must be a directory.');
-        return candidate;
-    }
-    catch (error) {
-        if (error instanceof CliError || !isFileNotFound(error))
-            throw error;
-        return undefined;
-    }
-}
-async function resolveGitSource(source, platform) {
-    const temporaryRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'lotagate-extension-git-'));
-    const directory = path.join(temporaryRoot, 'source');
-    try {
-        await execPlatformCommand('git', ['clone', '--depth', '1', source, directory], platform, { maxBufferBytes: 2 * 1024 * 1024 });
-        await fs.rm(path.join(directory, '.git'), { recursive: true, force: true });
-        return { directory, cleanup: () => fs.rm(temporaryRoot, { recursive: true, force: true }) };
-    }
-    catch (error) {
-        await fs.rm(temporaryRoot, { recursive: true, force: true });
-        throw invalidSource(`Unable to clone Git source: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-async function resolveNpmSource(source, platform) {
-    const temporaryRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'lotagate-extension-npm-'));
-    try {
-        await execPlatformCommand('npm', ['install', '--ignore-scripts', '--no-package-lock', '--no-save', '--prefix', temporaryRoot, source], platform, { maxBufferBytes: 4 * 1024 * 1024 });
-        const packageRoot = await findPackageRoot(path.join(temporaryRoot, 'node_modules'));
-        if (packageRoot === undefined)
-            throw invalidSource('npm package does not contain a LotaGate plugin or skill.');
-        return { directory: packageRoot, cleanup: () => fs.rm(temporaryRoot, { recursive: true, force: true }) };
-    }
-    catch (error) {
-        await fs.rm(temporaryRoot, { recursive: true, force: true });
-        if (error instanceof CliError)
-            throw error;
-        throw invalidSource(`Unable to install npm source: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-async function findPackageRoot(root) {
-    let entries;
-    try {
-        entries = await fs.readdir(root, { withFileTypes: true });
-    }
-    catch (error) {
-        if (isFileNotFound(error))
-            return undefined;
-        throw error;
-    }
-    const candidates = [];
-    for (const entry of entries) {
-        if (!entry.isDirectory() || entry.name.startsWith('.'))
-            continue;
-        const directory = path.join(root, entry.name);
-        if (await containsExtensionMarker(directory))
-            candidates.push(directory);
-        if (entry.name.startsWith('@')) {
-            let scoped;
-            try {
-                scoped = await fs.readdir(directory, { withFileTypes: true });
-            }
-            catch {
-                scoped = [];
-            }
-            for (const child of scoped.filter((item) => item.isDirectory())) {
-                const scopedDirectory = path.join(directory, child.name);
-                if (await containsExtensionMarker(scopedDirectory))
-                    candidates.push(scopedDirectory);
-            }
-        }
-    }
-    if (candidates.length > 1)
-        throw invalidSource('npm package contains multiple extension roots.');
-    return candidates[0];
-}
-async function containsExtensionMarker(directory) {
-    try {
-        await fs.stat(path.join(directory, '.lotagate-plugin', 'plugin.json'));
-        return true;
-    }
-    catch (error) {
-        if (!isFileNotFound(error))
-            throw error;
-    }
-    try {
-        await fs.stat(path.join(directory, 'SKILL.md'));
-        return true;
-    }
-    catch (error) {
-        if (!isFileNotFound(error))
-            throw error;
-        return false;
-    }
-}
-function isGitSource(source) {
-    return /^https:\/\//u.test(source) && (source.endsWith('.git') || /^https:\/\/github\.com\/[^/]+\/[^/]+\/?$/u.test(source));
-}
-function isNpmSource(source) {
-    return /^@?[a-z0-9][a-z0-9._/-]*(?:@[a-z0-9][a-z0-9._-]*)?$/iu.test(source) && !source.includes('/') || /^@[a-z0-9][a-z0-9-]*\/[a-z0-9][a-z0-9._-]*(?:@[a-z0-9][a-z0-9._-]*)?$/iu.test(source);
-}
-function invalidSource(message) {
-    return new CliError(CLI_ERROR_CODES.PLUGIN_MANIFEST_INVALID, message, { category: 'extension', userMessage: `Unable to resolve extension source: ${message}` });
-}

package/dist/infrastructure/extensions/file-mcp-config-store.d.ts

@@ -1,15 +0,0 @@
-import { type CliMcpConfig, type CliMcpServerConfig } from '../../domain/extensions/mcp-config.js';
-import type { ExtensionScope } from '../../domain/extensions/extension-scope.js';
-export declare class FileMcpConfigStore {
-    private readonly filePath;
-    constructor(location: string, scope?: ExtensionScope);
-    static forScope(cwd: string, globalConfigDir: string, scope: ExtensionScope): FileMcpConfigStore;
-    get path(): string;
-    list(): Promise<CliMcpConfig>;
-    get(name: string): Promise<import("../../domain/extensions/mcp-config.js").CliMcpServerEntry | undefined>;
-    add(name: string, config: CliMcpServerConfig): Promise<void>;
-    remove(name: string): Promise<boolean>;
-    setEnabled(name: string, enabled: boolean): Promise<void>;
-    private readRaw;
-    private write;
-}

package/dist/infrastructure/extensions/file-mcp-config-store.js

@@ -1,66 +0,0 @@
-import path from 'node:path';
-import { validateMcpConfig, validateMcpName } from '../../domain/extensions/mcp-config.js';
-import { CliError } from '../../domain/errors/cli-error.js';
-import { CLI_ERROR_CODES } from '../../domain/errors/error-codes.js';
-import { atomicWriteFile, withFileLock } from '../filesystem/atomic-file-store.js';
-import { isFileNotFound } from '../filesystem/fs-errors.js';
-import { readJsonFileBounded } from '../filesystem/bounded-json-reader.js';
-import { RESOURCE_LIMITS } from '../../domain/runtime/resource-limits.js';
-export class FileMcpConfigStore {
-    filePath;
-    constructor(location, scope = 'project') {
-        this.filePath = scope === 'user'
-            ? path.join(path.resolve(location), 'mcp.json')
-            : path.join(path.resolve(location), '.lotagate', 'mcp.json');
-    }
-    static forScope(cwd, globalConfigDir, scope) {
-        return new FileMcpConfigStore(scope === 'user' ? globalConfigDir : cwd, scope);
-    }
-    get path() { return this.filePath; }
-    async list() { return validateMcpConfig(await this.readRaw()); }
-    async get(name) { return (await this.list())[validateMcpName(name)]; }
-    async add(name, config) {
-        const normalized = validateMcpName(name);
-        await withFileLock(this.filePath, async () => {
-            const current = await this.list();
-            current[normalized] = { enabled: true, config };
-            await this.write(current);
-        });
-    }
-    async remove(name) {
-        const normalized = validateMcpName(name);
-        return withFileLock(this.filePath, async () => {
-            const current = await this.list();
-            if (current[normalized] === undefined)
-                return false;
-            delete current[normalized];
-            await this.write(current);
-            return true;
-        });
-    }
-    async setEnabled(name, enabled) {
-        const normalized = validateMcpName(name);
-        await withFileLock(this.filePath, async () => {
-            const current = await this.list();
-            const entry = current[normalized];
-            if (entry === undefined)
-                throw new CliError(CLI_ERROR_CODES.MCP_SERVER_NOT_FOUND, `MCP server not found: ${normalized}`, { category: 'mcp', userMessage: `MCP server not found: ${normalized}.` });
-            current[normalized] = { ...entry, enabled };
-            await this.write(current);
-        });
-    }
-    async readRaw() {
-        try {
-            return await readJsonFileBounded(this.filePath, RESOURCE_LIMITS.mcpConfigBytes);
-        }
-        catch (error) {
-            if (isFileNotFound(error))
-                return {};
-            throw error;
-        }
-    }
-    async write(value) {
-        const normalized = validateMcpConfig(value);
-        await atomicWriteFile(this.filePath, `${JSON.stringify(normalized, null, 2)}\n`);
-    }
-}

package/dist/infrastructure/extensions/hook-runtime.d.ts

@@ -1,18 +0,0 @@
-import type { ToolExecutionContext, ToolExecutor, ToolPolicy } from '@lotagate/agent-sdk';
-import { type HookDefinition, type HookEvent } from '../../domain/extensions/hook-manifest.js';
-import type { PluginManifest } from '../../domain/extensions/plugin-manifest.js';
-export interface HookRuntimePolicy {
-    trustedProject: boolean;
-    enabled: boolean;
-    toolPolicy: ToolPolicy;
-}
-export declare class HookRuntime {
-    private readonly executor;
-    private readonly policy;
-    constructor(executor: ToolExecutor, policy: HookRuntimePolicy);
-    load(plugin: PluginManifest): Promise<readonly HookDefinition[]>;
-    loadProject(cwd: string): Promise<readonly HookDefinition[]>;
-    private loadDirectory;
-    run(hook: HookDefinition, context: ToolExecutionContext): Promise<boolean>;
-    runEvent(hooks: readonly HookDefinition[], event: HookEvent, context: ToolExecutionContext): Promise<number>;
-}

package/dist/infrastructure/extensions/hook-runtime.js

@@ -1,66 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { ToolExecutionError } from '@lotagate/agent-sdk';
-import { parseHookDefinition } from '../../domain/extensions/hook-manifest.js';
-import { isFileNotFound } from '../filesystem/fs-errors.js';
-import { readJsonFileBounded } from '../filesystem/bounded-json-reader.js';
-import { RESOURCE_LIMITS } from '../../domain/runtime/resource-limits.js';
-export class HookRuntime {
-    executor;
-    policy;
-    constructor(executor, policy) {
-        this.executor = executor;
-        this.policy = policy;
-    }
-    async load(plugin) {
-        if (plugin.hooksDirectory === undefined)
-            return [];
-        const root = path.resolve(plugin.directory, plugin.hooksDirectory);
-        if (!root.startsWith(`${path.resolve(plugin.directory)}${path.sep}`))
-            return [];
-        return this.loadDirectory(root);
-    }
-    async loadProject(cwd) {
-        return this.loadDirectory(path.join(path.resolve(cwd), '.lotagate', 'hooks'));
-    }
-    async loadDirectory(root) {
-        let files;
-        try {
-            files = (await fs.readdir(root, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith('.json')).map((entry) => path.join(root, entry.name));
-        }
-        catch (error) {
-            if (isFileNotFound(error))
-                return [];
-            throw error;
-        }
-        const hooks = [];
-        for (const file of files.sort())
-            hooks.push(parseHookDefinition(await readJsonFileBounded(file, RESOURCE_LIMITS.configFileBytes), root, path.basename(file, '.json')));
-        return hooks;
-    }
-    async run(hook, context) {
-        if (!this.policy.enabled || !this.policy.trustedProject)
-            return false;
-        const input = { command: hook.command, args: [...hook.args], cwd: '.', timeoutMs: hook.timeoutMs };
-        const toolInfo = this.executor.getToolInfo?.('shell.exec');
-        try {
-            await this.policy.toolPolicy.assertAllowed({ toolName: 'shell.exec', input, context, ...(toolInfo === undefined ? {} : { toolInfo }) });
-        }
-        catch (error) {
-            if (error instanceof ToolExecutionError)
-                return false;
-            throw error;
-        }
-        const result = await this.executor.execute('shell.exec', input, context);
-        if (result.isError)
-            throw new Error(`Hook failed: ${hook.id}`);
-        return true;
-    }
-    async runEvent(hooks, event, context) {
-        let executed = 0;
-        for (const hook of hooks)
-            if (hook.event === event && await this.run(hook, context))
-                executed += 1;
-        return executed;
-    }
-}

package/dist/infrastructure/extensions/mcp-runtime.d.ts

@@ -1,12 +0,0 @@
-import { McpClientManager, type McpConnectionSummary, type McpServerConfigMap } from '@lotagate/agent-sdk';
-import type { CliMcpConfig } from '../../domain/extensions/mcp-config.js';
-import type { McpConfigReader } from './composite-mcp-config-store.js';
-export declare class McpRuntime {
-    private readonly storeFactory;
-    private manager;
-    constructor(storeFactory?: (cwd: string) => McpConfigReader);
-    connectConfigured(cwd: string, trusted: boolean): Promise<readonly McpConnectionSummary[]>;
-    get client(): McpClientManager | undefined;
-    close(): Promise<void>;
-}
-export declare function toAgentMcpConfig(config: CliMcpConfig): McpServerConfigMap;