@myrialabs/clopen 0.0.1

package/backend/lib/mcp/config.ts

@@ -0,0 +1,316 @@
+/**
+ * MCP Custom Tools Configuration & Registry
+ *
+ * This file combines server registry and configuration in one place
+ * to avoid duplication and make it easier to add new servers.
+ */
+
+import type { McpSdkServerConfigWithInstance, McpServerConfig } from "@anthropic-ai/claude-agent-sdk";
+import type { McpLocalConfig } from '@opencode-ai/sdk';
+import type { ServerConfig, ParsedMcpToolName, ServerName } from './types';
+import { serverRegistry } from './servers';
+import { debug } from '$shared/utils/logger';
+import { resolve } from 'path';
+
+/**
+ * User-defined MCP Servers Configuration
+ *
+ * Define your server configuration here. Only specify `enabled` and `tools`.
+ * Server instances are automatically merged from the registry.
+ *
+ * Type-safe: Server names and tool names are validated at compile time!
+ */
+const mcpServersConfig: Record<ServerName, ServerConfig> = {
+	"weather-service": {
+		enabled: true,
+		tools: [
+			"get_temperature",
+		]
+	},
+	"browser-automation": {
+		enabled: true,
+		tools: [
+			// Tab Management
+			"list_tabs",
+			"switch_tab",
+			"open_new_tab",
+			"close_tab",
+
+			// Navigation
+			"navigate",
+
+			// Browser Actions
+			"actions",
+
+			// Page Inspection
+			"analyze_dom",
+			"take_screenshot",
+			"get_console_logs",
+			"clear_console_logs",
+			"execute_console",
+		]
+	}
+};
+
+/**
+ * Helper to merge user config with server instances from registry
+ */
+function createServerConfig<T extends Record<ServerName, ServerConfig>>(
+	config: T
+): { [K in keyof T]: T[K] & { instance: McpSdkServerConfigWithInstance } } {
+	const result = {} as any;
+
+	for (const [serverName, serverConfig] of Object.entries(config)) {
+		result[serverName] = {
+			...serverConfig,
+			instance: serverRegistry[serverName as ServerName]
+		};
+	}
+
+	return result;
+}
+
+/**
+ * MCP Servers Configuration with instances
+ *
+ * This is the final configuration used throughout the application.
+ * Automatically merges user config with server instances.
+ */
+export const mcpServers: Record<string, ServerConfig & { instance: McpSdkServerConfigWithInstance }> = createServerConfig(mcpServersConfig);
+
+// ============================================================================
+// Server Registry Functions
+// ============================================================================
+
+/**
+ * Get all enabled MCP servers for Claude SDK
+ */
+export function getEnabledMcpServers(): Record<string, McpServerConfig> {
+	const enabledServers: Record<string, McpServerConfig> = {};
+
+	Object.entries(mcpServers).forEach(([serverName, serverConfig]) => {
+		if (serverConfig.enabled) {
+			enabledServers[serverName] = serverConfig.instance;
+			debug.log('mcp', `✓ Enabled MCP server: ${serverName}`);
+		} else {
+			debug.log('mcp', `✗ Disabled MCP server: ${serverName}`);
+		}
+	});
+
+	debug.log('mcp', `Total enabled MCP servers: ${Object.keys(enabledServers).length}`);
+
+	return enabledServers;
+}
+
+/**
+ * Get list of all allowed MCP tool names
+ *
+ * Tool names follow the format: mcp__{server-name}__{tool-name}
+ * Example: "mcp__weather-service__get_temperature"
+ */
+export function getAllowedMcpTools(): string[] {
+	const tools: string[] = [];
+
+	Object.entries(mcpServers).forEach(([serverName, serverConfig]) => {
+		if (!serverConfig.enabled) return;
+
+		serverConfig.tools.forEach((toolName) => {
+			const formattedName = `mcp__${serverName}__${toolName}`;
+			tools.push(formattedName);
+			debug.log('mcp', `✓ Allowed MCP tool: ${formattedName}`);
+		});
+	});
+
+	debug.log('mcp', `Total allowed MCP tools: ${tools.length}`);
+
+	return tools;
+}
+
+// ============================================================================
+// Configuration Helper Functions
+// ============================================================================
+
+/**
+ * Get server configuration by name
+ */
+export function getServerConfig(serverName: string) {
+	return mcpServers[serverName];
+}
+
+/**
+ * Check if a tool exists in server configuration
+ */
+export function getToolConfig(serverName: string, toolName: string): boolean {
+	const server = getServerConfig(serverName);
+	return server?.tools.includes(toolName as any) ?? false;
+}
+
+/**
+ * Check if a server is enabled
+ */
+export function isServerEnabled(serverName: string): boolean {
+	return mcpServers[serverName]?.enabled ?? false;
+}
+
+/**
+ * Check if a tool is enabled
+ */
+export function isToolEnabled(serverName: string, toolName: string): boolean {
+	const server = mcpServers[serverName];
+	if (!server?.enabled) return false;
+
+	return server.tools.includes(toolName as any);
+}
+
+// ============================================================================
+// Utility Functions
+// ============================================================================
+
+/**
+ * Parse MCP tool name into components
+ *
+ * Format: mcp__{server-name}__{tool-name}
+ * Example: "mcp__weather-service__get_temperature"
+ */
+export function parseMcpToolName(fullName: string): ParsedMcpToolName | null {
+	if (!fullName.startsWith('mcp__')) {
+		return null;
+	}
+
+	const withoutPrefix = fullName.replace('mcp__', '');
+	const parts = withoutPrefix.split('__');
+
+	if (parts.length !== 2) {
+		debug.warn('mcp', `Invalid MCP tool name format: ${fullName}`);
+		return null;
+	}
+
+	const [server, tool] = parts;
+
+	return {
+		server,
+		tool,
+		fullName
+	};
+}
+
+/**
+ * Check if a tool name is a custom MCP tool
+ */
+export function isMcpTool(toolName: string): boolean {
+	return toolName.startsWith('mcp__');
+}
+
+/**
+ * Get all enabled server names
+ */
+export function getEnabledServerNames(): string[] {
+	return Object.entries(mcpServers)
+		.filter(([_, config]) => config.enabled)
+		.map(([name, _]) => name);
+}
+
+/**
+ * Get all enabled tool names for a specific server
+ */
+export function getEnabledToolsForServer(serverName: string): string[] {
+	const serverConfig = mcpServers[serverName];
+	if (!serverConfig?.enabled) {
+		return [];
+	}
+
+	return serverConfig.tools.map((toolName) => `mcp__${serverName}__${toolName}`);
+}
+
+/**
+ * Get statistics about MCP servers and tools
+ */
+export function getMcpStats() {
+	const enabledServers = getEnabledServerNames();
+	const allTools = getAllowedMcpTools();
+
+	return {
+		totalServers: Object.keys(mcpServers).length,
+		enabledServers: enabledServers.length,
+		totalTools: allTools.length,
+		serverNames: enabledServers,
+		toolNames: allTools
+	};
+}
+
+// ============================================================================
+// Open Code Tool Name Resolution (single source of truth)
+// ============================================================================
+
+/**
+ * Resolve an Open Code tool name to our mcp__server__tool format.
+ *
+ * Open Code prefixes tool names with the MCP server name:
+ * e.g. "clopen-mcp_open_new_tab" → "mcp__browser-automation__open_new_tab"
+ *
+ * This function strips the prefix and maps back using the mcpServers
+ * registry — the SAME source that defines which tools exist.
+ *
+ * Returns null if the tool name is not one of our custom MCP tools.
+ */
+export function resolveOpenCodeToolName(toolName: string): string | null {
+	// Already in our format
+	if (toolName.startsWith('mcp__')) return toolName;
+
+	// Strip Open Code MCP server prefix if present
+	// Open Code prefixes with the stdio server name: "clopen-mcp_<tool>"
+	let rawName = toolName;
+	const ocPrefix = 'clopen-mcp_';
+	if (rawName.startsWith(ocPrefix)) {
+		rawName = rawName.slice(ocPrefix.length);
+	}
+
+	// Look up which server owns this tool
+	for (const [serverName, serverConfig] of Object.entries(mcpServers)) {
+		if (!serverConfig.enabled) continue;
+		if ((serverConfig.tools as readonly string[]).includes(rawName)) {
+			return `mcp__${serverName}__${rawName}`;
+		}
+	}
+
+	return null;
+}
+
+// ============================================================================
+// Open Code MCP Configuration
+// ============================================================================
+
+/**
+ * Get MCP configuration for Open Code engine.
+ *
+ * Open Code expects MCP servers as local (stdio subprocess) or remote (HTTP URL).
+ * We provide a single local MCP server that wraps all our custom tools.
+ * The server communicates with the main Clopen process via an HTTP bridge
+ * for tools that need in-process access (browser-automation).
+ */
+export function getOpenCodeMcpConfig(): Record<string, McpLocalConfig> {
+	// Check if any servers are enabled
+	const enabledServers = getEnabledServerNames();
+	if (enabledServers.length === 0) {
+		return {};
+	}
+
+	// Resolve path to the stdio server script
+	const stdioServerPath = resolve(import.meta.dir, 'stdio-server.ts');
+	const port = process.env.PORT || '9141';
+
+	debug.log('mcp', `📦 Open Code MCP: stdio server at ${stdioServerPath}`);
+	debug.log('mcp', `📦 Open Code MCP: bridge port ${port}`);
+
+	return {
+		'clopen-mcp': {
+			type: 'local',
+			command: ['bun', 'run', stdioServerPath],
+			environment: {
+				CLOPEN_PORT: port,
+			},
+			enabled: true,
+			timeout: 10000,
+		},
+	};
+}

package/backend/lib/mcp/index.ts

@@ -0,0 +1,35 @@
+/**
+ * MCP (Model Context Protocol) Custom Tools
+ *
+ * Main export point for the custom MCP tools system.
+ */
+
+// Type definitions
+export type {
+	ParsedMcpToolName,
+	McpServerStatus
+} from './types';
+
+// Main configuration and all utilities
+export {
+	mcpServers,
+	getEnabledMcpServers,
+	getAllowedMcpTools,
+	getServerConfig,
+	getToolConfig,
+	isServerEnabled,
+	isToolEnabled,
+	parseMcpToolName,
+	isMcpTool,
+	getEnabledServerNames,
+	getEnabledToolsForServer,
+	getMcpStats,
+	getOpenCodeMcpConfig,
+	resolveOpenCodeToolName
+} from './config';
+
+// Server implementations
+export * from './servers';
+
+// Project context service for MCP tool handlers
+export { projectContextService } from './project-context';

package/backend/lib/mcp/project-context.ts

@@ -0,0 +1,236 @@
+/**
+ * Project Context Service
+ *
+ * Stores mapping between chat sessions and projectId to provide
+ * project context to MCP tool handlers.
+ *
+ * This is needed because MCP tools are executed within a chat session context,
+ * but the Claude Agent SDK doesn't provide a way to pass custom context
+ * to tool handlers.
+ */
+
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { debug } from '$shared/utils/logger';
+
+// Execution context for MCP tool handlers
+interface ExecutionContext {
+	chatSessionId?: string;
+	projectId?: string;
+	streamId?: string;
+}
+
+// AsyncLocalStorage for execution context
+const executionContext = new AsyncLocalStorage<ExecutionContext>();
+
+class ProjectContextService {
+	// Map chat session ID to project ID
+	private sessionProjectMap = new Map<string, string>();
+
+	// Map stream ID to project ID (for additional tracking)
+	private streamProjectMap = new Map<string, string>();
+
+	// Track active streams (streamId -> context)
+	private activeStreams = new Map<string, { chatSessionId: string; projectId: string; startedAt: number }>();
+
+	// Track the most recently active stream (for MCP tool execution context)
+	private mostRecentActiveStream: { streamId: string; chatSessionId: string; projectId: string } | null = null;
+
+	// Track the most recently used projectId (as a last resort fallback)
+	private lastUsedProjectId: string | null = null;
+
+	/**
+	 * Register a chat session with its project ID
+	 * Should be called when a chat stream starts
+	 */
+	registerSession(chatSessionId: string, projectId: string): void {
+		if (!chatSessionId || !projectId) {
+			debug.warn('mcp', `⚠️ Cannot register session: chatSessionId='${chatSessionId}' projectId='${projectId}'`);
+			return;
+		}
+
+		this.sessionProjectMap.set(chatSessionId, projectId);
+		this.lastUsedProjectId = projectId;
+
+		debug.log('mcp', `📌 Registered session: ${chatSessionId} -> project: ${projectId}`);
+		debug.log('mcp', `📊 Total sessions registered: ${this.sessionProjectMap.size}`);
+	}
+
+	/**
+	 * Register a stream ID with its project ID
+	 * Should be called when a chat stream starts
+	 */
+	registerStream(streamId: string, projectId: string, chatSessionId?: string): void {
+		if (!streamId || !projectId) {
+			debug.warn('mcp', `⚠️ Cannot register stream: streamId='${streamId}' projectId='${projectId}'`);
+			return;
+		}
+
+		this.streamProjectMap.set(streamId, projectId);
+
+		// Track as active stream
+		if (chatSessionId) {
+			this.activeStreams.set(streamId, {
+				chatSessionId,
+				projectId,
+				startedAt: Date.now()
+			});
+
+			// Update most recent active stream
+			this.mostRecentActiveStream = { streamId, chatSessionId, projectId };
+
+			debug.log('mcp', `📌 Registered stream: ${streamId.slice(0, 8)} -> project: ${projectId} (session: ${chatSessionId.slice(0, 8)})`);
+			debug.log('mcp', `🎯 Most recent active stream set to: ${projectId}`);
+		} else {
+			debug.log('mcp', `📌 Registered stream: ${streamId.slice(0, 8)} -> project: ${projectId} (no session)`);
+		}
+
+		debug.log('mcp', `📊 Total active streams: ${this.activeStreams.size}`);
+	}
+
+	/**
+	 * Get project ID for a chat session
+	 */
+	getProjectIdForSession(chatSessionId: string): string | null {
+		return this.sessionProjectMap.get(chatSessionId) || null;
+	}
+
+	/**
+	 * Get project ID for a stream
+	 */
+	getProjectIdForStream(streamId: string): string | null {
+		return this.streamProjectMap.get(streamId) || null;
+	}
+
+	/**
+	 * Unregister a session (cleanup)
+	 */
+	unregisterSession(chatSessionId: string): void {
+		this.sessionProjectMap.delete(chatSessionId);
+		debug.log('mcp', `🗑️ Unregistered session ${chatSessionId}`);
+	}
+
+	/**
+	 * Unregister a stream (cleanup)
+	 */
+	unregisterStream(streamId: string): void {
+		this.streamProjectMap.delete(streamId);
+		this.activeStreams.delete(streamId);
+
+		// Clear most recent if it was this stream
+		if (this.mostRecentActiveStream?.streamId === streamId) {
+			// Find another active stream to use as most recent
+			const remaining = Array.from(this.activeStreams.entries());
+			if (remaining.length > 0) {
+				// Get the most recently started stream
+				const [latestStreamId, latestContext] = remaining.sort((a, b) => b[1].startedAt - a[1].startedAt)[0];
+				this.mostRecentActiveStream = {
+					streamId: latestStreamId,
+					chatSessionId: latestContext.chatSessionId,
+					projectId: latestContext.projectId
+				};
+			} else {
+				this.mostRecentActiveStream = null;
+			}
+		}
+	}
+
+	/**
+	 * Get the last used project ID (fallback)
+	 * This is used as a last resort when no session context is available
+	 */
+	getLastUsedProjectId(): string | null {
+		return this.lastUsedProjectId;
+	}
+
+	/**
+	 * Get all registered sessions (for debugging)
+	 */
+	getAllSessions(): Array<{ sessionId: string; projectId: string }> {
+		return Array.from(this.sessionProjectMap.entries()).map(([sessionId, projectId]) => ({
+			sessionId,
+			projectId
+		}));
+	}
+
+	/**
+	 * Clear all mappings (for testing or cleanup)
+	 */
+	clear(): void {
+		this.sessionProjectMap.clear();
+		this.streamProjectMap.clear();
+		this.lastUsedProjectId = null;
+		debug.log('mcp', '🧹 Cleared all project context mappings');
+	}
+
+	/**
+	 * Get current execution context (from AsyncLocalStorage)
+	 */
+	getCurrentContext(): ExecutionContext | undefined {
+		return executionContext.getStore();
+	}
+
+	/**
+	 * Run callback with execution context
+	 * This should be called by stream manager when starting MCP tool execution
+	 */
+	runWithContext<T>(context: ExecutionContext, callback: () => T): T {
+		return executionContext.run(context, callback);
+	}
+
+	/**
+	 * Run async callback with execution context
+	 */
+	async runWithContextAsync<T>(context: ExecutionContext, callback: () => Promise<T>): Promise<T> {
+		return executionContext.run(context, callback);
+	}
+
+	/**
+	 * Get project ID from current execution context
+	 * This is the primary method MCP handlers should use
+	 */
+	getCurrentProjectId(): string | null {
+		const context = this.getCurrentContext();
+
+		// 1. Try to get from execution context (highest priority)
+		if (context?.projectId) {
+			debug.log('mcp', `📍 Project ID from execution context: ${context.projectId}`);
+			return context.projectId;
+		}
+
+		// 2. Try to get from session mapping
+		if (context?.chatSessionId) {
+			const projectId = this.getProjectIdForSession(context.chatSessionId);
+			if (projectId) {
+				debug.log('mcp', `📍 Project ID from session mapping: ${projectId}`);
+				return projectId;
+			}
+		}
+
+		// 3. Try to get from stream mapping
+		if (context?.streamId) {
+			const projectId = this.getProjectIdForStream(context.streamId);
+			if (projectId) {
+				debug.log('mcp', `📍 Project ID from stream mapping: ${projectId}`);
+				return projectId;
+			}
+		}
+
+		// 4. Try to get from most recent active stream
+		if (this.mostRecentActiveStream) {
+			debug.log('mcp', `📍 Project ID from most recent active stream: ${this.mostRecentActiveStream.projectId}`);
+			return this.mostRecentActiveStream.projectId;
+		}
+
+		// 5. Fallback to last used project ID
+		const fallback = this.getLastUsedProjectId();
+		if (fallback) {
+			debug.log('mcp', `📍 Project ID from fallback: ${fallback}`);
+		} else {
+			debug.warn('mcp', '⚠️ No project ID available in any context!');
+		}
+		return fallback;
+	}
+}
+
+// Singleton instance
+export const projectContextService = new ProjectContextService();