@mcpilotx/intentorch 0.5.0

package/dist/daemon/service.js

@@ -0,0 +1,278 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { spawn } from 'child_process';
+import { CONFIG_PATH, LOGS_DIR } from '../core/constants.js';
+import { logger } from '../core/logger.js';
+export class ServiceManager {
+    services = new Map();
+    processes = new Map();
+    constructor() {
+        this.loadServices();
+    }
+    loadServices() {
+        if (!fs.existsSync(CONFIG_PATH)) {
+            return;
+        }
+        const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+        const serviceInstances = config.services?.instances || [];
+        for (const service of serviceInstances) {
+            this.services.set(service.name, {
+                ...service,
+                status: service.status || 'installed',
+            });
+        }
+    }
+    saveServices() {
+        const config = fs.existsSync(CONFIG_PATH)
+            ? JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'))
+            : { services: {} };
+        config.services.instances = Array.from(this.services.values());
+        fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+    }
+    async installService(servicePath, name) {
+        const resolvedPath = path.resolve(servicePath);
+        if (!fs.existsSync(resolvedPath)) {
+            throw new Error(`Service path not found: ${resolvedPath}`);
+        }
+        const serviceName = name || path.basename(resolvedPath);
+        // Check if service is already installed
+        if (this.services.has(serviceName)) {
+            throw new Error(`Service ${serviceName} is already installed`);
+        }
+        // Create service configuration
+        const serviceConfig = {
+            name: serviceName,
+            path: resolvedPath,
+            runtime: 'node', // Default, should actually be obtained from detector
+            entry: this.detectEntryPoint(resolvedPath),
+        };
+        const serviceInfo = {
+            name: serviceName,
+            path: resolvedPath,
+            runtime: serviceConfig.runtime,
+            status: 'installed',
+            installedAt: new Date().toISOString(),
+            config: serviceConfig,
+        };
+        this.services.set(serviceName, serviceInfo);
+        this.saveServices();
+        logger.info(`Service installed: ${serviceName} at ${resolvedPath}`);
+        return serviceInfo;
+    }
+    async startService(name) {
+        const service = this.services.get(name);
+        if (!service) {
+            throw new Error(`Service ${name} is not installed`);
+        }
+        if (service.status === 'running') {
+            logger.warn(`Service ${name} is already running`);
+            return service;
+        }
+        try {
+            // Create log directory
+            const logDir = path.join(LOGS_DIR, name);
+            if (!fs.existsSync(logDir)) {
+                fs.mkdirSync(logDir, { recursive: true });
+            }
+            const stdoutLog = path.join(logDir, 'stdout.log');
+            const stderrLog = path.join(logDir, 'stderr.log');
+            const stdout = fs.openSync(stdoutLog, 'a');
+            const stderr = fs.openSync(stderrLog, 'a');
+            // Start service based on runtime
+            const process = this.spawnService(service);
+            process.stdout?.pipe(fs.createWriteStream(stdoutLog, { flags: 'a' }));
+            process.stderr?.pipe(fs.createWriteStream(stderrLog, { flags: 'a' }));
+            this.processes.set(name, process);
+            // Update service status
+            service.status = 'running';
+            service.startedAt = new Date().toISOString();
+            service.stoppedAt = undefined;
+            service.pid = process.pid;
+            this.saveServices();
+            logger.info(`Service started: ${name} (PID: ${process.pid})`);
+            return service;
+        }
+        catch (error) {
+            service.status = 'error';
+            this.saveServices();
+            throw new Error(`Failed to start service ${name}: ${error.message}`, { cause: error });
+        }
+    }
+    async stopService(name) {
+        const service = this.services.get(name);
+        if (!service) {
+            throw new Error(`Service ${name} is not installed`);
+        }
+        if (service.status !== 'running') {
+            logger.warn(`Service ${name} is not running`);
+            return service;
+        }
+        const process = this.processes.get(name);
+        if (process) {
+            process.kill();
+            this.processes.delete(name);
+        }
+        service.status = 'stopped';
+        service.stoppedAt = new Date().toISOString();
+        service.pid = undefined;
+        this.saveServices();
+        logger.info(`Service stopped: ${name}`);
+        return service;
+    }
+    async restartService(name) {
+        await this.stopService(name);
+        // Wait for a while to ensure process is completely stopped
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        return await this.startService(name);
+    }
+    async uninstallService(name) {
+        const service = this.services.get(name);
+        if (!service) {
+            throw new Error(`Service ${name} is not installed`);
+        }
+        // If service is running, stop it first
+        if (service.status === 'running') {
+            await this.stopService(name);
+        }
+        // Remove from configuration
+        this.services.delete(name);
+        this.saveServices();
+        logger.info(`Service uninstalled: ${name}`);
+    }
+    getService(name) {
+        return this.services.get(name);
+    }
+    getAllServices() {
+        return Array.from(this.services.values());
+    }
+    getRunningServices() {
+        return Array.from(this.services.values()).filter(s => s.status === 'running');
+    }
+    async getServiceLogs(name, lines = 50) {
+        const logDir = path.join(LOGS_DIR, name);
+        const logFile = path.join(logDir, 'stdout.log');
+        if (!fs.existsSync(logFile)) {
+            return `No logs found for service ${name}`;
+        }
+        try {
+            const content = fs.readFileSync(logFile, 'utf-8');
+            const linesArray = content.split('\n');
+            return linesArray.slice(-lines).join('\n');
+        }
+        catch (error) {
+            return `Failed to read logs: ${error.message}`;
+        }
+    }
+    async getServiceStats(name) {
+        const service = this.services.get(name);
+        if (!service) {
+            throw new Error(`Service ${name} not found`);
+        }
+        const process = this.processes.get(name);
+        return {
+            name: service.name,
+            status: service.status,
+            pid: service.pid,
+            runtime: service.runtime,
+            installedAt: service.installedAt,
+            startedAt: service.startedAt,
+            stoppedAt: service.stoppedAt,
+            isProcessAlive: process ? !process.exitCode : false,
+            memoryUsage: this.getProcessMemoryUsage(process),
+            uptime: service.startedAt
+                ? Date.now() - new Date(service.startedAt).getTime()
+                : 0,
+        };
+    }
+    spawnService(service) {
+        const { config } = service;
+        const cwd = config.path || '.';
+        let command;
+        let args = [];
+        switch (service.runtime) {
+            case 'node':
+                command = 'node';
+                args = [config.entry, ...(config.args || [])];
+                break;
+            case 'python':
+                command = 'python3';
+                args = [config.entry, ...(config.args || [])];
+                break;
+            case 'docker':
+                command = 'docker';
+                args = ['run', '-d', '--rm', '--name', `mcp-${service.name}`, config.image || service.name];
+                if (config.args) {
+                    args.push(...config.args);
+                }
+                break;
+            default:
+                command = config.entry;
+                args = config.args || [];
+        }
+        logger.debug(`Spawning service: ${command} ${args.join(' ')}`);
+        return spawn(command, args, {
+            cwd,
+            env: {
+                ...process.env,
+                ...config.env,
+            },
+            stdio: ['pipe', 'pipe', 'pipe'],
+            detached: false,
+        });
+    }
+    detectEntryPoint(servicePath) {
+        const possibleEntries = [
+            'index.js', 'main.js', 'app.js', 'server.js',
+            'index.ts', 'main.ts', 'app.ts', 'server.ts',
+            'main.py', 'app.py', 'server.py',
+            'main.go', 'server.go',
+            'main.rs', 'lib.rs',
+        ];
+        for (const entry of possibleEntries) {
+            const entryPath = path.join(servicePath, entry);
+            if (fs.existsSync(entryPath)) {
+                return entry;
+            }
+        }
+        // If no standard entry point found, return the first file
+        const files = fs.readdirSync(servicePath);
+        const firstFile = files.find(f => f.endsWith('.js') || f.endsWith('.ts') || f.endsWith('.py') ||
+            f.endsWith('.go') || f.endsWith('.rs'));
+        return firstFile || 'index.js';
+    }
+    getProcessMemoryUsage(process) {
+        if (!process || !process.pid) {
+            return undefined;
+        }
+        try {
+            // This is a simplified implementation, should actually use system-specific methods
+            // For example, reading /proc/[pid]/status on Linux
+            return 0;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async healthCheck(name) {
+        const service = this.services.get(name);
+        if (!service || service.status !== 'running') {
+            return false;
+        }
+        const process = this.processes.get(name);
+        if (!process || process.exitCode !== null) {
+            return false;
+        }
+        // More complex health check logic can be added here
+        // For example, checking HTTP endpoints, TCP ports, etc.
+        return true;
+    }
+    async cleanup() {
+        // Stop all running services
+        for (const [name, service] of this.services) {
+            if (service.status === 'running') {
+                await this.stopService(name);
+            }
+        }
+    }
+}
+//# sourceMappingURL=service.js.map

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+import { SDKOptions, MCPilotSDK, mcpilot } from './sdk';
+/**
+ * IntentOrch SDK Core - Main Entry File
+ * Exports all public APIs, designed for developers
+ * Formerly known as MCPilot SDK
+ */
+export { MCPilotSDK, IntentOrchSDK, mcpilot, intentorch } from './sdk';
+export type { SDKOptions, ServiceStatus, AskOptions, AskResult, } from './sdk';
+export type { RuntimeType, ServiceConfig, Config, AIConfig, DetectionResult, } from './core/types';
+export type { RuntimeAdapter } from './runtime/adapter';
+export { EnhancedRuntimeDetector } from './runtime/detector-advanced';
+export { ConfigManager } from './core/config-manager';
+export { SimpleAI } from './ai/ai';
+export { CloudIntentEngine, type CloudIntentEngineConfig, type AtomicIntent, type DependencyEdge, type IntentParseResult, type ToolSelectionResult, type ExecutionContext, type ExecutionResult, type EnhancedExecutionStep, type WorkflowPlan, type EnhancedExecutionResult, } from './ai';
+export { MCPClient, ToolRegistry, createMCPConfig, TOOL_CATEGORIES, TOOL_PATTERNS, discoverLocalMCPServers, loadMCPServersFromEnv, } from './mcp';
+export { BaseTransport, StdioTransport, HTTPTransport, SSETransport, TransportFactory } from './mcp/transport';
+export { MCP_METHODS, MCP_ERROR_CODES } from './mcp/types';
+export type { Tool, ToolCall, ToolResult, MCPClientConfig, TransportConfig, StdioLogFilterConfig, TransportType, MCPError, JSONRPCRequest, JSONRPCResponse, Resource, ResourceList, ResourceContents, Prompt, PromptList, MCPSession, MCPEvent, MCPEventType, } from './mcp/types';
+export { logger } from './core/logger';
+export { MCPilotError, IntentOrchError, ErrorCode, ErrorSeverity, ErrorFactory, ErrorHandler, ConsoleErrorHandler, RetryErrorHandler, createError, wrapError, isMCPilotError, shouldRetry, } from './core/error-handler';
+export { PerformanceMonitor, getPerformanceMonitor } from './core/performance-monitor';
+/**
+ * Quick start function - Create and return SDK instance
+ */
+export declare function createSDK(options?: SDKOptions): MCPilotSDK;
+/**
+ * Default export - Singleton instance
+ */
+export default mcpilot;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,36 @@
+import { MCPilotSDK, mcpilot } from './sdk.js';
+/**
+ * IntentOrch SDK Core - Main Entry File
+ * Exports all public APIs, designed for developers
+ * Formerly known as MCPilot SDK
+ */
+// Export core SDK class and types (with backward compatibility)
+export { MCPilotSDK, IntentOrchSDK, mcpilot, intentorch } from './sdk.js';
+export { EnhancedRuntimeDetector } from './runtime/detector-advanced.js';
+// Export configuration manager
+export { ConfigManager } from './core/config-manager.js';
+// Export AI functionality (optional)
+export { SimpleAI } from './ai/ai.js';
+// Export Cloud Intent Engine functionality
+export { CloudIntentEngine, } from './ai/index.js';
+// Export MCP functionality
+export { MCPClient, ToolRegistry, createMCPConfig, TOOL_CATEGORIES, TOOL_PATTERNS, discoverLocalMCPServers, loadMCPServersFromEnv, } from './mcp/index.js';
+export { BaseTransport, StdioTransport, HTTPTransport, SSETransport, TransportFactory } from './mcp/transport.js';
+export { MCP_METHODS, MCP_ERROR_CODES } from './mcp/types.js';
+// Export utility functions
+export { logger } from './core/logger.js';
+// Export error handling
+export { MCPilotError, IntentOrchError, ErrorCode, ErrorSeverity, ErrorFactory, ErrorHandler, ConsoleErrorHandler, RetryErrorHandler, createError, wrapError, isMCPilotError, shouldRetry, } from './core/error-handler.js';
+// Export performance monitoring
+export { PerformanceMonitor, getPerformanceMonitor } from './core/performance-monitor.js';
+/**
+ * Quick start function - Create and return SDK instance
+ */
+export function createSDK(options) {
+    return new MCPilotSDK(options);
+}
+/**
+ * Default export - Singleton instance
+ */
+export default mcpilot;
+//# sourceMappingURL=index.js.map

package/dist/mcp/client.d.ts

@@ -0,0 +1,51 @@
+/**
+ * MCP Client Core Class
+ * Provides complete MCP protocol client functionality
+ */
+import { EventEmitter } from 'events';
+import { MCPClientConfig, Tool, ToolResult, Resource, Prompt } from './types';
+export declare class MCPClient extends EventEmitter {
+    private config;
+    private transport;
+    private connected;
+    private requestId;
+    private pendingRequests;
+    private tools;
+    private resources;
+    private prompts;
+    private sessionId?;
+    constructor(config: MCPClientConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    listTools(): Promise<Tool[]>;
+    callTool(toolName: string, arguments_: Record<string, any>): Promise<ToolResult>;
+    refreshTools(): Promise<void>;
+    getTools(): Tool[];
+    findTool(name: string): Tool | undefined;
+    listResources(): Promise<Resource[]>;
+    readResource(uri: string): Promise<any>;
+    refreshResources(): Promise<void>;
+    getResources(): Resource[];
+    listPrompts(): Promise<Prompt[]>;
+    getPrompt(name: string, arguments_?: Record<string, any>): Promise<any>;
+    refreshPrompts(): Promise<void>;
+    getPrompts(): Prompt[];
+    private sendRequest;
+    private generateRequestId;
+    private setupTransportListeners;
+    private handleTransportMessage;
+    private handleTransportError;
+    private handleNotification;
+    private emitEvent;
+    withRetry<T>(operation: () => Promise<T>): Promise<T>;
+    getStatus(): {
+        connected: boolean;
+        toolsCount: number;
+        resourcesCount: number;
+        promptsCount: number;
+        sessionId: string;
+    };
+    destroy(): void;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/mcp/client.js

@@ -0,0 +1,276 @@
+/**
+ * MCP Client Core Class
+ * Provides complete MCP protocol client functionality
+ */
+import { EventEmitter } from 'events';
+import { MCP_METHODS, } from './types.js';
+import { TransportFactory } from './transport.js';
+export class MCPClient extends EventEmitter {
+    config;
+    transport;
+    connected = false;
+    requestId = 0;
+    pendingRequests = new Map();
+    // State
+    tools = [];
+    resources = [];
+    prompts = [];
+    sessionId;
+    constructor(config) {
+        super();
+        this.config = {
+            autoConnect: false, // Default disable auto-connect requests to avoid server not being ready
+            timeout: 30000,
+            maxRetries: 3,
+            ...config,
+        };
+        this.transport = TransportFactory.create(config.transport);
+        this.setupTransportListeners();
+    }
+    // ==================== Connection Management ====================
+    async connect() {
+        if (this.connected) {
+            return;
+        }
+        try {
+            await this.transport.connect();
+            this.connected = true;
+            this.emitEvent('connected');
+            // Automatically fetch tool list after connection
+            if (this.config.autoConnect) {
+                await this.refreshTools();
+                await this.refreshResources();
+                await this.refreshPrompts();
+            }
+        }
+        catch (error) {
+            this.emitEvent('error', error);
+            throw error;
+        }
+    }
+    async disconnect() {
+        if (!this.connected) {
+            return;
+        }
+        try {
+            await this.transport.disconnect();
+            this.connected = false;
+            // Clean up all pending requests
+            this.pendingRequests.forEach(({ reject, timeout }) => {
+                clearTimeout(timeout);
+                reject(new Error('Disconnected'));
+            });
+            this.pendingRequests.clear();
+            this.emitEvent('disconnected');
+        }
+        catch (error) {
+            this.emitEvent('error', error);
+            throw error;
+        }
+    }
+    isConnected() {
+        return this.connected && this.transport.isConnected();
+    }
+    // ==================== Tool Related Methods ====================
+    async listTools() {
+        const response = await this.sendRequest(MCP_METHODS.TOOLS_LIST);
+        const toolList = response;
+        this.tools = toolList.tools;
+        this.emitEvent('tools_updated', this.tools);
+        return this.tools;
+    }
+    async callTool(toolName, arguments_) {
+        const toolCall = {
+            name: toolName,
+            arguments: arguments_,
+        };
+        const response = await this.sendRequest(MCP_METHODS.TOOLS_CALL, { call: toolCall });
+        // Ensure response is a valid ToolResult
+        const toolResult = response;
+        // Check if the tool execution failed (isError flag)
+        if (toolResult.isError) {
+            // Create a proper error from the tool result content
+            const errorMessage = toolResult.content?.[0]?.text || 'Tool execution failed';
+            throw new Error(`Tool "${toolName}" execution failed: ${errorMessage}`);
+        }
+        return toolResult;
+    }
+    async refreshTools() {
+        await this.listTools();
+    }
+    getTools() {
+        return [...this.tools];
+    }
+    findTool(name) {
+        return this.tools.find(tool => tool.name === name);
+    }
+    // ==================== Resource Related Methods ====================
+    async listResources() {
+        const response = await this.sendRequest(MCP_METHODS.RESOURCES_LIST);
+        const resourceList = response;
+        this.resources = resourceList.resources;
+        this.emitEvent('resources_updated', this.resources);
+        return this.resources;
+    }
+    async readResource(uri) {
+        const response = await this.sendRequest(MCP_METHODS.RESOURCES_READ, { uri });
+        return response;
+    }
+    async refreshResources() {
+        await this.listResources();
+    }
+    getResources() {
+        return [...this.resources];
+    }
+    // ==================== Prompt Related Methods ====================
+    async listPrompts() {
+        const response = await this.sendRequest(MCP_METHODS.PROMPTS_LIST);
+        const promptList = response;
+        this.prompts = promptList.prompts;
+        this.emitEvent('prompts_updated', this.prompts);
+        return this.prompts;
+    }
+    async getPrompt(name, arguments_) {
+        const response = await this.sendRequest(MCP_METHODS.PROMPTS_GET, {
+            name,
+            arguments: arguments_,
+        });
+        return response;
+    }
+    async refreshPrompts() {
+        await this.listPrompts();
+    }
+    getPrompts() {
+        return [...this.prompts];
+    }
+    // ==================== Core Request Methods ====================
+    async sendRequest(method, params) {
+        if (!this.isConnected()) {
+            throw new Error('Not connected to MCP server');
+        }
+        const requestId = this.generateRequestId();
+        const request = {
+            jsonrpc: '2.0',
+            id: requestId,
+            method,
+            params,
+        };
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(requestId);
+                reject(new Error(`Request timeout after ${this.config.timeout}ms`));
+            }, this.config.timeout);
+            this.pendingRequests.set(requestId, { resolve, reject, timeout });
+            this.transport.send(request).catch(error => {
+                this.pendingRequests.delete(requestId);
+                clearTimeout(timeout);
+                reject(error);
+            });
+        });
+    }
+    generateRequestId() {
+        return `req_${++this.requestId}_${Date.now()}`;
+    }
+    // ==================== Transport Layer Event Handling ====================
+    setupTransportListeners() {
+        this.transport.on('message', this.handleTransportMessage.bind(this));
+        this.transport.on('error', this.handleTransportError.bind(this));
+        this.transport.on('connected', () => {
+            this.connected = true;
+            this.emitEvent('connected');
+        });
+        this.transport.on('disconnected', () => {
+            this.connected = false;
+            this.emitEvent('disconnected');
+        });
+    }
+    handleTransportMessage(message) {
+        try {
+            const response = message;
+            // Handle request response
+            if (response.id && this.pendingRequests.has(response.id)) {
+                const { resolve, reject, timeout } = this.pendingRequests.get(response.id);
+                clearTimeout(timeout);
+                this.pendingRequests.delete(response.id);
+                if (response.error) {
+                    const errorMessage = response.error.message || 'Unknown error';
+                    const error = new Error(errorMessage);
+                    error.code = response.error.code;
+                    error.data = response.error.data;
+                    reject(error);
+                }
+                else {
+                    resolve(response.result);
+                }
+            }
+            // Handle server-pushed notifications (messages without id)
+            else if (!response.id) {
+                this.handleNotification(response);
+            }
+        }
+        catch (error) {
+            this.emitEvent('error', error);
+        }
+    }
+    handleTransportError(error) {
+        this.emitEvent('error', error);
+    }
+    handleNotification(response) {
+        // Handle server-pushed notifications
+        // For example: tools/changed, resources/changed, etc.
+        if (response.result) {
+            // Can handle different types of notifications based on method field
+            console.log('Received notification:', response);
+        }
+    }
+    // ==================== Event Emission ====================
+    emitEvent(type, data) {
+        const event = {
+            type,
+            data,
+            timestamp: Date.now(),
+        };
+        this.emit(type, event);
+        this.emit('event', event);
+    }
+    // ==================== Utility Methods ====================
+    async withRetry(operation) {
+        let lastError;
+        for (let attempt = 1; attempt <= this.config.maxRetries; attempt++) {
+            try {
+                return await operation();
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt < this.config.maxRetries) {
+                    const delay = Math.min(1000 * Math.pow(2, attempt - 1), 10000);
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                    continue;
+                }
+            }
+        }
+        throw lastError;
+    }
+    // ==================== Status Query ====================
+    getStatus() {
+        return {
+            connected: this.connected,
+            toolsCount: this.tools.length,
+            resourcesCount: this.resources.length,
+            promptsCount: this.prompts.length,
+            sessionId: this.sessionId,
+        };
+    }
+    // ==================== Cleanup ====================
+    destroy() {
+        this.disconnect().catch(() => {
+            // Ignore errors when disconnecting
+        });
+        this.removeAllListeners();
+        this.pendingRequests.clear();
+        this.tools = [];
+        this.resources = [];
+        this.prompts = [];
+    }
+}
+//# sourceMappingURL=client.js.map