clodds 1.1.0

package/dist/mcp/index.js

@@ -0,0 +1,940 @@
+"use strict";
+/**
+ * MCP (Model Context Protocol) - Clawdbot-style server integration
+ *
+ * Features:
+ * - Full MCP protocol support (tools, resources, prompts)
+ * - JSON-RPC 2.0 transport
+ * - Protocol schemas & validation
+ * - Command registry & discovery
+ * - Server lifecycle management
+ * - mcporter skill integration
+ * - Stdio and SSE transports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mcp = void 0;
+exports.createMcpRegistry = createMcpRegistry;
+exports.validateSchema = validateSchema;
+exports.importSkillsFromDirectory = importSkillsFromDirectory;
+exports.loadMcpConfig = loadMcpConfig;
+exports.initializeFromConfig = initializeFromConfig;
+exports.mcpToolToClodds = mcpToolToClodds;
+const child_process_1 = require("child_process");
+const events_1 = require("events");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const logger_1 = require("../utils/logger");
+const MCP_RESOURCE_CHUNK_BYTES = Math.max(1024, Number(process.env.CLODDS_MCP_RESOURCE_CHUNK_BYTES || 64 * 1024));
+// =============================================================================
+// STDIO CLIENT IMPLEMENTATION
+// =============================================================================
+function chunkResourceContents(content) {
+    if (content.chunk || typeof content.complete === 'boolean') {
+        return [content];
+    }
+    const payload = content.text ?? content.blob;
+    if (!payload || payload.length <= MCP_RESOURCE_CHUNK_BYTES) {
+        return [content];
+    }
+    const chunks = [];
+    for (let i = 0; i < payload.length; i += MCP_RESOURCE_CHUNK_BYTES) {
+        const chunk = payload.slice(i, i + MCP_RESOURCE_CHUNK_BYTES);
+        const isLast = i + MCP_RESOURCE_CHUNK_BYTES >= payload.length;
+        chunks.push({
+            uri: content.uri,
+            mimeType: content.mimeType,
+            chunk,
+            complete: isLast,
+        });
+    }
+    return chunks;
+}
+class StdioMcpClient {
+    config;
+    process = null;
+    pendingRequests = new Map();
+    requestId = 0;
+    buffer = '';
+    events = new events_1.EventEmitter();
+    reconnectAttempts = 0;
+    defaultTimeoutMs = Number(process.env.CLODDS_MCP_REQUEST_TIMEOUT_MS || 15000);
+    serverInfo;
+    connected = false;
+    constructor(config) {
+        this.config = config;
+    }
+    async connect() {
+        if (this.connected)
+            return;
+        const command = this.config.command;
+        if (!command) {
+            throw new Error('command is required for stdio MCP transport');
+        }
+        return new Promise((resolve, reject) => {
+            const env = { ...process.env, ...this.config.env };
+            const proc = (0, child_process_1.spawn)(command, this.config.args || [], {
+                env,
+                cwd: this.config.cwd,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            this.process = proc;
+            proc.stdout?.on('data', (data) => {
+                this.handleData(data.toString());
+            });
+            proc.stderr?.on('data', (data) => {
+                logger_1.logger.debug({ server: this.config.name, stderr: data.toString() }, 'MCP server stderr');
+            });
+            proc.on('error', (err) => {
+                logger_1.logger.error({ server: this.config.name, error: err }, 'MCP server error');
+                this.connected = false;
+                reject(err);
+            });
+            proc.on('exit', (code) => {
+                logger_1.logger.info({ server: this.config.name, code }, 'MCP server exited');
+                this.connected = false;
+                if (this.config.restartOnExit) {
+                    void this.scheduleReconnect();
+                }
+                else if (this.config.retryOnFailure !== false) {
+                    void this.scheduleReconnect();
+                }
+            });
+            // Initialize connection
+            this.initialize()
+                .then((info) => {
+                this.serverInfo = info;
+                this.connected = true;
+                this.reconnectAttempts = 0;
+                logger_1.logger.info({ server: this.config.name, info }, 'MCP server connected');
+                resolve();
+            })
+                .catch(reject);
+        });
+    }
+    async disconnect() {
+        if (this.process) {
+            this.process.kill();
+            this.process = null;
+        }
+        this.connected = false;
+        this.pendingRequests.clear();
+    }
+    async scheduleReconnect() {
+        const max = this.config.maxRetries ?? 5;
+        if (this.reconnectAttempts >= max) {
+            logger_1.logger.warn({ server: this.config.name }, 'MCP reconnect attempts exhausted');
+            return;
+        }
+        const base = this.config.reconnectBaseMs ?? 1000;
+        const maxDelay = this.config.reconnectMaxMs ?? 30000;
+        const delay = Math.min(maxDelay, base * Math.pow(2, this.reconnectAttempts));
+        this.reconnectAttempts += 1;
+        logger_1.logger.info({ server: this.config.name, attempt: this.reconnectAttempts, delay }, 'Scheduling MCP reconnect');
+        await new Promise((r) => setTimeout(r, delay));
+        try {
+            await this.connect();
+        }
+        catch (error) {
+            logger_1.logger.warn({ server: this.config.name, error }, 'MCP reconnect failed');
+        }
+    }
+    handleData(data) {
+        this.buffer += data;
+        // Process complete JSON-RPC messages
+        const lines = this.buffer.split('\n');
+        this.buffer = lines.pop() || '';
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const response = JSON.parse(line);
+                this.handleResponse(response);
+            }
+            catch (err) {
+                logger_1.logger.warn({ line, error: err }, 'Failed to parse MCP response');
+            }
+        }
+    }
+    handleResponse(response) {
+        if (response.id === undefined) {
+            // Notification, emit event
+            this.events.emit('notification', response);
+            return;
+        }
+        const pending = this.pendingRequests.get(response.id);
+        if (!pending) {
+            logger_1.logger.warn({ id: response.id }, 'Unknown response ID');
+            return;
+        }
+        this.pendingRequests.delete(response.id);
+        if (response.error) {
+            pending.reject(new Error(`MCP Error ${response.error.code}: ${response.error.message}`));
+        }
+        else {
+            pending.resolve(response.result);
+        }
+    }
+    async request(method, params) {
+        if (!this.process?.stdin) {
+            throw new Error('Not connected');
+        }
+        const id = ++this.requestId;
+        const request = {
+            jsonrpc: '2.0',
+            id,
+            method,
+            params,
+        };
+        const timeoutMs = this.config.requestTimeoutMs ?? this.defaultTimeoutMs;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                if (this.pendingRequests.has(id)) {
+                    this.pendingRequests.delete(id);
+                    reject(new Error(`MCP request timeout after ${timeoutMs}ms`));
+                }
+            }, timeoutMs);
+            this.pendingRequests.set(id, {
+                resolve: (result) => {
+                    clearTimeout(timer);
+                    resolve(result);
+                },
+                reject: (error) => {
+                    clearTimeout(timer);
+                    reject(error);
+                },
+            });
+            this.process.stdin.write(JSON.stringify(request) + '\n');
+        });
+    }
+    async initialize() {
+        const result = await this.request('initialize', {
+            protocolVersion: '2024-11-05',
+            clientInfo: {
+                name: 'clodds',
+                version: '0.1.0',
+            },
+            capabilities: {},
+        });
+        // Send initialized notification
+        this.process?.stdin?.write(JSON.stringify({
+            jsonrpc: '2.0',
+            method: 'notifications/initialized',
+        }) + '\n');
+        return result.serverInfo;
+    }
+    async listTools() {
+        const result = await this.request('tools/list');
+        return result.tools || [];
+    }
+    async callTool(name, params) {
+        const result = await this.request('tools/call', {
+            name,
+            arguments: params,
+        });
+        return result;
+    }
+    async listResources() {
+        const result = await this.request('resources/list');
+        return result.resources || [];
+    }
+    async listResourceTemplates() {
+        const result = await this.request('resources/templates/list');
+        return result.resourceTemplates || [];
+    }
+    async readResource(uri) {
+        const result = await this.request('resources/read', { uri });
+        return result.contents?.[0] || { uri };
+    }
+    async *streamResource(uri) {
+        const result = await this.request('resources/read', { uri });
+        if (result.contents?.length) {
+            for (const content of result.contents) {
+                for (const chunk of chunkResourceContents(content)) {
+                    yield chunk;
+                }
+            }
+        }
+    }
+    async listPrompts() {
+        const result = await this.request('prompts/list');
+        return result.prompts || [];
+    }
+    async getPrompt(name, args) {
+        const result = await this.request('prompts/get', {
+            name,
+            arguments: args,
+        });
+        return result.messages?.map(m => m.content) || [];
+    }
+    async health() {
+        try {
+            await this.listTools();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+// =============================================================================
+// SSE CLIENT IMPLEMENTATION
+// =============================================================================
+class SseMcpClient {
+    config;
+    pendingRequests = new Map();
+    requestId = 0;
+    buffer = '';
+    abortController = null;
+    reconnectAttempts = 0;
+    defaultTimeoutMs = Number(process.env.CLODDS_MCP_REQUEST_TIMEOUT_MS || 15000);
+    serverInfo;
+    connected = false;
+    constructor(config) {
+        this.config = config;
+    }
+    async connect() {
+        if (this.connected)
+            return;
+        if (!this.config.sseEndpoint) {
+            throw new Error('sseEndpoint is required for SSE transport');
+        }
+        this.abortController = new AbortController();
+        const response = await fetch(this.config.sseEndpoint, {
+            method: 'GET',
+            headers: { Accept: 'text/event-stream', ...(this.config.headers || {}) },
+            signal: this.abortController.signal,
+        });
+        if (!response.ok || !response.body) {
+            throw new Error(`Failed to connect SSE: ${response.status}`);
+        }
+        this.connected = true;
+        this.readStream(response.body).catch((error) => {
+            logger_1.logger.warn({ server: this.config.name, error }, 'SSE stream ended');
+            this.connected = false;
+            if (this.config.retryOnFailure !== false) {
+                void this.scheduleReconnect();
+            }
+        });
+        const info = await this.initialize();
+        this.serverInfo = info;
+        this.reconnectAttempts = 0;
+        logger_1.logger.info({ server: this.config.name, info }, 'MCP SSE server connected');
+    }
+    async disconnect() {
+        this.abortController?.abort();
+        this.abortController = null;
+        this.connected = false;
+        this.pendingRequests.clear();
+    }
+    async scheduleReconnect() {
+        const max = this.config.maxRetries ?? 5;
+        if (this.reconnectAttempts >= max) {
+            logger_1.logger.warn({ server: this.config.name }, 'MCP SSE reconnect attempts exhausted');
+            return;
+        }
+        const base = this.config.reconnectBaseMs ?? 1000;
+        const maxDelay = this.config.reconnectMaxMs ?? 30000;
+        const delay = Math.min(maxDelay, base * Math.pow(2, this.reconnectAttempts));
+        this.reconnectAttempts += 1;
+        logger_1.logger.info({ server: this.config.name, attempt: this.reconnectAttempts, delay }, 'Scheduling MCP SSE reconnect');
+        await new Promise((r) => setTimeout(r, delay));
+        try {
+            await this.connect();
+        }
+        catch (error) {
+            logger_1.logger.warn({ server: this.config.name, error }, 'MCP SSE reconnect failed');
+        }
+    }
+    async readStream(stream) {
+        const reader = stream.getReader();
+        const decoder = new TextDecoder();
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            this.handleData(decoder.decode(value, { stream: true }));
+        }
+    }
+    handleData(data) {
+        this.buffer += data;
+        const chunks = this.buffer.split('\n\n');
+        this.buffer = chunks.pop() || '';
+        for (const chunk of chunks) {
+            const lines = chunk.split('\n');
+            const dataLines = [];
+            for (const line of lines) {
+                if (line.startsWith('data:')) {
+                    dataLines.push(line.slice(5).trim());
+                }
+            }
+            if (dataLines.length === 0)
+                continue;
+            const payload = dataLines.join('\n');
+            try {
+                const response = JSON.parse(payload);
+                this.handleResponse(response);
+            }
+            catch (err) {
+                logger_1.logger.warn({ payload, error: err }, 'Failed to parse SSE MCP response');
+            }
+        }
+    }
+    handleResponse(response) {
+        if (response.id === undefined) {
+            return;
+        }
+        const pending = this.pendingRequests.get(response.id);
+        if (!pending) {
+            logger_1.logger.warn({ id: response.id }, 'Unknown SSE response ID');
+            return;
+        }
+        this.pendingRequests.delete(response.id);
+        if (response.error) {
+            pending.reject(new Error(`MCP Error ${response.error.code}: ${response.error.message}`));
+        }
+        else {
+            pending.resolve(response.result);
+        }
+    }
+    async request(method, params) {
+        const id = ++this.requestId;
+        const request = {
+            jsonrpc: '2.0',
+            id,
+            method,
+            params,
+        };
+        const endpoint = this.config.messageEndpoint || this.inferMessageEndpoint();
+        if (!endpoint) {
+            throw new Error('messageEndpoint is required for SSE transport');
+        }
+        const timeoutMs = this.config.requestTimeoutMs ?? this.defaultTimeoutMs;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                if (this.pendingRequests.has(id)) {
+                    this.pendingRequests.delete(id);
+                    reject(new Error(`MCP request timeout after ${timeoutMs}ms`));
+                }
+            }, timeoutMs);
+            this.pendingRequests.set(id, {
+                resolve: (result) => {
+                    clearTimeout(timer);
+                    resolve(result);
+                },
+                reject: (error) => {
+                    clearTimeout(timer);
+                    reject(error);
+                },
+            });
+            fetch(endpoint, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...(this.config.headers || {}) },
+                body: JSON.stringify(request),
+            }).catch((error) => {
+                this.pendingRequests.delete(id);
+                clearTimeout(timer);
+                reject(error);
+            });
+        });
+    }
+    inferMessageEndpoint() {
+        if (!this.config.sseEndpoint)
+            return null;
+        if (this.config.sseEndpoint.endsWith('/sse')) {
+            return this.config.sseEndpoint.replace(/\/sse$/, '/message');
+        }
+        return null;
+    }
+    async initialize() {
+        const result = await this.request('initialize', {
+            protocolVersion: '2024-11-05',
+            clientInfo: {
+                name: 'clodds',
+                version: '0.1.0',
+            },
+            capabilities: {},
+        });
+        await this.request('notifications/initialized');
+        return result.serverInfo;
+    }
+    async listTools() {
+        const result = await this.request('tools/list');
+        return result.tools || [];
+    }
+    async callTool(name, params) {
+        const result = await this.request('tools/call', {
+            name,
+            arguments: params,
+        });
+        return result;
+    }
+    async listResources() {
+        const result = await this.request('resources/list');
+        return result.resources || [];
+    }
+    async listResourceTemplates() {
+        const result = await this.request('resources/templates/list');
+        return result.resourceTemplates || [];
+    }
+    async readResource(uri) {
+        const result = await this.request('resources/read', { uri });
+        return result.contents?.[0] || { uri };
+    }
+    async *streamResource(uri) {
+        const result = await this.request('resources/read', { uri });
+        if (result.contents?.length) {
+            for (const content of result.contents) {
+                for (const chunk of chunkResourceContents(content)) {
+                    yield chunk;
+                }
+            }
+        }
+    }
+    async listPrompts() {
+        const result = await this.request('prompts/list');
+        return result.prompts || [];
+    }
+    async getPrompt(name, args) {
+        const result = await this.request('prompts/get', {
+            name,
+            arguments: args,
+        });
+        return result.messages?.map(m => m.content) || [];
+    }
+    async health() {
+        try {
+            await this.listTools();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+// =============================================================================
+// MCP REGISTRY IMPLEMENTATION
+// =============================================================================
+function createMcpRegistry() {
+    const servers = new Map();
+    const clients = new Map();
+    const promptCache = new Map();
+    const promptTtlMs = Number(process.env.CLODDS_MCP_PROMPT_CACHE_TTL_MS || 5 * 60 * 1000);
+    return {
+        register(config) {
+            servers.set(config.name, config);
+            logger_1.logger.debug({ name: config.name }, 'MCP server registered');
+        },
+        unregister(name) {
+            const client = clients.get(name);
+            if (client) {
+                client.disconnect();
+                clients.delete(name);
+            }
+            servers.delete(name);
+        },
+        getClient(name) {
+            return clients.get(name);
+        },
+        listServers() {
+            return Array.from(servers.keys());
+        },
+        async connectAll() {
+            const promises = [];
+            for (const [name, config] of servers) {
+                if (config.autoStart !== false) {
+                    if (config.transport !== 'sse' && !config.command) {
+                        logger_1.logger.warn({ name }, 'Skipping MCP server without command (stdio transport)');
+                        continue;
+                    }
+                    const client = config.transport === 'sse'
+                        ? new SseMcpClient(config)
+                        : new StdioMcpClient(config);
+                    clients.set(name, client);
+                    const connectPromise = client.connect().catch((err) => {
+                        logger_1.logger.error({ name, error: err }, 'Failed to connect MCP server');
+                    });
+                    promises.push(connectPromise);
+                }
+            }
+            await Promise.all(promises);
+        },
+        async disconnectAll() {
+            const promises = [];
+            for (const client of clients.values()) {
+                promises.push(client.disconnect());
+            }
+            await Promise.all(promises);
+            clients.clear();
+        },
+        async getAllTools() {
+            const allTools = [];
+            for (const [name, client] of clients) {
+                if (!client.connected)
+                    continue;
+                try {
+                    const tools = await client.listTools();
+                    for (const tool of tools) {
+                        allTools.push({ ...tool, server: name });
+                    }
+                }
+                catch (err) {
+                    logger_1.logger.warn({ server: name, error: err }, 'Failed to list tools');
+                }
+            }
+            return allTools;
+        },
+        async callTool(qualifiedName, params) {
+            const [serverName, toolName] = qualifiedName.includes(':')
+                ? qualifiedName.split(':', 2)
+                : [null, qualifiedName];
+            // If no server specified, search all
+            if (!serverName) {
+                for (const [srvName, client] of clients) {
+                    if (!client.connected)
+                        continue;
+                    try {
+                        const tools = await client.listTools();
+                        if (tools.some(t => t.name === toolName)) {
+                            return client.callTool(toolName, params);
+                        }
+                    }
+                    catch (e) {
+                        logger_1.logger.debug({ err: e, server: srvName, tool: toolName }, 'Tool lookup failed on server');
+                    }
+                }
+                throw new Error(`Tool not found: ${qualifiedName}`);
+            }
+            const client = clients.get(serverName);
+            if (!client?.connected) {
+                throw new Error(`Server not connected: ${serverName}`);
+            }
+            return client.callTool(toolName, params);
+        },
+        async checkHealth() {
+            const results = {};
+            for (const [name, client] of clients) {
+                if (!client.connected) {
+                    results[name] = false;
+                    continue;
+                }
+                try {
+                    results[name] = await client.health();
+                }
+                catch {
+                    results[name] = false;
+                }
+            }
+            return results;
+        },
+        async *streamResource(qualifiedName) {
+            const [serverName, uri] = qualifiedName.includes(':')
+                ? qualifiedName.split(':', 2)
+                : [null, qualifiedName];
+            if (!serverName) {
+                for (const client of clients.values()) {
+                    if (!client.connected)
+                        continue;
+                    try {
+                        for await (const chunk of client.streamResource(uri)) {
+                            yield chunk;
+                        }
+                        return;
+                    }
+                    catch (e) {
+                        logger_1.logger.debug({ err: e, uri }, 'Resource stream failed on server');
+                    }
+                }
+                throw new Error(`Resource not found: ${qualifiedName}`);
+            }
+            const client = clients.get(serverName);
+            if (!client?.connected) {
+                throw new Error(`Server not connected: ${serverName}`);
+            }
+            for await (const chunk of client.streamResource(uri)) {
+                yield chunk;
+            }
+        },
+        async getPromptCached(qualifiedName, args) {
+            const [serverName, promptName] = qualifiedName.includes(':')
+                ? qualifiedName.split(':', 2)
+                : [null, qualifiedName];
+            const key = `${serverName || 'any'}:${promptName}:${JSON.stringify(args || {})}`;
+            const cached = promptCache.get(key);
+            if (cached && cached.expiresAt > Date.now()) {
+                return cached.content;
+            }
+            const resolvePrompt = async (client) => {
+                const content = await client.getPrompt(promptName, args);
+                promptCache.set(key, { content, expiresAt: Date.now() + promptTtlMs });
+                return content;
+            };
+            if (!serverName) {
+                for (const client of clients.values()) {
+                    if (!client.connected)
+                        continue;
+                    try {
+                        return await resolvePrompt(client);
+                    }
+                    catch (e) {
+                        logger_1.logger.debug({ err: e, prompt: promptName }, 'Prompt lookup failed on server');
+                    }
+                }
+                throw new Error(`Prompt not found: ${qualifiedName}`);
+            }
+            const client = clients.get(serverName);
+            if (!client?.connected) {
+                throw new Error(`Server not connected: ${serverName}`);
+            }
+            return resolvePrompt(client);
+        },
+        async callToolBatch(qualifiedName, paramsList) {
+            const [serverName, toolName] = qualifiedName.includes(':')
+                ? qualifiedName.split(':', 2)
+                : [null, qualifiedName];
+            const runOnClient = async (client) => {
+                const results = [];
+                for (const params of paramsList) {
+                    results.push(await client.callTool(toolName, params));
+                }
+                return results;
+            };
+            if (!serverName) {
+                for (const client of clients.values()) {
+                    if (!client.connected)
+                        continue;
+                    try {
+                        const tools = await client.listTools();
+                        if (tools.some(t => t.name === toolName)) {
+                            return runOnClient(client);
+                        }
+                    }
+                    catch (e) {
+                        logger_1.logger.debug({ err: e, tool: toolName }, 'Batch tool lookup failed on server');
+                    }
+                }
+                throw new Error(`Tool not found: ${qualifiedName}`);
+            }
+            const client = clients.get(serverName);
+            if (!client?.connected) {
+                throw new Error(`Server not connected: ${serverName}`);
+            }
+            return runOnClient(client);
+        },
+    };
+}
+// =============================================================================
+// SCHEMA VALIDATION
+// =============================================================================
+/**
+ * Validate data against JSON Schema
+ */
+function validateSchema(data, schema) {
+    const errors = [];
+    function validate(value, sch, path) {
+        if (!sch)
+            return;
+        // Type validation
+        if (sch.type) {
+            const actualType = Array.isArray(value) ? 'array' : typeof value;
+            if (sch.type === 'integer' && typeof value === 'number' && Number.isInteger(value)) {
+                // ok
+            }
+            else if (sch.type === 'array' && Array.isArray(value)) {
+                // ok
+            }
+            else if (sch.type !== actualType) {
+                errors.push(`${path}: expected ${sch.type}, got ${actualType}`);
+                return;
+            }
+        }
+        // Enum validation
+        if (sch.enum && !sch.enum.includes(value)) {
+            errors.push(`${path}: value must be one of: ${sch.enum.join(', ')}`);
+        }
+        // Object properties
+        if (sch.properties && typeof value === 'object' && value !== null) {
+            const obj = value;
+            // Required fields
+            if (sch.required) {
+                for (const reqField of sch.required) {
+                    if (!(reqField in obj)) {
+                        errors.push(`${path}.${reqField}: required field missing`);
+                    }
+                }
+            }
+            // Validate each property
+            for (const [key, propSchema] of Object.entries(sch.properties)) {
+                if (key in obj) {
+                    validate(obj[key], propSchema, `${path}.${key}`);
+                }
+            }
+            // Additional properties
+            if (sch.additionalProperties === false) {
+                const allowed = new Set(Object.keys(sch.properties));
+                for (const key of Object.keys(obj)) {
+                    if (!allowed.has(key)) {
+                        errors.push(`${path}.${key}: additional property not allowed`);
+                    }
+                }
+            }
+        }
+        // Array items
+        if (sch.items && Array.isArray(value)) {
+            for (let i = 0; i < value.length; i++) {
+                validate(value[i], sch.items, `${path}[${i}]`);
+            }
+        }
+    }
+    validate(data, schema, '$');
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * Import skills from a Claude Code skills directory
+ */
+function importSkillsFromDirectory(skillsDir) {
+    if (!(0, fs_1.existsSync)(skillsDir)) {
+        logger_1.logger.warn({ dir: skillsDir }, 'Skills directory not found');
+        return [];
+    }
+    const skills = [];
+    // Look for skill manifest files
+    const manifestNames = ['skill.json', 'manifest.json', 'package.json'];
+    try {
+        const { readdirSync, statSync } = require('fs');
+        const entries = readdirSync(skillsDir);
+        for (const entry of entries) {
+            const entryPath = (0, path_1.join)(skillsDir, entry);
+            const stat = statSync(entryPath);
+            if (stat.isDirectory()) {
+                // Check for manifest in subdirectory
+                for (const manifestName of manifestNames) {
+                    const manifestPath = (0, path_1.join)(entryPath, manifestName);
+                    if ((0, fs_1.existsSync)(manifestPath)) {
+                        try {
+                            const manifest = JSON.parse((0, fs_1.readFileSync)(manifestPath, 'utf-8'));
+                            skills.push({
+                                name: manifest.name || entry,
+                                description: manifest.description,
+                                commands: manifest.commands || manifest.skills || [],
+                                source: entryPath,
+                            });
+                        }
+                        catch (err) {
+                            logger_1.logger.warn({ path: manifestPath, error: err }, 'Failed to parse skill manifest');
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    catch (err) {
+        logger_1.logger.error({ dir: skillsDir, error: err }, 'Failed to read skills directory');
+    }
+    logger_1.logger.info({ count: skills.length }, 'Imported skills');
+    return skills;
+}
+/**
+ * Load MCP config from .mcp.json or similar
+ */
+function loadMcpConfig(configPath) {
+    const paths = configPath
+        ? [configPath]
+        : [
+            (0, path_1.join)(process.cwd(), '.mcp.json'),
+            (0, path_1.join)(process.cwd(), 'mcp.json'),
+            (0, path_1.join)((0, os_1.homedir)(), '.config', 'clodds', 'mcp.json'),
+            (0, path_1.join)((0, os_1.homedir)(), '.claude', 'mcp.json'),
+        ];
+    for (const p of paths) {
+        if ((0, fs_1.existsSync)(p)) {
+            try {
+                const content = (0, fs_1.readFileSync)(p, 'utf-8');
+                const config = JSON.parse(content);
+                logger_1.logger.info({ path: p }, 'Loaded MCP config');
+                return config;
+            }
+            catch (err) {
+                logger_1.logger.warn({ path: p, error: err }, 'Failed to parse MCP config');
+            }
+        }
+    }
+    return {};
+}
+/**
+ * Initialize registry from config file
+ */
+function initializeFromConfig(registry, config) {
+    if (!config.mcpServers)
+        return;
+    for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+        registry.register({
+            name,
+            command: serverConfig.command,
+            args: serverConfig.args,
+            env: serverConfig.env,
+            cwd: serverConfig.cwd,
+            headers: serverConfig.headers,
+            transport: serverConfig.transport,
+            sseEndpoint: serverConfig.sseEndpoint,
+            messageEndpoint: serverConfig.messageEndpoint,
+            autoStart: serverConfig.autoStart ?? true,
+            retryOnFailure: serverConfig.retryOnFailure,
+            maxRetries: serverConfig.maxRetries,
+            restartOnExit: serverConfig.restartOnExit,
+            requestTimeoutMs: serverConfig.requestTimeoutMs,
+            reconnectBaseMs: serverConfig.reconnectBaseMs,
+            reconnectMaxMs: serverConfig.reconnectMaxMs,
+        });
+    }
+}
+// =============================================================================
+// TOOL ADAPTER
+// =============================================================================
+/**
+ * Convert MCP tool to Clodds tool format
+ */
+function mcpToolToClodds(mcpTool) {
+    return {
+        name: `mcp__${mcpTool.server}__${mcpTool.name}`,
+        description: mcpTool.description || `MCP tool: ${mcpTool.name}`,
+        parameters: mcpTool.inputSchema,
+        registry: null, // Will be set by caller
+        async execute(params) {
+            const validation = validateSchema(params, mcpTool.inputSchema);
+            if (!validation.valid) {
+                throw new Error(`MCP tool parameter validation failed: ${validation.errors.join('; ')}`);
+            }
+            const registry = this.registry;
+            const result = await registry.callTool(`${mcpTool.server}:${mcpTool.name}`, params);
+            // Convert MCP result to string
+            if (result.isError) {
+                throw new Error(result.content.map(c => c.text).join('\n'));
+            }
+            return result.content
+                .map(c => {
+                if (c.type === 'text')
+                    return c.text;
+                if (c.type === 'resource')
+                    return `[Resource: ${c.uri}]`;
+                if (c.type === 'image')
+                    return `[Image: ${c.mimeType}]`;
+                return '';
+            })
+                .join('\n');
+        },
+    };
+}
+// =============================================================================
+// EXPORTS
+// =============================================================================
+exports.mcp = {
+    createRegistry: createMcpRegistry,
+    loadConfig: loadMcpConfig,
+    initializeFromConfig,
+    validateSchema,
+    importSkills: importSkillsFromDirectory,
+    toolToClodds: mcpToolToClodds,
+};
+//# sourceMappingURL=index.js.map