@syrin/cli 1.3.0

package/dist/runtime/llm/provider.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Base LLM provider interface.
+ * All LLM providers must implement this interface.
+ */
+import type { LLMRequest, LLMResponse } from './types.js';
+/**
+ * Base interface for all LLM providers.
+ */
+export interface LLMProvider {
+    /**
+     * Send a chat request to the LLM.
+     * @param request - The LLM request with messages and tools
+     * @returns Promise resolving to LLM response
+     */
+    chat(request: LLMRequest): Promise<LLMResponse>;
+    /**
+     * Check if this provider supports tool/function calling.
+     * @returns true if tool calling is supported
+     */
+    supportsToolCalls(): boolean;
+    /**
+     * Get the name of this provider.
+     * @returns Provider name (e.g., "OpenAI", "Claude", "Ollama")
+     */
+    getName(): string;
+    /**
+     * Get the model name being used.
+     * @returns Model name
+     */
+    getModelName(): string;
+}
+//# sourceMappingURL=provider.d.ts.map

package/dist/runtime/llm/provider.js

@@ -0,0 +1,6 @@
+/**
+ * Base LLM provider interface.
+ * All LLM providers must implement this interface.
+ */
+export {};
+//# sourceMappingURL=provider.js.map

package/dist/runtime/llm/types.d.ts

@@ -0,0 +1,55 @@
+/**
+ * LLM provider type definitions.
+ * Common types used across all LLM provider implementations.
+ */
+/**
+ * Message role in a conversation.
+ */
+export type MessageRole = 'user' | 'assistant' | 'system';
+/**
+ * A message in the conversation.
+ */
+export interface LLMMessage {
+    role: MessageRole;
+    content: string;
+}
+/**
+ * Tool definition for LLM function calling.
+ */
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+/**
+ * A tool call proposed by the LLM.
+ */
+export interface ToolCall {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+}
+/**
+ * LLM response containing text and optional tool calls.
+ */
+export interface LLMResponse {
+    content: string;
+    finishReason?: 'stop' | 'length' | 'tool_calls' | 'error';
+    toolCalls?: ToolCall[];
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+/**
+ * Request to send to LLM.
+ */
+export interface LLMRequest {
+    messages: LLMMessage[];
+    tools?: ToolDefinition[];
+    temperature?: number;
+    maxTokens?: number;
+    systemPrompt?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/runtime/llm/types.js

@@ -0,0 +1,6 @@
+/**
+ * LLM provider type definitions.
+ * Common types used across all LLM provider implementations.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/runtime/mcp/client/base.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Base MCP client manager with shared functionality.
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import type { EventEmitter } from '../../../events/emitter.js';
+import type { TransportType } from '../../../config/types.js';
+/**
+ * Base class for MCP client managers with shared functionality.
+ */
+export declare abstract class BaseMCPClientManager {
+    protected readonly eventEmitter: EventEmitter;
+    protected client: Client | null;
+    protected connected: boolean;
+    constructor(eventEmitter: EventEmitter);
+    /**
+     * Get available tools from the MCP server.
+     */
+    getAvailableTools(): Promise<Array<{
+        name: string;
+        description: string;
+        inputSchema: Record<string, unknown>;
+    }>>;
+    /**
+     * Execute a tool call.
+     */
+    executeTool(toolName: string, toolArguments: Record<string, unknown>, executionMode: boolean): Promise<unknown>;
+    /**
+     * Check if the manager is connected.
+     */
+    isConnected(): boolean;
+    /**
+     * Get the transport type (must be implemented by subclasses).
+     */
+    abstract getTransportType(): TransportType;
+    /**
+     * Helper to emit transport error events.
+     */
+    protected emitTransportError(errorMessage: string, errorCode: string, recoverable: boolean): Promise<void>;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/runtime/mcp/client/base.js

@@ -0,0 +1,157 @@
+/**
+ * Base MCP client manager with shared functionality.
+ */
+import { TransportEventType, ToolExecutionEventType, } from '../../../events/event-type.js';
+import { ConfigurationError } from '../../../utils/errors.js';
+import { v4 as uuidv4 } from 'uuid';
+/**
+ * Base class for MCP client managers with shared functionality.
+ */
+export class BaseMCPClientManager {
+    eventEmitter;
+    client = null;
+    connected = false;
+    constructor(eventEmitter) {
+        this.eventEmitter = eventEmitter;
+    }
+    /**
+     * Get available tools from the MCP server.
+     */
+    async getAvailableTools() {
+        if (!this.client || !this.connected) {
+            throw new ConfigurationError('MCP client is not connected');
+        }
+        try {
+            const response = await this.client.listTools();
+            return (response.tools || []).map(tool => ({
+                name: tool.name,
+                description: tool.description || '',
+                inputSchema: tool.inputSchema || {},
+            }));
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            await this.emitTransportError(`Failed to list tools: ${errorMessage}`, 'LIST_TOOLS_ERROR', true);
+            throw new Error(`Failed to list tools: ${errorMessage}`);
+        }
+    }
+    /**
+     * Execute a tool call.
+     */
+    async executeTool(toolName, toolArguments, executionMode) {
+        if (!this.client || !this.connected) {
+            throw new ConfigurationError('MCP client is not connected');
+        }
+        const executionId = uuidv4();
+        const startTime = Date.now();
+        // Emit tool execution started event
+        await this.eventEmitter.emit(ToolExecutionEventType.TOOL_EXECUTION_STARTED, {
+            tool_name: toolName,
+            arguments: toolArguments,
+            execution_id: executionId,
+        });
+        // Emit transport message sent event
+        // Construct request body from source variables to ensure consistency
+        const requestMessage = JSON.stringify({
+            method: 'tools/call',
+            params: {
+                name: toolName,
+                arguments: toolArguments,
+            },
+        });
+        // Derive tool_name and tool_arguments from the same source variables
+        // used to construct request_body to guarantee consistency
+        await this.eventEmitter.emit(TransportEventType.TRANSPORT_MESSAGE_SENT, {
+            transport_type: this.getTransportType(),
+            message_type: 'tools/call',
+            size_bytes: Buffer.byteLength(requestMessage, 'utf8'),
+            tool_name: toolName,
+            tool_arguments: toolArguments,
+            request_body: requestMessage,
+        });
+        if (!executionMode) {
+            // Preview mode - don't actually execute
+            const duration = Date.now() - startTime;
+            await this.eventEmitter.emit(ToolExecutionEventType.TOOL_EXECUTION_COMPLETED, {
+                tool_name: toolName,
+                arguments: toolArguments,
+                result: {
+                    preview: true,
+                    message: 'Tool call preview (not executed)',
+                },
+                execution_id: executionId,
+                duration_ms: duration,
+            });
+            return { preview: true, message: 'Tool call preview (not executed)' };
+        }
+        try {
+            // Execute the tool
+            const result = await this.client.callTool({
+                name: toolName,
+                arguments: toolArguments,
+            });
+            const duration = Date.now() - startTime;
+            // Emit transport message received event
+            const responseMessage = JSON.stringify(result);
+            await this.eventEmitter.emit(TransportEventType.TRANSPORT_MESSAGE_RECEIVED, {
+                transport_type: this.getTransportType(),
+                message_type: 'tools/call_response',
+                size_bytes: Buffer.byteLength(responseMessage, 'utf8'),
+            });
+            // Extract result content
+            const resultContent = result.content || [];
+            const textContent = resultContent
+                .filter((item) => item.type === 'text')
+                .map((item) => item.text || '')
+                .join('\n');
+            const toolResult = textContent || result;
+            // Emit tool execution completed event
+            await this.eventEmitter.emit(ToolExecutionEventType.TOOL_EXECUTION_COMPLETED, {
+                tool_name: toolName,
+                arguments: toolArguments,
+                result: toolResult,
+                execution_id: executionId,
+                duration_ms: duration,
+            });
+            return toolResult;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const errorStack = error instanceof Error ? error.stack : undefined;
+            // Emit tool execution failed event
+            await this.eventEmitter.emit(ToolExecutionEventType.TOOL_EXECUTION_FAILED, {
+                tool_name: toolName,
+                arguments: toolArguments,
+                execution_id: executionId,
+                error: {
+                    message: errorMessage,
+                    code: 'TOOL_EXECUTION_ERROR',
+                    stack_trace: errorStack,
+                    error_type: 'runtime',
+                },
+                duration_ms: duration,
+            });
+            await this.emitTransportError(errorMessage, 'TOOL_EXECUTION_ERROR', true);
+            throw new Error(`Tool execution failed: ${errorMessage}`);
+        }
+    }
+    /**
+     * Check if the manager is connected.
+     */
+    isConnected() {
+        return this.connected;
+    }
+    /**
+     * Helper to emit transport error events.
+     */
+    async emitTransportError(errorMessage, errorCode, recoverable) {
+        await this.eventEmitter.emit(TransportEventType.TRANSPORT_ERROR, {
+            transport_type: this.getTransportType(),
+            error_message: errorMessage,
+            error_code: errorCode,
+            recoverable,
+        });
+    }
+}
+//# sourceMappingURL=base.js.map

package/dist/runtime/mcp/client/manager.d.ts

@@ -0,0 +1,91 @@
+/**
+ * MCP Client Manager.
+ * Manages MCP client connections and tool execution with event integration.
+ */
+import type { EventEmitter } from '../../../events/emitter.js';
+import type { TransportType } from '../../../config/types.js';
+import type { MCPURL, Command } from '../../../types/ids.js';
+import { BaseMCPClientManager } from './base.js';
+/**
+ * MCP client manager interface.
+ */
+export interface MCPClientManager {
+    /**
+     * Connect to the MCP server.
+     * @returns Promise that resolves when connected
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the MCP server.
+     * @returns Promise that resolves when disconnected
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Get available tools from the MCP server.
+     * @returns Array of tool definitions
+     */
+    getAvailableTools(): Promise<Array<{
+        name: string;
+        description: string;
+        inputSchema: Record<string, unknown>;
+    }>>;
+    /**
+     * Execute a tool call.
+     * @param toolName - Name of the tool to execute
+     * @param toolArguments - Tool arguments
+     * @param executionMode - Whether to actually execute (true) or just preview (false)
+     * @returns Tool execution result
+     */
+    executeTool(toolName: string, toolArguments: Record<string, unknown>, executionMode: boolean): Promise<unknown>;
+    /**
+     * Check if the manager is connected.
+     * @returns true if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Get the transport type.
+     * @returns Transport type
+     */
+    getTransportType(): TransportType;
+}
+/**
+ * HTTP-based MCP client manager.
+ */
+export declare class HTTPMCPClientManager extends BaseMCPClientManager implements MCPClientManager {
+    private readonly mcpUrl;
+    private readonly shouldSpawn;
+    private readonly serverCommand?;
+    private transport;
+    private process;
+    constructor(mcpUrl: string, eventEmitter: EventEmitter, shouldSpawn?: boolean, serverCommand?: string | undefined);
+    connect(): Promise<void>;
+    /**
+     * Spawn the HTTP server as a child process and capture logs.
+     */
+    private spawnServer;
+    disconnect(): Promise<void>;
+    getTransportType(): TransportType;
+}
+/**
+ * Stdio-based MCP client manager.
+ */
+export declare class StdioMCPClientManager extends BaseMCPClientManager implements MCPClientManager {
+    private readonly command;
+    private transport;
+    private process;
+    constructor(command: string, eventEmitter: EventEmitter);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    getTransportType(): TransportType;
+}
+/**
+ * Factory function to create an MCP client manager.
+ * @param transport - Transport type
+ * @param mcpUrl - MCP URL (for HTTP transport)
+ * @param command - Command to spawn server (optional, only if shouldSpawn is true)
+ * @param eventEmitter - Event emitter for emitting events
+ * @param shouldSpawn - Whether to spawn the server as a child process
+ * @returns MCP client manager instance
+ */
+export declare function createMCPClientManager(transport: TransportType, mcpUrl: MCPURL | string | undefined, command: Command | string | undefined, eventEmitter: EventEmitter, shouldSpawn?: boolean): MCPClientManager;
+//# sourceMappingURL=manager.d.ts.map

package/dist/runtime/mcp/client/manager.js

@@ -0,0 +1,248 @@
+/**
+ * MCP Client Manager.
+ * Manages MCP client connections and tool execution with event integration.
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { TransportEventType } from '../../../events/event-type.js';
+import { getConnectedClient } from '../connection.js';
+import { ConfigurationError } from '../../../utils/errors.js';
+import { logger } from '../../../utils/logger.js';
+import { parseCommand, setupProcessLogCapture, spawnProcess } from './process.js';
+import { BaseMCPClientManager } from './base.js';
+/**
+ * HTTP-based MCP client manager.
+ */
+export class HTTPMCPClientManager extends BaseMCPClientManager {
+    mcpUrl;
+    shouldSpawn;
+    serverCommand;
+    transport = null;
+    process = null;
+    constructor(mcpUrl, eventEmitter, shouldSpawn = false, serverCommand) {
+        super(eventEmitter);
+        this.mcpUrl = mcpUrl;
+        this.shouldSpawn = shouldSpawn;
+        this.serverCommand = serverCommand;
+    }
+    async connect() {
+        if (this.connected) {
+            return;
+        }
+        try {
+            // Spawn server process if needed
+            if (this.shouldSpawn && this.serverCommand) {
+                this.spawnServer();
+                // Wait a bit for server to start
+                await new Promise(resolve => setTimeout(resolve, 2000));
+            }
+            // Emit transport initialization event
+            await this.eventEmitter.emit(TransportEventType.TRANSPORT_INITIALIZED, {
+                transport_type: 'http',
+                endpoint: this.mcpUrl,
+                ...(this.shouldSpawn && this.serverCommand
+                    ? { command: this.serverCommand }
+                    : {}),
+            });
+            const connection = await getConnectedClient(this.mcpUrl, undefined, 10000);
+            this.client = connection.client;
+            this.transport = connection.transport;
+            this.connected = true;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // Clean up spawned process on error
+            if (this.process) {
+                this.process.kill();
+                this.process = null;
+            }
+            // Emit transport error event
+            await this.eventEmitter.emit(TransportEventType.TRANSPORT_ERROR, {
+                transport_type: 'http',
+                error_message: errorMessage,
+                error_code: 'CONNECTION_FAILED',
+                recoverable: true,
+            });
+            throw new ConfigurationError(`Failed to connect to MCP server at ${this.mcpUrl}: ${errorMessage}`);
+        }
+    }
+    /**
+     * Spawn the HTTP server as a child process and capture logs.
+     */
+    spawnServer() {
+        if (!this.serverCommand) {
+            throw new ConfigurationError('Server command is required for spawning');
+        }
+        const command = this.serverCommand.trim();
+        if (!command) {
+            throw new ConfigurationError('Server command is empty');
+        }
+        const { executable, args } = parseCommand(command);
+        this.process = spawnProcess(executable, args);
+        setupProcessLogCapture(this.process);
+        // Handle process errors
+        this.process.on('error', (error) => {
+            void this.emitTransportError(`Failed to spawn server process: ${error.message}`, 'SPAWN_ERROR', false);
+        });
+        // Handle process exit
+        this.process.on('exit', (code, signal) => {
+            if (code !== null && code !== 0) {
+                void this.emitTransportError(`Server process exited with code ${code}${signal ? ` (signal: ${signal})` : ''}`, 'SERVER_EXIT', false);
+            }
+        });
+    }
+    async disconnect() {
+        if (!this.connected) {
+            return;
+        }
+        try {
+            if (this.transport) {
+                await this.transport.close();
+            }
+            this.connected = false;
+            this.client = null;
+            this.transport = null;
+        }
+        catch (error) {
+            // Log but don't throw - cleanup errors are non-critical
+            const err = error instanceof Error ? error : new Error(String(error));
+            logger.error('Error closing transport during disconnect', err);
+            await this.eventEmitter.emit(TransportEventType.TRANSPORT_ERROR, {
+                transport_type: 'http',
+                error_message: err.message,
+                error_code: 'DISCONNECT_ERROR',
+                recoverable: false,
+            });
+        }
+    }
+    getTransportType() {
+        return 'http';
+    }
+}
+/**
+ * Stdio-based MCP client manager.
+ */
+export class StdioMCPClientManager extends BaseMCPClientManager {
+    command;
+    transport = null;
+    process = null;
+    constructor(command, eventEmitter) {
+        super(eventEmitter);
+        this.command = command;
+    }
+    async connect() {
+        if (this.connected) {
+            return;
+        }
+        try {
+            const command = this.command.trim();
+            if (!command) {
+                throw new ConfigurationError('Command is empty');
+            }
+            const { executable, args } = parseCommand(command);
+            // Emit transport initialization event
+            await this.eventEmitter.emit(TransportEventType.TRANSPORT_INITIALIZED, {
+                transport_type: 'stdio',
+                command: this.command,
+            });
+            // Create MCP client
+            this.client = new Client({
+                name: 'syrin',
+                version: '1.0.0',
+            }, {
+                capabilities: {},
+            });
+            // Spawn the process
+            this.process = spawnProcess(executable, args);
+            setupProcessLogCapture(this.process);
+            // Create stdio transport
+            this.transport = new StdioClientTransport({
+                command: executable,
+                args,
+                env: process.env,
+            });
+            // Set up error handler
+            this.client.onerror = () => {
+                // Error handler - errors are logged but we'll catch them in try-catch
+            };
+            // Set up process error handler
+            this.process.on('error', (error) => {
+                throw new Error(`Failed to start process: ${error.message}`);
+            });
+            // Connect with timeout
+            const connectionPromise = this.client.connect(this.transport);
+            const timeoutPromise = new Promise((_, reject) => {
+                setTimeout(() => {
+                    if (this.process) {
+                        this.process.kill();
+                    }
+                    reject(new Error(`Connection timeout after 10000ms`));
+                }, 10000);
+            });
+            await Promise.race([connectionPromise, timeoutPromise]);
+            this.connected = true;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // Clean up on error
+            if (this.process) {
+                this.process.kill();
+                this.process = null;
+            }
+            // Emit transport error event
+            await this.eventEmitter.emit(TransportEventType.TRANSPORT_ERROR, {
+                transport_type: 'stdio',
+                error_message: errorMessage,
+                error_code: 'CONNECTION_FAILED',
+                recoverable: true,
+            });
+            throw new ConfigurationError(`Failed to connect to MCP server via stdio: ${errorMessage}`);
+        }
+    }
+    async disconnect() {
+        if (!this.connected) {
+            return;
+        }
+        try {
+            if (this.transport) {
+                await this.transport.close();
+            }
+            this.connected = false;
+            this.client = null;
+            this.transport = null;
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            logger.error('Error closing transport during disconnect', err);
+            await this.emitTransportError(err.message, 'DISCONNECT_ERROR', false);
+        }
+    }
+    getTransportType() {
+        return 'stdio';
+    }
+}
+/**
+ * Factory function to create an MCP client manager.
+ * @param transport - Transport type
+ * @param mcpUrl - MCP URL (for HTTP transport)
+ * @param command - Command to spawn server (optional, only if shouldSpawn is true)
+ * @param eventEmitter - Event emitter for emitting events
+ * @param shouldSpawn - Whether to spawn the server as a child process
+ * @returns MCP client manager instance
+ */
+export function createMCPClientManager(transport, mcpUrl, command, eventEmitter, shouldSpawn = false) {
+    if (transport === 'http') {
+        if (!mcpUrl) {
+            throw new ConfigurationError('MCP URL is required for HTTP transport');
+        }
+        return new HTTPMCPClientManager(mcpUrl, eventEmitter, shouldSpawn, command);
+    }
+    if (transport === 'stdio') {
+        if (!command) {
+            throw new ConfigurationError('Command is required for stdio transport');
+        }
+        return new StdioMCPClientManager(command, eventEmitter);
+    }
+    throw new ConfigurationError(`Unsupported transport type: ${String(transport)}`);
+}
+//# sourceMappingURL=manager.js.map

package/dist/runtime/mcp/client/process.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Process spawning utilities for MCP servers.
+ */
+import * as childProcess from 'child_process';
+/**
+ * Check if a command contains shell operators that require shell execution.
+ * We only detect patterns that absolutely require a shell, avoiding false positives.
+ * Essential operators: &&, ||, |, ;, $, $(, `
+ */
+export declare function requiresShellExecution(command: string): boolean;
+/**
+ * Parse a command into executable and arguments.
+ * Handles shell operators by wrapping in shell execution.
+ */
+export declare function parseCommand(command: string): {
+    executable: string;
+    args: string[];
+};
+/**
+ * Set up log capture for a child process.
+ * Captures stdout and stderr, formatting them appropriately.
+ */
+export declare function setupProcessLogCapture(process: childProcess.ChildProcess): void;
+/**
+ * Spawn a process with proper configuration.
+ */
+export declare function spawnProcess(executable: string, args: string[], options?: {
+    cwd?: string;
+    env?: Record<string, string>;
+}): childProcess.ChildProcess;
+//# sourceMappingURL=process.d.ts.map