npm - opik-mcp - Versions diffs - 0.0.1 - Mend

opik-mcp 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/LICENSE +203 -0
package/README.md +203 -0
package/build/cli.js +72 -0
package/build/client/index.html +323 -0
package/build/config.js +205 -0
package/build/debug-log.js +64 -0
package/build/index.js +1847 -0
package/build/mcp-server.js +96 -0
package/build/test-client.js +436 -0
package/build/transports/sse-transport.js +169 -0
package/build/transports/types.js +4 -0
package/build/types.js +4 -0
package/build/utils/capabilities.js +303 -0
package/build/utils/env.js +52 -0
package/build/utils/examples.js +414 -0
package/build/utils/metrics-info.js +263 -0
package/build/utils/tracing-info.js +119 -0
package/package.json +79 -0

package/build/client/index.html ADDED Viewed

@@ -0,0 +1,323 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>MCP SSE Client</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
+      line-height: 1.6;
+      margin: 0;
+      padding: 20px;
+      color: #333;
+      max-width: 1200px;
+      margin: 0 auto;
+    }
+    h1, h2, h3 {
+      color: #0066cc;
+    }
+    #messages {
+      height: 300px;
+      overflow-y: auto;
+      border: 1px solid #ddd;
+      padding: 10px;
+      margin-bottom: 20px;
+      background-color: #f9f9f9;
+      border-radius: 4px;
+      font-family: monospace;
+    }
+    #message-form {
+      margin-bottom: 20px;
+    }
+    textarea {
+      width: 100%;
+      padding: 10px;
+      border: 1px solid #ddd;
+      border-radius: 4px;
+      min-height: 100px;
+      font-family: monospace;
+      margin-bottom: 10px;
+    }
+    button {
+      background-color: #0066cc;
+      color: white;
+      border: none;
+      padding: 10px 20px;
+      border-radius: 4px;
+      cursor: pointer;
+      font-size: 16px;
+    }
+    button:hover {
+      background-color: #0055aa;
+    }
+    .message {
+      margin-bottom: 8px;
+      border-bottom: 1px solid #eee;
+      padding-bottom: 8px;
+    }
+    .message-time {
+      color: #666;
+      font-size: 12px;
+    }
+    .message-direction {
+      display: inline-block;
+      padding: 2px 6px;
+      border-radius: 3px;
+      font-size: 12px;
+      margin-right: 8px;
+    }
+    .direction-incoming {
+      background-color: #e7f3ff;
+      color: #0066cc;
+    }
+    .direction-outgoing {
+      background-color: #e7ffe7;
+      color: #007700;
+    }
+    .message-content {
+      white-space: pre-wrap;
+      background-color: #fff;
+      padding: 8px;
+      border-radius: 4px;
+      overflow-x: auto;
+    }
+    .connection-info {
+      margin-bottom: 20px;
+      padding: 10px;
+      background-color: #f0f0f0;
+      border-radius: 4px;
+    }
+    .status {
+      display: inline-block;
+      width: 12px;
+      height: 12px;
+      border-radius: 50%;
+      margin-right: 8px;
+    }
+    .status-connected {
+      background-color: #00cc00;
+    }
+    .status-disconnected {
+      background-color: #cc0000;
+    }
+  </style>
+</head>
+<body>
+  <h1>MCP SSE Client</h1>
+  <div class="connection-info">
+    <div id="connection-status">
+      <span class="status status-disconnected"></span> Disconnected
+    </div>
+    <div>
+      <label for="server-url">Server URL:</label>
+      <input type="text" id="server-url" value="http://localhost:3001" style="width: 250px;">
+      <button id="connect-btn">Connect</button>
+      <button id="disconnect-btn" disabled>Disconnect</button>
+    </div>
+  </div>
+  <h2>Send Message</h2>
+  <div id="message-form">
+    <textarea id="message-input" placeholder="Enter your JSON message here...">
+{
+  "jsonrpc": "2.0",
+  "method": "mcp__get_server_info",
+  "id": "1",
+  "params": {}
+}
+</textarea>
+    <button id="send-btn" disabled>Send Message</button>
+  </div>
+  <h2>Messages</h2>
+  <div id="messages"></div>
+  <script>
+    let eventSource = null;
+    const messagesContainer = document.getElementById('messages');
+    const messageInput = document.getElementById('message-input');
+    const sendBtn = document.getElementById('send-btn');
+    const connectBtn = document.getElementById('connect-btn');
+    const disconnectBtn = document.getElementById('disconnect-btn');
+    const serverUrlInput = document.getElementById('server-url');
+    const connectionStatus = document.getElementById('connection-status');
+    // Function to connect to the SSE server
+    function connect() {
+      const serverUrl = serverUrlInput.value.trim();
+      if (!serverUrl) {
+        alert('Please enter a valid server URL');
+        return;
+      }
+      try {
+        // Generate a unique client ID
+        const clientId = 'client_' + Date.now();
+        // Create a new EventSource
+        eventSource = new EventSource(`${serverUrl}/events?clientId=${clientId}`);
+        // Listen for messages
+        eventSource.onmessage = (event) => {
+          const data = event.data;
+          addMessage('incoming', data);
+        };
+        // Handle connection open
+        eventSource.onopen = () => {
+          connectionStatus.innerHTML = '<span class="status status-connected"></span> Connected';
+          connectBtn.disabled = true;
+          disconnectBtn.disabled = false;
+          sendBtn.disabled = false;
+          addMessage('system', 'Connected to server');
+        };
+        // Handle errors
+        eventSource.onerror = (error) => {
+          console.error('EventSource error:', error);
+          addMessage('system', 'Connection error. Reconnecting...');
+          connectionStatus.innerHTML = '<span class="status status-disconnected"></span> Error connecting';
+        };
+      } catch (error) {
+        console.error('Error connecting to server:', error);
+        addMessage('system', `Error connecting: ${error.message}`);
+      }
+    }
+    // Function to disconnect from the SSE server
+    function disconnect() {
+      if (eventSource) {
+        eventSource.close();
+        eventSource = null;
+        connectionStatus.innerHTML = '<span class="status status-disconnected"></span> Disconnected';
+        connectBtn.disabled = false;
+        disconnectBtn.disabled = true;
+        sendBtn.disabled = true;
+        addMessage('system', 'Disconnected from server');
+      }
+    }
+    // Function to send a message to the server
+    async function sendMessage() {
+      const message = messageInput.value.trim();
+      if (!message) {
+        alert('Please enter a message to send');
+        return;
+      }
+      try {
+        // Parse message to validate JSON
+        const jsonMessage = JSON.parse(message);
+        // Send the message to the server
+        const serverUrl = serverUrlInput.value.trim();
+        const response = await fetch(`${serverUrl}/send`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: message,
+        });
+        const responseData = await response.json();
+        if (response.ok) {
+          addMessage('outgoing', message);
+        } else {
+          addMessage('system', `Error sending message: ${responseData.message || 'Unknown error'}`);
+        }
+      } catch (error) {
+        console.error('Error sending message:', error);
+        addMessage('system', `Error sending message: ${error.message}`);
+      }
+    }
+    // Function to add a message to the messages container
+    function addMessage(direction, content) {
+      const messageDiv = document.createElement('div');
+      messageDiv.className = 'message';
+      const now = new Date();
+      const time = now.toLocaleTimeString();
+      let directionLabel = '';
+      let directionClass = '';
+      switch (direction) {
+        case 'incoming':
+          directionLabel = 'Received';
+          directionClass = 'direction-incoming';
+          break;
+        case 'outgoing':
+          directionLabel = 'Sent';
+          directionClass = 'direction-outgoing';
+          break;
+        case 'system':
+          directionLabel = 'System';
+          directionClass = '';
+          break;
+      }
+      let contentDisplay = content;
+      // Try to pretty-print JSON if it's not a system message
+      if (direction !== 'system') {
+        try {
+          contentDisplay = JSON.stringify(JSON.parse(content), null, 2);
+        } catch (e) {
+          // Not valid JSON, just use as-is
+        }
+      }
+      messageDiv.innerHTML = `
+        <div>
+          <span class="message-time">${time}</span>
+          <span class="message-direction ${directionClass}">${directionLabel}</span>
+        </div>
+        <div class="message-content">${direction === 'system' ? content : contentDisplay}</div>
+      `;
+      messagesContainer.appendChild(messageDiv);
+      // Auto-scroll to bottom
+      messagesContainer.scrollTop = messagesContainer.scrollHeight;
+    }
+    // Set up event listeners
+    connectBtn.addEventListener('click', connect);
+    disconnectBtn.addEventListener('click', disconnect);
+    sendBtn.addEventListener('click', sendMessage);
+    // Allow pressing Enter in the input to send a message
+    messageInput.addEventListener('keydown', (event) => {
+      if (event.key === 'Enter' && event.ctrlKey) {
+        sendMessage();
+        event.preventDefault();
+      }
+    });
+    // Add a welcome message
+    addMessage('system', 'Welcome to the MCP SSE Client. Click Connect to start.');
+  </script>
+</body>
+</html>

package/build/config.js ADDED Viewed

@@ -0,0 +1,205 @@
+/**
+ * Configuration loader for Opik MCP server
+ * Loads and validates environment variables from .env file
+ * and/or command-line arguments
+ */
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import * as fs from 'node:fs';
+/**
+ * File-based logger
+ * Only writes if debug mode is enabled or being set to enabled
+ */
+function writeToLogFile(message, forceWrite = false) {
+    try {
+        // Check if debug mode is enabled or being set to enabled
+        // This check is special because we're in the process of parsing args
+        const debugArg = process.argv.includes('--debug') &&
+            process.argv[process.argv.indexOf('--debug') + 1] === 'true';
+        const debugEnv = process.env.DEBUG_MODE === 'true';
+        if (debugArg || debugEnv || forceWrite) {
+            const logFile = '/tmp/opik-mcp.log';
+            if (!fs.existsSync(logFile)) {
+                fs.writeFileSync(logFile, `Opik MCP Server Started: ${new Date().toISOString()}\n`);
+            }
+            fs.appendFileSync(logFile, `[${new Date().toISOString()}] [config] ${message}\n`);
+        }
+    }
+    catch (error) {
+        // Silently fail if we can't write to the log file
+    }
+}
+/**
+ * Parse command-line arguments
+ */
+function parseCommandLineArgs() {
+    return yargs(hideBin(process.argv))
+        // API Configuration
+        .option('apiUrl', {
+        alias: 'url',
+        type: 'string',
+        description: 'API base URL',
+    })
+        .option('apiKey', {
+        alias: 'key',
+        type: 'string',
+        description: 'API key for authentication',
+    })
+        .option('workspace', {
+        alias: 'ws',
+        type: 'string',
+        description: 'Workspace name',
+    })
+        .option('selfHosted', {
+        type: 'boolean',
+        description: 'Whether the instance is self-hosted',
+    })
+        .option('debug', {
+        type: 'boolean',
+        description: 'Enable debug mode',
+    })
+        // Transport Configuration
+        .option('transport', {
+        type: 'string',
+        description: 'Transport type (stdio or sse)',
+        choices: ['stdio', 'sse'],
+        default: 'stdio',
+    })
+        .option('ssePort', {
+        type: 'number',
+        description: 'Port for SSE transport',
+        default: 3001,
+    })
+        .option('sseHost', {
+        type: 'string',
+        description: 'Host for SSE transport',
+        default: 'localhost',
+    })
+        .option('sseLogPath', {
+        type: 'string',
+        description: 'Log file path for SSE transport',
+        default: '/tmp/opik-mcp-sse.log',
+    })
+        // MCP Configuration
+        .option('mcpName', {
+        type: 'string',
+        description: 'MCP server name',
+    })
+        .option('mcpVersion', {
+        type: 'string',
+        description: 'MCP server version',
+    })
+        .option('mcpPort', {
+        type: 'number',
+        description: 'MCP server port',
+    })
+        .option('mcpLogging', {
+        type: 'boolean',
+        description: 'Enable MCP server logging',
+    })
+        .option('mcpDefaultWorkspace', {
+        type: 'string',
+        description: 'Default workspace name',
+    })
+        // Tool enablement
+        .option('disablePromptTools', {
+        type: 'boolean',
+        description: 'Disable prompt-related tools',
+    })
+        .option('disableProjectTools', {
+        type: 'boolean',
+        description: 'Disable project-related tools',
+    })
+        .option('disableTraceTools', {
+        type: 'boolean',
+        description: 'Disable trace-related tools',
+    })
+        .option('disableMetricTools', {
+        type: 'boolean',
+        description: 'Disable metric-related tools',
+    })
+        .help()
+        .parse();
+}
+/**
+ * Load environment variables with fallbacks
+ */
+function loadConfig() {
+    // Parse command-line arguments first
+    const args = parseCommandLineArgs();
+    // Try to load from process.env and command-line args, with command-line taking precedence
+    const config = {
+        // API configuration with fallbacks - with much more forgiving defaults
+        apiBaseUrl: args.apiUrl || process.env.OPIK_API_BASE_URL || 'https://www.comet.com/opik/api',
+        workspaceName: (args.workspace || process.env.OPIK_WORKSPACE_NAME || 'default').replace(/^['"](.*)['"]$/, '$1'), // Remove any quotes
+        apiKey: args.apiKey || process.env.OPIK_API_KEY || '',
+        isSelfHosted: args.selfHosted !== undefined
+            ? args.selfHosted
+            : process.env.OPIK_SELF_HOSTED === 'true' || false,
+        debugMode: args.debug !== undefined ? args.debug : process.env.DEBUG_MODE === 'true' || false,
+        // Transport configuration
+        transport: (args.transport || process.env.TRANSPORT || 'stdio'),
+        ssePort: args.ssePort || (process.env.SSE_PORT ? parseInt(process.env.SSE_PORT, 10) : 3001),
+        sseHost: args.sseHost || process.env.SSE_HOST || 'localhost',
+        sseLogPath: args.sseLogPath || process.env.SSE_LOG_PATH || '/tmp/opik-mcp-sse.log',
+        // MCP configuration with fallbacks
+        mcpName: args.mcpName || process.env.MCP_NAME || 'opik-manager',
+        mcpVersion: args.mcpVersion || process.env.MCP_VERSION || '1.0.0',
+        mcpPort: args.mcpPort || (process.env.MCP_PORT ? parseInt(process.env.MCP_PORT, 10) : undefined),
+        mcpLogging: args.mcpLogging !== undefined ? args.mcpLogging : process.env.MCP_LOGGING === 'true' || false,
+        mcpDefaultWorkspace: args.mcpDefaultWorkspace || process.env.MCP_DEFAULT_WORKSPACE || 'default',
+        // Tool enablement with fallbacks - note the logic reversal for the command-line args
+        mcpEnablePromptTools: args.disablePromptTools
+            ? false
+            : process.env.MCP_ENABLE_PROMPT_TOOLS !== 'false', // Enable by default
+        mcpEnableProjectTools: args.disableProjectTools
+            ? false
+            : process.env.MCP_ENABLE_PROJECT_TOOLS !== 'false', // Enable by default
+        mcpEnableTraceTools: args.disableTraceTools
+            ? false
+            : process.env.MCP_ENABLE_TRACE_TOOLS !== 'false', // Enable by default
+        mcpEnableMetricTools: args.disableMetricTools
+            ? false
+            : process.env.MCP_ENABLE_METRIC_TOOLS !== 'false', // Enable by default
+    };
+    // Validate required fields but be much more forgiving
+    if (!config.apiKey) {
+        // Only warn about missing API key, don't throw an error
+        writeToLogFile(`Warning: No API key provided - some functionality will be limited`, true);
+        // Still allow the server to start even without an API key
+    }
+    // Log configuration if in debug mode
+    if (config.debugMode) {
+        writeToLogFile('Opik MCP Configuration:');
+        writeToLogFile(`- API Base URL: ${config.apiBaseUrl}`);
+        writeToLogFile(`- Self-hosted: ${config.isSelfHosted ? 'Yes' : 'No'}`);
+        if (!config.isSelfHosted) {
+            writeToLogFile(`- Workspace: ${config.workspaceName}`);
+        }
+        writeToLogFile(`- Debug mode: ${config.debugMode ? 'Enabled' : 'Disabled'}`);
+        // Log transport configuration
+        writeToLogFile('\nTransport Configuration:');
+        writeToLogFile(`- Transport: ${config.transport}`);
+        if (config.transport === 'sse') {
+            writeToLogFile(`- SSE Port: ${config.ssePort}`);
+            writeToLogFile(`- SSE Host: ${config.sseHost}`);
+            writeToLogFile(`- SSE Log Path: ${config.sseLogPath}`);
+        }
+        // Log MCP configuration
+        writeToLogFile('\nMCP Configuration:');
+        writeToLogFile(`- MCP Name: ${config.mcpName}`);
+        writeToLogFile(`- MCP Version: ${config.mcpVersion}`);
+        if (config.mcpPort)
+            writeToLogFile(`- MCP Port: ${config.mcpPort}`);
+        writeToLogFile(`- MCP Logging: ${config.mcpLogging ? 'Enabled' : 'Disabled'}`);
+        writeToLogFile(`- MCP Default Workspace: ${config.mcpDefaultWorkspace}`);
+        writeToLogFile(`- Prompt Tools: ${config.mcpEnablePromptTools ? 'Enabled' : 'Disabled'}`);
+        writeToLogFile(`- Project Tools: ${config.mcpEnableProjectTools ? 'Enabled' : 'Disabled'}`);
+        writeToLogFile(`- Trace Tools: ${config.mcpEnableTraceTools ? 'Enabled' : 'Disabled'}`);
+        writeToLogFile(`- Metric Tools: ${config.mcpEnableMetricTools ? 'Enabled' : 'Disabled'}`);
+    }
+    return config;
+}
+// Export the configuration
+const config = loadConfig();
+export default config;

package/build/debug-log.js ADDED Viewed

@@ -0,0 +1,64 @@
+/**
+ * Debug logging utility for MCP server
+ */
+// Write directly to a file for debugging
+import fs from 'fs';
+export function initDebugLog() {
+    const logPath = '/tmp/opik-mcp-debug.log';
+    // Clear previous log
+    try {
+        fs.writeFileSync(logPath, 'MCP DEBUG LOG STARTED\n');
+    }
+    catch (error) {
+        // If we can't write to the file, use console.error
+        console.error('Failed to write to debug log file:', error);
+    }
+    // Log startup information
+    logDebug('MCP Server starting initialization');
+    logDebug(`Process ID: ${process.pid}`);
+    logDebug(`Node Version: ${process.version}`);
+    logDebug(`Working Directory: ${process.cwd()}`);
+    // Log environment variables
+    logDebug('Environment Variables:');
+    Object.keys(process.env)
+        .filter(key => key.startsWith('OPIK_'))
+        .forEach(key => {
+        let value = process.env[key];
+        // Mask sensitive information
+        if (key === 'OPIK_API_KEY')
+            value = '***MASKED***';
+        logDebug(`  ${key}: ${value}`);
+    });
+    // Log command line arguments
+    logDebug('Command Line Arguments:');
+    process.argv.forEach((arg, index) => {
+        logDebug(`  ${index}: ${arg}`);
+    });
+    // Set up uncaught exception handler
+    process.on('uncaughtException', error => {
+        logDebug(`UNCAUGHT EXCEPTION: ${error.message}`);
+        logDebug(error.stack || 'No stack trace available');
+    });
+    // Set up unhandled rejection handler
+    process.on('unhandledRejection', (reason, _promise) => {
+        logDebug(`UNHANDLED REJECTION: ${reason}`);
+    });
+    // Set up exit handler
+    process.on('exit', code => {
+        logDebug(`Process exiting with code: ${code}`);
+    });
+}
+export function logDebug(message) {
+    const logPath = '/tmp/opik-mcp-debug.log';
+    const timestamp = new Date().toISOString();
+    const logMessage = `[${timestamp}] ${message}\n`;
+    return new Promise(resolve => {
+        try {
+            fs.appendFileSync(logPath, logMessage);
+        }
+        catch (error) {
+            console.error('Failed to append to debug log file:', error);
+        }
+        resolve();
+    });
+}