nitrostack 1.0.14 → 1.0.16

package/src/studio/lib/log-manager.ts

@@ -0,0 +1,76 @@
+// Log Manager for MCP Server
+// Captures stdout/stderr from MCP server process and streams to clients
+
+export interface LogEntry {
+  timestamp: number;
+  level: 'info' | 'error' | 'warn' | 'debug';
+  message: string;
+  source: 'stdout' | 'stderr' | 'system';
+}
+
+class LogManager {
+  private logs: LogEntry[] = [];
+  private maxLogs = 1000; // Keep last 1000 logs in memory
+  private listeners: Set<(log: LogEntry) => void> = new Set();
+
+  addLog(message: string, level: LogEntry['level'] = 'info', source: LogEntry['source'] = 'system') {
+    const entry: LogEntry = {
+      timestamp: Date.now(),
+      level,
+      message: message.trim(),
+      source,
+    };
+
+    this.logs.push(entry);
+
+    // Keep only last maxLogs entries
+    if (this.logs.length > this.maxLogs) {
+      this.logs = this.logs.slice(-this.maxLogs);
+    }
+
+    // Notify all listeners
+    this.listeners.forEach(listener => {
+      try {
+        listener(entry);
+      } catch (error) {
+        console.error('Error in log listener:', error);
+      }
+    });
+  }
+
+  getLogs(limit?: number): LogEntry[] {
+    if (limit) {
+      return this.logs.slice(-limit);
+    }
+    return [...this.logs];
+  }
+
+  clearLogs() {
+    this.logs = [];
+    this.addLog('Logs cleared', 'info', 'system');
+  }
+
+  subscribe(listener: (log: LogEntry) => void): () => void {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  getLogCount(): number {
+    return this.logs.length;
+  }
+}
+
+// Global singleton
+declare global {
+  var __logManager: LogManager | undefined;
+}
+
+export function getLogManager(): LogManager {
+  if (!global.__logManager) {
+    global.__logManager = new LogManager();
+  }
+  return global.__logManager;
+}
+

package/src/studio/lib/mcp-client.ts

@@ -1,20 +1,36 @@
 // MCP Client for Studio
-// Communicates with MCP server via stdio
+// Communicates with MCP server via stdio or HTTP
 
 import { spawn, ChildProcess } from 'child_process';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { HttpClientTransport } from '@/lib/http-client-transport';
+import { getLogManager } from '@/lib/log-manager';
 
-export interface McpClientConfig {
+export type TransportType = 'stdio' | 'http';
+
+export interface StdioClientConfig {
+  type: 'stdio';
   command: string;
   args: string[];
   env?: Record<string, string>;
   cwd?: string;
 }
 
+export interface HttpClientConfig {
+  type: 'http';
+  baseUrl: string;
+  basePath?: string;
+  headers?: Record<string, string>;
+}
+
+export type McpClientConfig = StdioClientConfig | HttpClientConfig;
+
 export class McpClient {
   private client: Client | null = null;
-  private transport: StdioClientTransport | null = null;
+  private transport: StdioClientTransport | HttpClientTransport | null = null;
+  private transportType: TransportType | null = null;
+  private childProcess: ChildProcess | null = null;
 
   async connect(config: McpClientConfig): Promise<void> {
     if (this.client && this.transport) {
@@ -35,16 +51,73 @@ export class McpClient {
       this.transport = null;
     }
 
-    console.log('🚀 Connecting to MCP server:', config.command, config.args);
-    console.log('📝 Environment vars:', Object.keys(config.env || {}).join(', '));
+    this.transportType = config.type;
+
+    // Create appropriate transport based on type
+    if (config.type === 'stdio') {
+      console.log('🚀 Connecting to MCP server via STDIO:', config.command, config.args);
+      console.log('📝 Environment vars:', Object.keys(config.env || {}).join(', '));
+      
+      const logManager = getLogManager();
+      logManager.addLog(`Starting MCP server: ${config.command} ${config.args.join(' ')}`, 'info', 'system');
+
+      // Create STDIO transport (it will spawn the process internally)
+      this.transport = new StdioClientTransport({
+        command: config.command,
+        args: config.args,
+        env: { ...process.env, ...config.env },
+        cwd: config.cwd,
+      });
+
+      // Access the child process from the transport to capture logs
+      // The transport stores the process in a private property, so we need to access it
+      setTimeout(() => {
+        const transport = this.transport as any;
+        if (transport._process || transport.process) {
+          this.childProcess = transport._process || transport.process;
+          
+          // Capture stdout
+          this.childProcess?.stdout?.on('data', (data: Buffer) => {
+            const message = data.toString();
+            logManager.addLog(message, 'info', 'stdout');
+          });
+
+          // Capture stderr
+          this.childProcess?.stderr?.on('data', (data: Buffer) => {
+            const message = data.toString();
+            logManager.addLog(message, 'error', 'stderr');
+          });
+
+          // Handle process errors
+          this.childProcess?.on('error', (error: Error) => {
+            logManager.addLog(`Process error: ${error.message}`, 'error', 'system');
+          });
 
-    // Create transport (it will spawn the process internally)
-    this.transport = new StdioClientTransport({
-      command: config.command,
-      args: config.args,
-      env: { ...process.env, ...config.env },
-      cwd: config.cwd, // Set working directory for the child process
-    });
+          // Handle process exit
+          this.childProcess?.on('exit', (code: number | null, signal: string | null) => {
+            if (code !== null) {
+              logManager.addLog(`MCP server exited with code ${code}`, code === 0 ? 'info' : 'error', 'system');
+            } else if (signal) {
+              logManager.addLog(`MCP server killed with signal ${signal}`, 'warn', 'system');
+            }
+          });
+        }
+      }, 100); // Small delay to ensure transport has spawned the process
+    } else if (config.type === 'http') {
+      console.log('🌐 Connecting to MCP server via HTTP:', config.baseUrl);
+
+      // Create HTTP transport
+      this.transport = new HttpClientTransport({
+        baseUrl: config.baseUrl,
+        basePath: config.basePath,
+        headers: config.headers,
+      });
+
+      // Start the HTTP transport (establish SSE connection)
+      await this.transport.start();
+    } else {
+      throw new Error(`Unknown transport type: ${(config as any).type}`);
+    }
 
     // Create client
     this.client = new Client(
@@ -65,22 +138,25 @@ export class McpClient {
       console.error('❌ MCP Client error:', error);
       this.client = null;
       this.transport = null;
+      this.transportType = null;
     };
 
     this.client.onclose = () => {
       console.log('🔌 MCP Client connection closed');
       this.client = null;
       this.transport = null;
+      this.transportType = null;
     };
 
     // Connect
     try {
       await this.client.connect(this.transport);
-      console.log('✅ MCP Client connected and ready');
+      console.log(`✅ MCP Client connected and ready (${config.type.toUpperCase()} transport)`);
     } catch (error) {
       console.error('❌ Failed to connect MCP client:', error);
       this.client = null;
       this.transport = null;
+      this.transportType = null;
       throw error;
     }
   }
@@ -88,6 +164,8 @@ export class McpClient {
   async disconnect(): Promise<void> {
     console.log('🛑 Disconnecting MCP client...');
     
+    const logManager = getLogManager();
+    
     if (this.client) {
       await this.client.close();
       this.client = null;
@@ -97,12 +175,24 @@ export class McpClient {
       await this.transport.close();
       this.transport = null;
     }
+
+    if (this.childProcess) {
+      logManager.addLog('Stopping MCP server process', 'info', 'system');
+      this.childProcess.kill('SIGTERM');
+      this.childProcess = null;
+    }
+
+    this.transportType = null;
   }
 
   isConnected(): boolean {
     return this.client !== null;
   }
 
+  getTransportType(): TransportType | null {
+    return this.transportType;
+  }
+
   async listTools() {
     if (!this.client) throw new Error('Not connected');
     return await this.client.listTools();