@syrin/cli 1.3.0

package/dist/runtime/mcp/list.js

@@ -0,0 +1,65 @@
+/**
+ * MCP listing utilities.
+ * Provides functions to list tools, resources, and prompts from MCP servers.
+ */
+/**
+ * Helper function to handle errors consistently across list functions.
+ */
+function handleListError(operation, error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to list ${operation}: ${errorMessage}`);
+}
+/**
+ * List all tools available from the MCP server.
+ */
+export async function listTools(client) {
+    try {
+        const response = await client.listTools();
+        return {
+            tools: response.tools || [],
+        };
+    }
+    catch (error) {
+        handleListError('tools', error);
+    }
+}
+/**
+ * List all resources available from the MCP server.
+ */
+export async function listResources(client) {
+    try {
+        const response = await client.listResources();
+        return {
+            resources: response.resources || [],
+        };
+    }
+    catch (error) {
+        handleListError('resources', error);
+    }
+}
+/**
+ * List all prompts available from the MCP server.
+ */
+export async function listPrompts(client) {
+    try {
+        const response = await client.listPrompts();
+        return {
+            prompts: response.prompts || [],
+        };
+    }
+    catch (error) {
+        handleListError('prompts', error);
+    }
+}
+/**
+ * Close the MCP transport connection.
+ */
+export async function closeConnection(transport) {
+    try {
+        await transport.close();
+    }
+    catch {
+        // Ignore errors during cleanup
+    }
+}
+//# sourceMappingURL=list.js.map

package/dist/runtime/mcp/stdio-transport.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Stdio transport utilities for MCP.
+ * Provides functions to get connected clients via stdio transport.
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import * as childProcess from 'child_process';
+import type { Command } from '../../types/ids.js';
+/**
+ * Get a connected MCP client via stdio transport that stays open for operations.
+ * Use this when you need to perform multiple operations with the same connection.
+ * Remember to call close() on the transport when done.
+ *
+ * @param command - The command to execute (e.g., "python3 server.py")
+ * @param timeout - Connection timeout in milliseconds (default: 10000)
+ * @returns Connected client and transport instances
+ */
+export declare function getConnectedStdioClient(command: Command | string, timeout?: number): Promise<{
+    client: Client;
+    transport: StdioClientTransport;
+    process: childProcess.ChildProcess;
+}>;
+//# sourceMappingURL=stdio-transport.d.ts.map

package/dist/runtime/mcp/stdio-transport.js

@@ -0,0 +1,71 @@
+/**
+ * Stdio transport utilities for MCP.
+ * Provides functions to get connected clients via stdio transport.
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import * as childProcess from 'child_process';
+/**
+ * Get a connected MCP client via stdio transport that stays open for operations.
+ * Use this when you need to perform multiple operations with the same connection.
+ * Remember to call close() on the transport when done.
+ *
+ * @param command - The command to execute (e.g., "python3 server.py")
+ * @param timeout - Connection timeout in milliseconds (default: 10000)
+ * @returns Connected client and transport instances
+ */
+export async function getConnectedStdioClient(command, timeout = 10000) {
+    // Split command into executable and arguments
+    const parts = command.trim().split(/\s+/);
+    const executable = parts[0];
+    const args = parts.slice(1);
+    if (!executable) {
+        throw new Error('Command is empty');
+    }
+    // Create MCP client
+    const client = new Client({
+        name: 'syrin',
+        version: '1.0.0',
+    }, {
+        capabilities: {},
+    });
+    // Spawn the process
+    const childProc = childProcess.spawn(executable, args, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: process.env,
+    });
+    // Create stdio transport
+    const transport = new StdioClientTransport({
+        command: executable,
+        args,
+        env: process.env,
+    });
+    // Set up error handler
+    client.onerror = () => {
+        // Error handler - errors are logged but we'll catch them in try-catch
+    };
+    // Set up process error handler
+    childProc.on('error', (error) => {
+        throw new Error(`Failed to start process: ${error.message}`);
+    });
+    // Try to connect with timeout
+    const connectionPromise = client.connect(transport);
+    // Create a timeout promise
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+            childProc.kill();
+            reject(new Error(`Connection timeout after ${timeout}ms`));
+        }, timeout);
+    });
+    // Race between connection and timeout
+    try {
+        await Promise.race([connectionPromise, timeoutPromise]);
+    }
+    catch (error) {
+        // Clean up on error
+        childProc.kill();
+        throw error;
+    }
+    return { client, transport, process: childProc };
+}
+//# sourceMappingURL=stdio-transport.js.map

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

@@ -0,0 +1,85 @@
+/**
+ * Types for MCP connections.
+ * These types represent the structure of MCP connection results and connection information.
+ */
+import type { MCPURL, Command } from '../../types/ids.js';
+import type { TransportType } from '../../config/types.js';
+/**
+ * Result of connecting to an MCP server.
+ */
+export interface MCPConnectionResult {
+    /** Whether the connection was successful */
+    success: boolean;
+    /** Transport type used */
+    transport: TransportType;
+    /** Error message if connection failed */
+    error?: string;
+    /** Connection details */
+    details?: MCPConnectionDetails;
+}
+/**
+ * Request/response information for debugging.
+ */
+export interface MCPRequestInfo {
+    /** HTTP method used */
+    method?: string;
+    /** URL endpoint */
+    url?: string;
+    /** Headers sent */
+    headers?: Record<string, string>;
+    /** Request body/payload */
+    body?: unknown;
+}
+export interface MCPResponseInfo {
+    /** HTTP status code */
+    statusCode?: number;
+    /** Response headers */
+    headers?: Record<string, string>;
+    /** Response body */
+    body?: unknown;
+}
+/**
+ * Detailed information about an MCP connection.
+ */
+export interface MCPConnectionDetails {
+    /** The MCP URL (for HTTP transport) */
+    mcpUrl?: string;
+    /** The command (for stdio transport) */
+    command?: string;
+    /** Discovery URL (if applicable) */
+    discoveryUrl?: string;
+    /** Protocol version (if available) */
+    protocolVersion?: string;
+    /** Server capabilities (if available) - keys are capability names */
+    capabilities?: Record<string, unknown>;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+    /** Client instance (for reuse in other commands) */
+    client?: unknown;
+    /** Transport instance (for reuse in other commands) */
+    transport?: unknown;
+    /** Initialize request information */
+    initializeRequest?: MCPRequestInfo;
+    /** Initialize response information */
+    initializeResponse?: MCPResponseInfo;
+    /** Session ID if available */
+    sessionId?: string;
+}
+/**
+ * Options for connecting to an MCP server.
+ */
+export interface MCPConnectionOptions {
+    /** Transport type to use */
+    transport: TransportType;
+    /** MCP URL (for http transport) */
+    url?: MCPURL | string;
+    /** Command to execute (for stdio transport) */
+    command?: Command | string;
+    /** Timeout in milliseconds */
+    timeout?: number;
+    /** Environment variables (for stdio transport) */
+    env?: Record<string, string>;
+    /** Authentication headers (for http transport) */
+    headers?: Record<string, string>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/runtime/mcp/types.js

@@ -0,0 +1,6 @@
+/**
+ * Types for MCP connections.
+ * These types represent the structure of MCP connection results and connection information.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/runtime/sandbox/executor.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Sandbox executor for isolated tool execution.
+ * Provides isolated execution environment with process reuse for performance.
+ * This module is reusable for any sandboxed execution needs, not just testing.
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import type { Command } from '../../types/ids.js';
+import type { ToolExecutionResult } from './types.js';
+export * from './types.js';
+/**
+ * Options for sandbox execution.
+ */
+export interface SandboxOptions {
+    /** Timeout for tool execution in milliseconds */
+    timeout: number;
+    /** Memory limit in MB (enforced via command wrapping).
+     *
+     * Memory limits are enforced by wrapping the command:
+     * - POSIX systems: Wraps command with `ulimit -v <memoryMB>M &&`
+     * - Node.js commands: Injects `--max-old-space-size=<memoryMB>` into node args
+     * - Other commands: Uses ulimit wrapper on POSIX systems
+     */
+    memoryLimitMB?: number;
+    /** MCP server command to execute */
+    mcpCommand: Command | string;
+    /** Environment variables for the process */
+    env?: Record<string, string>;
+    /** Project root directory (for detecting side effects) */
+    projectRoot: string;
+    /** Suppress stderr output (redirect to /dev/null) */
+    suppressStderr?: boolean;
+}
+/**
+ * Sandbox executor with process reuse.
+ * Starts MCP server once, executes multiple tools, then closes.
+ */
+export declare class SandboxExecutor {
+    private client;
+    private transport;
+    private tempDir;
+    private initialized;
+    private readonly options;
+    constructor(options: SandboxOptions);
+    /**
+     * Initialize the sandbox (start MCP server process).
+     * This should be called once before testing multiple tools.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Parse MCP protocol response and extract output or error.
+     * Handles various response formats from MCP SDK.
+     * @param rawResult - Raw result from MCP SDK
+     * @param timedOut - Whether execution timed out
+     * @returns Object with output and error (mutually exclusive)
+     */
+    private parseMcpResponse;
+    /**
+     * Check if text content looks like an error message.
+     * This handles cases where MCP servers return errors as text instead of proper error responses.
+     */
+    private isErrorText;
+    /**
+     * Classify error type from error message and MCP protocol response.
+     */
+    private classifyError;
+    /**
+     * Execute a tool with the given inputs.
+     * @param toolName - Name of the tool to execute
+     * @param inputs - Array of input objects to test
+     * @param timeoutMs - Optional per-tool timeout in milliseconds (overrides default)
+     * @returns Array of execution results (one per input)
+     */
+    executeTool(toolName: string, inputs: Array<Record<string, unknown>>, timeoutMs?: number): Promise<ToolExecutionResult[]>;
+    /**
+     * Format timeout in milliseconds to human-readable string.
+     */
+    private formatTimeout;
+    /**
+     * Get the MCP client instance (for reuse by orchestrator).
+     * @returns The MCP client, or null if not initialized
+     */
+    getClient(): Client | null;
+    /**
+     * Get current process memory usage (if available).
+     * @returns Memory usage in MB, or undefined if not available
+     */
+    private getProcessMemoryUsage;
+    /**
+     * Cleanup sandbox resources.
+     * Should be called after all tools are tested.
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Check if sandbox is initialized.
+     */
+    isInitialized(): boolean;
+    /**
+     * Get the temp directory path.
+     */
+    getTempDir(): string | null;
+}
+//# sourceMappingURL=executor.d.ts.map