crewx 0.8.7-rc.21 → 0.8.7-rc.22

package/dist-server/domain/mcp/mcp.service.js

@@ -1,684 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var McpService_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.McpService = void 0;
-const common_1 = require("@nestjs/common");
-const mcp_dto_js_1 = require("./mcp.dto.js");
-const crewx_tool_factory_js_1 = require("./crewx-tool.factory.js");
-const browser_session_store_js_1 = require("./browser-session.store.js");
-const tool_router_service_js_1 = require("./tool-router.service.js");
-const crewx_pool_service_js_1 = require("../../modules/crewx-pool.service.js");
-const project_repository_js_1 = require("../../repository/project.repository.js");
-const repository_1 = require("@crewx/sdk/repository");
-const sdk_1 = require("@crewx/sdk");
-const BROWSER_TOOL_DEFINITIONS = [
-    {
-        name: 'callBrowser',
-        description: 'Execute a WebMCP tool on a specific browser tab',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                tabId: { type: 'number', description: 'Target tab ID' },
-                tool: { type: 'string', description: 'WebMCP tool name' },
-                args: { type: 'object', description: 'Arguments to pass to the tool' },
-            },
-            required: ['tabId', 'tool'],
-        },
-    },
-    {
-        name: 'openTab',
-        description: 'Open a new browser tab with the given URL',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                url: { type: 'string', description: 'URL to open' },
-            },
-            required: ['url'],
-        },
-    },
-    {
-        name: 'listTabs',
-        description: 'List all connected tabs and their available tools',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'closeTab',
-        description: 'Close a browser tab',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                tabId: { type: 'number', description: 'Tab ID to close' },
-            },
-            required: ['tabId'],
-        },
-    },
-];
-const SERVER_NAME = 'crewx-ui';
-const SERVER_VERSION = '0.1.0';
-const PROTOCOL_VERSION = '2024-11-05';
-// workspace optional parameter schema — shared across tools that support it
-const WORKSPACE_PARAM = {
-    workspace: {
-        type: 'string',
-        description: 'Optional workspace slug (e.g. "crewx-ui"). Omit to use the server\'s current workspace.',
-    },
-};
-// Tool definitions exposed via tools/list
-const TOOL_DEFINITIONS = [
-    {
-        name: 'crewx_listWorkspaces',
-        description: 'List all registered workspaces (slug, name, path).',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'crewx_queryAgent',
-        description: 'Query an agent (read-only). The agent will answer your question without making changes.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                agentId: {
-                    type: 'string',
-                    description: 'The ID of the agent to query (e.g., "ui_backend_dev")',
-                },
-                query: {
-                    type: 'string',
-                    description: 'The question or request to send to the agent',
-                },
-                context: {
-                    type: 'string',
-                    description: 'Optional additional context for the query',
-                },
-                thread: {
-                    type: 'string',
-                    description: 'Thread ID for conversation continuity. Previous messages with the same thread ID will be included in the context automatically.',
-                },
-                metadata: {
-                    type: 'object',
-                    additionalProperties: true,
-                    description: 'Free-form metadata (e.g., workflow_id, project_id) persisted to the task record for tracing.',
-                },
-                ...WORKSPACE_PARAM,
-            },
-            required: ['agentId', 'query'],
-        },
-    },
-    {
-        name: 'crewx_executeAgent',
-        description: 'Execute a task with an agent (read-write). The agent can modify files and run commands.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                agentId: {
-                    type: 'string',
-                    description: 'The ID of the agent to execute (e.g., "ui_backend_dev")',
-                },
-                task: {
-                    type: 'string',
-                    description: 'The task description for the agent to execute',
-                },
-                context: {
-                    type: 'string',
-                    description: 'Optional additional context for the task',
-                },
-                thread: {
-                    type: 'string',
-                    description: 'Thread ID for conversation continuity. Previous messages with the same thread ID will be included in the context automatically.',
-                },
-                metadata: {
-                    type: 'object',
-                    additionalProperties: true,
-                    description: 'Free-form metadata (e.g., workflow_id, project_id) persisted to the task record for tracing.',
-                },
-                ...WORKSPACE_PARAM,
-            },
-            required: ['agentId', 'task'],
-        },
-    },
-    {
-        name: 'crewx_listAgents',
-        description: 'List all available agents and their capabilities.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                ...WORKSPACE_PARAM,
-            },
-        },
-    },
-];
-let McpService = McpService_1 = class McpService {
-    crewxPool;
-    projectRepo;
-    browserSessions;
-    toolRouter;
-    toolCallRepo;
-    logger = new common_1.Logger(McpService_1.name);
-    activeTaskMap = new Map();
-    constructor(crewxPool, projectRepo, browserSessions, toolRouter, toolCallRepo) {
-        this.crewxPool = crewxPool;
-        this.projectRepo = projectRepo;
-        this.browserSessions = browserSessions;
-        this.toolRouter = toolRouter;
-        this.toolCallRepo = toolCallRepo;
-    }
-    async getToolForCurrentRequest() {
-        const crewx = await this.crewxPool.getForCurrentRequest();
-        return (0, crewx_tool_factory_js_1.createCrewxTool)(crewx);
-    }
-    /**
-     * Resolve ICrewXTool for the given workspace slug.
-     * If slug is omitted, falls back to the current request's workspace.
-     * Throws a tagged error (code: WORKSPACE_NOT_FOUND) if slug is unknown.
-     */
-    async getToolForWorkspace(slug) {
-        if (!slug) {
-            return this.getToolForCurrentRequest();
-        }
-        const row = this.projectRepo.findBySlug(slug);
-        if (!row?.workspace_path) {
-            throw Object.assign(new Error(`Workspace not found: ${slug}`), {
-                code: 'WORKSPACE_NOT_FOUND',
-            });
-        }
-        const crewx = await this.crewxPool.getForPath(row.workspace_path);
-        return (0, crewx_tool_factory_js_1.createCrewxTool)(crewx);
-    }
-    // Validate JSON-RPC 2.0 request structure
-    validateRequest(body) {
-        if (!body || typeof body !== 'object') {
-            return {
-                jsonrpc: '2.0',
-                id: null,
-                error: {
-                    code: mcp_dto_js_1.JSON_RPC_ERRORS.INVALID_REQUEST.code,
-                    message: 'Request body must be a JSON object',
-                },
-            };
-        }
-        if (body.jsonrpc !== '2.0') {
-            return {
-                jsonrpc: '2.0',
-                id: body.id ?? null,
-                error: {
-                    code: mcp_dto_js_1.JSON_RPC_ERRORS.INVALID_REQUEST.code,
-                    message: 'Missing or invalid "jsonrpc" field - must be "2.0"',
-                },
-            };
-        }
-        if (!body.method || typeof body.method !== 'string') {
-            return {
-                jsonrpc: '2.0',
-                id: body.id ?? null,
-                error: {
-                    code: mcp_dto_js_1.JSON_RPC_ERRORS.INVALID_REQUEST.code,
-                    message: 'Missing or invalid "method" field - must be a string',
-                },
-            };
-        }
-        return null; // Valid
-    }
-    // Check if the request is a notification (no id field)
-    isNotification(body) {
-        return body.id === undefined || body.id === null;
-    }
-    async handleRequest(body, sessionId, clientType) {
-        const { method, id } = body;
-        this.logger.debug(`Handling MCP method: ${method}`);
-        if (this.isNotification(body)) {
-            if (method === 'browser/registerTools') {
-                return this.handleRegisterTools(sessionId, body.params);
-            }
-            if (method.startsWith('notifications/')) {
-                this.logger.debug(`Received notification: ${method}`);
-                return null;
-            }
-        }
-        switch (method) {
-            case 'initialize':
-                return this.handleInitialize(id, clientType);
-            case 'notifications/initialized':
-                return null;
-            case 'tools/list':
-                return this.handleToolsList(id, sessionId);
-            case 'tools/call':
-                return this.handleToolsCall(id, body.params, sessionId);
-            case 'prompts/list':
-                return {
-                    jsonrpc: '2.0',
-                    id,
-                    result: { prompts: [] },
-                };
-            case 'resources/list':
-                return {
-                    jsonrpc: '2.0',
-                    id,
-                    result: { resources: [] },
-                };
-            default:
-                return {
-                    jsonrpc: '2.0',
-                    id,
-                    error: {
-                        code: mcp_dto_js_1.JSON_RPC_ERRORS.METHOD_NOT_FOUND.code,
-                        message: `Method not found: ${method}`,
-                    },
-                };
-        }
-    }
-    handleToolCallResult(sessionId, body) {
-        if (!body.id || typeof body.id !== 'string')
-            return false;
-        if (body.error) {
-            const err = Object.assign(new Error(body.error.message ?? 'Tool call failed'), { jsonRpcCode: body.error.code });
-            return this.browserSessions.rejectToolCall(sessionId, body.id, err);
-        }
-        return this.browserSessions.resolveToolCall(sessionId, body.id, body.result);
-    }
-    createBrowserSession(clientType) {
-        return this.browserSessions.create(clientType).id;
-    }
-    getBrowserSessionStore() {
-        return this.browserSessions;
-    }
-    handleInitialize(id, clientType) {
-        const sessionId = this.createBrowserSession(clientType);
-        return {
-            jsonrpc: '2.0',
-            id: id ?? null,
-            result: {
-                protocolVersion: PROTOCOL_VERSION,
-                capabilities: {
-                    tools: {},
-                },
-                serverInfo: {
-                    name: SERVER_NAME,
-                    version: SERVER_VERSION,
-                },
-            },
-            _sessionId: sessionId,
-        };
-    }
-    handleToolsList(id, sessionId) {
-        const tools = [...TOOL_DEFINITIONS];
-        if (sessionId) {
-            const session = this.browserSessions.get(sessionId);
-            if (session?.clientType === 'browser') {
-                tools.push(...BROWSER_TOOL_DEFINITIONS);
-            }
-            const browserTools = this.browserSessions.getRegisteredTools(sessionId);
-            for (const bt of browserTools) {
-                tools.push({
-                    name: bt.name,
-                    description: bt.description ?? '',
-                    inputSchema: {
-                        type: 'object',
-                        properties: bt.inputSchema?.properties ?? {},
-                        ...(bt.inputSchema?.required ? { required: bt.inputSchema.required } : {}),
-                    },
-                    ...(bt.title ? { title: bt.title } : {}),
-                    ...(bt.annotations ? { annotations: bt.annotations } : {}),
-                });
-            }
-        }
-        return {
-            jsonrpc: '2.0',
-            id: id ?? null,
-            result: { tools },
-        };
-    }
-    handleRegisterTools(sessionId, params) {
-        if (!sessionId || !Array.isArray(params?.tools)) {
-            this.logger.warn('browser/registerTools: missing sessionId or params');
-            return null;
-        }
-        this.browserSessions.registerTools(sessionId, params.tools, params.mode);
-        return null;
-    }
-    async handleToolsCall(id, params, sessionId) {
-        if (!params?.name) {
-            return {
-                jsonrpc: '2.0',
-                id: id ?? null,
-                error: {
-                    code: mcp_dto_js_1.JSON_RPC_ERRORS.INVALID_PARAMS.code,
-                    message: 'Missing tool name in params',
-                },
-            };
-        }
-        const startTime = Date.now();
-        let response;
-        // Browser tool: route via SSE to the extension (dual routing: prefix + session lookup)
-        if (this.toolRouter.isBrowserTool(params.name, sessionId)) {
-            this.logger.log(`tools/call [browser]: ${params.name}`);
-            response = await this.toolRouter.dispatch(sessionId, params.name, params.arguments ?? {}, id);
-        }
-        else {
-            // Server tool: must exist in TOOL_DEFINITIONS
-            const tool = TOOL_DEFINITIONS.find((t) => t.name === params.name);
-            if (!tool) {
-                return {
-                    jsonrpc: '2.0',
-                    id: id ?? null,
-                    error: {
-                        code: mcp_dto_js_1.JSON_RPC_ERRORS.METHOD_NOT_FOUND.code,
-                        message: `Unknown tool: ${params.name}`,
-                    },
-                };
-            }
-            this.logger.log(`tools/call: ${params.name}(${JSON.stringify(params.arguments)})`);
-            try {
-                switch (params.name) {
-                    case 'crewx_listWorkspaces':
-                        response = this.execListWorkspaces(id);
-                        break;
-                    case 'crewx_listAgents':
-                        response = await this.execListAgents(id, params.arguments ?? {});
-                        break;
-                    case 'crewx_queryAgent':
-                        response = await this.execQueryAgent(id, params.arguments, sessionId);
-                        break;
-                    case 'crewx_executeAgent':
-                        response = await this.execExecuteAgent(id, params.arguments, sessionId);
-                        break;
-                    default:
-                        response = {
-                            jsonrpc: '2.0',
-                            id: id ?? null,
-                            error: {
-                                code: mcp_dto_js_1.JSON_RPC_ERRORS.METHOD_NOT_FOUND.code,
-                                message: `Tool not implemented: ${params.name}`,
-                            },
-                        };
-                }
-            }
-            catch (err) {
-                this.logger.error(`tools/call error: ${err.message}`, err.stack);
-                if (err.code === 'WORKSPACE_NOT_FOUND') {
-                    response = {
-                        jsonrpc: '2.0',
-                        id: id ?? null,
-                        error: {
-                            code: mcp_dto_js_1.JSON_RPC_ERRORS.INVALID_PARAMS.code,
-                            message: `WORKSPACE_NOT_FOUND: ${err.message}`,
-                        },
-                    };
-                }
-                else {
-                    response = {
-                        jsonrpc: '2.0',
-                        id: id ?? null,
-                        error: {
-                            code: mcp_dto_js_1.JSON_RPC_ERRORS.INTERNAL_ERROR.code,
-                            message: `Tool execution failed: ${err.message}`,
-                        },
-                    };
-                }
-            }
-        }
-        // Record only browser tool calls (agent calling a tool during execution).
-        // Server tools (queryAgent, executeAgent, etc.) are task triggers, not tool calls.
-        if (this.toolRouter.isBrowserTool(params.name, sessionId)) {
-            const duration = Date.now() - startTime;
-            const taskId = (sessionId ? this.activeTaskMap.get(sessionId) : undefined) ?? null;
-            try {
-                this.toolCallRepo.insertToolCall({
-                    id: (0, sdk_1.generateId)('tcl'),
-                    task_id: taskId,
-                    session_id: sessionId ?? null,
-                    tool_name: `mcp_${params.name}`,
-                    input: JSON.stringify(params.arguments ?? {}),
-                    output: JSON.stringify(response.result?.content ?? response.error ?? null),
-                    duration_ms: duration,
-                    timestamp: new Date().toISOString(),
-                });
-            }
-            catch (err) {
-                this.logger.warn(`tool_calls insert failed: ${err?.message}`);
-            }
-        }
-        return response;
-    }
-    // ──────────────────────────────────────────────
-    // Tool implementations — direct CrewXTool calls
-    // ──────────────────────────────────────────────
-    /**
-     * crewx_listWorkspaces — returns all registered workspaces (slug, name, path)
-     */
-    execListWorkspaces(id) {
-        try {
-            const { rows } = this.projectRepo.listProjects({ isActive: true, limit: 1000, offset: 0 });
-            const workspaces = rows.map((r) => ({
-                slug: r.slug,
-                name: r.name,
-                path: r.workspace_path ?? '',
-            }));
-            return {
-                jsonrpc: '2.0',
-                id: id ?? null,
-                result: {
-                    content: [{ type: 'text', text: JSON.stringify(workspaces, null, 2) }],
-                    isError: false,
-                },
-            };
-        }
-        catch (err) {
-            this.logger.error(`listWorkspaces error: ${err.message}`, err.stack);
-            return {
-                jsonrpc: '2.0',
-                id: id ?? null,
-                result: {
-                    content: [{ type: 'text', text: `Error listing workspaces: ${err.message}` }],
-                    isError: true,
-                },
-            };
-        }
-    }
-    /**
-     * crewx_listAgents — delegates to CrewXTool.listAgents()
-     */
-    async execListAgents(id, args) {
-        // May throw WORKSPACE_NOT_FOUND — propagates to handleToolsCall outer catch
-        const tool = await this.getToolForWorkspace(args.workspace);
-        try {
-            const result = await tool.listAgents();
-            return {
-                jsonrpc: '2.0',
-                id: id ?? null,
-                result: {
-                    content: result.content,
-                    isError: !result.success,
-                },
-            };
-        }
-        catch (err) {
-            this.logger.error(`listAgents error: ${err.message}`, err.stack);
-            return {
-                jsonrpc: '2.0',
-                id: id ?? null,
-                result: {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Error listing agents: ${err.message}`,
-                        },
-                    ],
-                    isError: true,
-                },
-            };
-        }
-    }
-    /**
-     * crewx_queryAgent — delegates to CrewXTool.queryAgent()
-     */
-    async execQueryAgent(id, args, sessionId) {
-        const { agentId, query, context, thread, metadata, workspace } = args;
-        if (!agentId || !query) {
-            return {
-                jsonrpc: '2.0',
-                id: id ?? null,
-                error: {
-                    code: mcp_dto_js_1.JSON_RPC_ERRORS.INVALID_PARAMS.code,
-                    message: 'Missing required params: agentId, query',
-                },
-            };
-        }
-        // May throw WORKSPACE_NOT_FOUND — propagates to handleToolsCall outer catch
-        const tool = await this.getToolForWorkspace(workspace);
-        try {
-            const startTime = Date.now();
-            const result = await tool.queryAgent({
-                agentId,
-                query,
-                context,
-                threadId: thread,
-                metadata: metadata ?? {},
-                platform: 'mcp',
-                onTaskId: sessionId
-                    ? (taskId) => this.activeTaskMap.set(sessionId, taskId)
-                    : undefined,
-            });
-            const duration = Date.now() - startTime;
-            const content = normalizeContent(result);
-            return {
-                jsonrpc: '2.0',
-                id: id ?? null,
-                result: {
-                    content,
-                    isError: result.isError ?? !result.success,
-                    _meta: {
-                        agent: result.agent ?? agentId,
-                        provider: result.provider,
-                        taskId: result.taskId,
-                        thread,
-                        duration,
-                    },
-                },
-            };
-        }
-        catch (err) {
-            this.logger.error(`queryAgent error: ${err.message}`, err.stack);
-            return {
-                jsonrpc: '2.0',
-                id: id ?? null,
-                result: {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Error querying agent: ${err.message}`,
-                        },
-                    ],
-                    isError: true,
-                    _meta: { agent: agentId },
-                },
-            };
-        }
-        finally {
-            if (sessionId) {
-                this.activeTaskMap.delete(sessionId);
-            }
-        }
-    }
-    /**
-     * crewx_executeAgent — delegates to CrewXTool.executeAgent()
-     */
-    async execExecuteAgent(id, args, sessionId) {
-        const { agentId, task, context, thread, metadata, workspace } = args;
-        if (!agentId || !task) {
-            return {
-                jsonrpc: '2.0',
-                id: id ?? null,
-                error: {
-                    code: mcp_dto_js_1.JSON_RPC_ERRORS.INVALID_PARAMS.code,
-                    message: 'Missing required params: agentId, task',
-                },
-            };
-        }
-        // May throw WORKSPACE_NOT_FOUND — propagates to handleToolsCall outer catch
-        const tool = await this.getToolForWorkspace(workspace);
-        try {
-            const startTime = Date.now();
-            const result = await tool.executeAgent({
-                agentId,
-                task,
-                context,
-                threadId: thread,
-                metadata: metadata ?? {},
-                platform: 'mcp',
-                onTaskId: sessionId
-                    ? (taskId) => this.activeTaskMap.set(sessionId, taskId)
-                    : undefined,
-            });
-            const duration = Date.now() - startTime;
-            const content = normalizeContent(result);
-            return {
-                jsonrpc: '2.0',
-                id: id ?? null,
-                result: {
-                    content,
-                    isError: result.isError ?? !result.success,
-                    _meta: {
-                        agent: result.agent ?? agentId,
-                        provider: result.provider,
-                        taskId: result.taskId,
-                        thread,
-                        duration,
-                    },
-                },
-            };
-        }
-        catch (err) {
-            this.logger.error(`executeAgent error: ${err.message}`, err.stack);
-            return {
-                jsonrpc: '2.0',
-                id: id ?? null,
-                result: {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Error executing agent: ${err.message}`,
-                        },
-                    ],
-                    isError: true,
-                    _meta: { agent: agentId },
-                },
-            };
-        }
-        finally {
-            if (sessionId) {
-                this.activeTaskMap.delete(sessionId);
-            }
-        }
-    }
-};
-exports.McpService = McpService;
-exports.McpService = McpService = McpService_1 = __decorate([
-    (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [crewx_pool_service_js_1.CrewxPoolService,
-        project_repository_js_1.ProjectRepository,
-        browser_session_store_js_1.BrowserSessionStore,
-        tool_router_service_js_1.ToolRouterService,
-        repository_1.ToolCallRepository])
-], McpService);
-function normalizeContent(result) {
-    if (Array.isArray(result.content) && result.content.length > 0) {
-        return result.content;
-    }
-    if (typeof result.response === 'string' && result.response.length > 0) {
-        return [{ type: 'text', text: result.response }];
-    }
-    return [];
-}