deepdebug-local-agent 0.3.1

package/mcp-server.js

@@ -0,0 +1,533 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import {
+    CallToolRequestSchema,
+    ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import path from "path";
+import { spawn } from "child_process";
+import { exists, listRecursive, readFile, writeFile, stat } from "./fs-utils.js";
+import { detectProject, readText } from "./detectors.js";
+import { applyUnifiedDiff } from "./patch.js";
+
+/**
+ * DeepDebug MCP Server
+ *
+ * Expõe as capacidades do Local Agent via Model Context Protocol.
+ * Permite que o Claude AI aceda ao código real dos workspaces
+ * antes de gerar patches.
+ *
+ * Tools:
+ * 1. read_file       — Lê ficheiro do workspace
+ * 2. write_file      — Escreve ficheiro no workspace
+ * 3. list_directory   — Lista ficheiros/dirs
+ * 4. search_code      — Grep no workspace
+ * 5. execute_command  — Corre comando (compile, test)
+ * 6. get_project_info — Language, framework, deps
+ * 7. apply_patch      — Aplica unified diff
+ * 8. get_workspace_status — Status de todos os workspaces
+ */
+
+/** @type {import('./workspace-manager.js').WorkspaceManager} */
+let workspaceManager = null;
+
+/**
+ * Inicializa o MCP Server com referência ao WorkspaceManager.
+ * @param {import('./workspace-manager.js').WorkspaceManager} wsManager
+ */
+export function createMCPServer(wsManager) {
+    workspaceManager = wsManager;
+
+    const server = new Server(
+        {
+            name: "deepdebug-local-agent",
+            version: "1.0.0",
+        },
+        {
+            capabilities: {
+                tools: {},
+            },
+        }
+    );
+
+    // ============================================
+    // LIST TOOLS
+    // ============================================
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: [
+            {
+                name: "read_file",
+                description: "Read the contents of a file from a workspace. Returns the full file content as text. Use this to understand existing code before generating patches.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspaceId: { type: "string", description: "Workspace ID (optional, uses default if not provided)" },
+                        path: { type: "string", description: "Relative file path (e.g. 'src/main/java/com/example/UserService.java')" },
+                    },
+                    required: ["path"],
+                },
+            },
+            {
+                name: "write_file",
+                description: "Write content to a file in a workspace. Creates the file if it doesn't exist. Use with caution.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspaceId: { type: "string", description: "Workspace ID" },
+                        path: { type: "string", description: "Relative file path" },
+                        content: { type: "string", description: "File content to write" },
+                    },
+                    required: ["path", "content"],
+                },
+            },
+            {
+                name: "list_directory",
+                description: "List files and directories in a workspace path. Returns file tree with types (file/dir). Useful to understand project structure.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspaceId: { type: "string", description: "Workspace ID" },
+                        path: { type: "string", description: "Relative directory path (empty or '.' for root)" },
+                        maxFiles: { type: "number", description: "Max files to return (default 500)", default: 500 },
+                    },
+                    required: [],
+                },
+            },
+            {
+                name: "search_code",
+                description: "Search for text patterns in workspace files using grep. Returns matching lines with file paths and line numbers. Use to find related code, usages, and dependencies.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspaceId: { type: "string", description: "Workspace ID" },
+                        query: { type: "string", description: "Search pattern (text or regex)" },
+                        filePattern: { type: "string", description: "File glob pattern (e.g. '*.java', '*.ts')", default: "*" },
+                        maxResults: { type: "number", description: "Max results (default 50)", default: 50 },
+                    },
+                    required: ["query"],
+                },
+            },
+            {
+                name: "execute_command",
+                description: "Execute a shell command in the workspace directory. Use for compilation, testing, and validation. Returns stdout, stderr, and exit code.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspaceId: { type: "string", description: "Workspace ID" },
+                        command: { type: "string", description: "Command to execute (e.g. 'mvn compile', 'npm test')" },
+                        timeoutMs: { type: "number", description: "Timeout in ms (default 120000)", default: 120000 },
+                    },
+                    required: ["command"],
+                },
+            },
+            {
+                name: "get_project_info",
+                description: "Get project metadata: programming language, framework, build tool, and detected port. Use to understand the tech stack before generating fixes.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspaceId: { type: "string", description: "Workspace ID" },
+                    },
+                    required: [],
+                },
+            },
+            {
+                name: "apply_patch",
+                description: "Apply a unified diff patch to a file in the workspace. The diff must be in standard unified diff format. Returns the patched file path and size.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspaceId: { type: "string", description: "Workspace ID" },
+                        diff: { type: "string", description: "Unified diff content" },
+                    },
+                    required: ["diff"],
+                },
+            },
+            {
+                name: "get_workspace_status",
+                description: "Get status of all open workspaces, or a specific one. Returns workspace IDs, roots, project info, and last access times.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspaceId: { type: "string", description: "Specific workspace ID (optional, returns all if not provided)" },
+                    },
+                    required: [],
+                },
+            },
+        ],
+    }));
+
+    // ============================================
+    // CALL TOOL — Route to handler
+    // ============================================
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+
+        try {
+            switch (name) {
+                case "read_file":
+                    return await handleReadFile(args);
+                case "write_file":
+                    return await handleWriteFile(args);
+                case "list_directory":
+                    return await handleListDirectory(args);
+                case "search_code":
+                    return await handleSearchCode(args);
+                case "execute_command":
+                    return await handleExecuteCommand(args);
+                case "get_project_info":
+                    return await handleGetProjectInfo(args);
+                case "apply_patch":
+                    return await handleApplyPatch(args);
+                case "get_workspace_status":
+                    return await handleGetWorkspaceStatus(args);
+                default:
+                    return errorResponse(`Unknown tool: ${name}`);
+            }
+        } catch (err) {
+            console.error(`❌ MCP tool error [${name}]:`, err.message);
+            return errorResponse(err.message);
+        }
+    });
+
+    return server;
+}
+
+// ============================================
+// TOOL HANDLERS
+// ============================================
+
+async function handleReadFile(args) {
+    const root = workspaceManager.resolveRoot(args.workspaceId);
+    const filePath = args.path;
+
+    // Security: prevent path traversal
+    const full = path.resolve(root, filePath);
+    if (!full.startsWith(root)) {
+        return errorResponse("Path traversal not allowed");
+    }
+
+    if (!(await exists(full))) {
+        return errorResponse(`File not found: ${filePath}`);
+    }
+
+    const fileStats = await stat(full);
+    // Limit: 1MB
+    if (fileStats.size > 1024 * 1024) {
+        return errorResponse(`File too large: ${(fileStats.size / 1024).toFixed(0)}KB (max 1MB)`);
+    }
+
+    const content = await readFile(full, "utf8");
+
+    return textResponse(
+        `File: ${filePath}\nSize: ${fileStats.size} bytes\nLines: ${content.split("\n").length}\n\n${content}`
+    );
+}
+
+async function handleWriteFile(args) {
+    const root = workspaceManager.resolveRoot(args.workspaceId);
+    const filePath = args.path;
+    const content = args.content;
+
+    const full = path.resolve(root, filePath);
+    if (!full.startsWith(root)) {
+        return errorResponse("Path traversal not allowed");
+    }
+
+    // Ensure directory exists
+    const dir = path.dirname(full);
+    const fs = await import("fs");
+    await fs.promises.mkdir(dir, { recursive: true });
+
+    await writeFile(full, content, "utf8");
+
+    return textResponse(`Written: ${filePath} (${Buffer.byteLength(content, "utf8")} bytes)`);
+}
+
+async function handleListDirectory(args) {
+    const root = workspaceManager.resolveRoot(args.workspaceId);
+    const dirPath = args.path || ".";
+    const maxFiles = args.maxFiles || 500;
+
+    const full = path.resolve(root, dirPath);
+    if (!full.startsWith(root)) {
+        return errorResponse("Path traversal not allowed");
+    }
+
+    const entries = await listRecursive(full, { maxFiles });
+
+    // Format as tree-like output
+    const lines = entries.map(e =>
+        `${e.type === "dir" ? "📁" : "📄"} ${e.path}`
+    );
+
+    return textResponse(
+        `Directory: ${dirPath}\nEntries: ${entries.length}${entries.length >= maxFiles ? " (truncated)" : ""}\n\n${lines.join("\n")}`
+    );
+}
+
+async function handleSearchCode(args) {
+    const root = workspaceManager.resolveRoot(args.workspaceId);
+    const query = args.query;
+    const filePattern = args.filePattern || "*";
+    const maxResults = args.maxResults || 50;
+
+    return new Promise((resolve) => {
+        // Use grep with recursive search, excluding common dirs
+        const grepArgs = [
+            "-rn",                          // recursive + line numbers
+            "--include", filePattern,        // file pattern
+            "-m", String(maxResults),        // max matches per file
+            "--exclude-dir=node_modules",
+            "--exclude-dir=.git",
+            "--exclude-dir=target",
+            "--exclude-dir=build",
+            "--exclude-dir=dist",
+            "--exclude-dir=.idea",
+            "--exclude-dir=__pycache__",
+            query,
+            "."
+        ];
+
+        const child = spawn("grep", grepArgs, { cwd: root, shell: false });
+        let stdout = "";
+        let stderr = "";
+
+        child.stdout.on("data", (d) => stdout += d.toString());
+        child.stderr.on("data", (d) => stderr += d.toString());
+
+        const timer = setTimeout(() => {
+            try { child.kill("SIGKILL"); } catch {}
+        }, 10000);
+
+        child.on("close", (code) => {
+            clearTimeout(timer);
+
+            if (code > 1) {
+                resolve(errorResponse(`Search failed: ${stderr.trim()}`));
+                return;
+            }
+
+            const lines = stdout.trim().split("\n").filter(Boolean);
+            const truncated = lines.length >= maxResults;
+
+            resolve(textResponse(
+                `Search: "${query}" (pattern: ${filePattern})\nResults: ${lines.length}${truncated ? " (truncated)" : ""}\n\n${lines.join("\n")}`
+            ));
+        });
+    });
+}
+
+async function handleExecuteCommand(args) {
+    const root = workspaceManager.resolveRoot(args.workspaceId);
+    const command = args.command;
+    const timeoutMs = args.timeoutMs || 120000;
+
+    // Security: block dangerous commands
+    const blocked = ["rm -rf /", "rm -rf ~", "mkfs", "dd if=", "> /dev/"];
+    for (const b of blocked) {
+        if (command.includes(b)) {
+            return errorResponse(`Blocked command: ${b}`);
+        }
+    }
+
+    return new Promise((resolve) => {
+        const child = spawn("sh", ["-c", command], { cwd: root });
+        let stdout = "";
+        let stderr = "";
+
+        child.stdout.on("data", (d) => stdout += d.toString());
+        child.stderr.on("data", (d) => stderr += d.toString());
+
+        const timer = setTimeout(() => {
+            try { child.kill("SIGKILL"); } catch {}
+            resolve(textResponse(
+                `Command: ${command}\nStatus: TIMEOUT (${timeoutMs}ms)\n\nstdout:\n${stdout}\n\nstderr:\n${stderr}`
+            ));
+        }, timeoutMs);
+
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            resolve(textResponse(
+                `Command: ${command}\nExit code: ${code}\n\nstdout:\n${stdout}\n\nstderr:\n${stderr}`
+            ));
+        });
+    });
+}
+
+async function handleGetProjectInfo(args) {
+    const root = workspaceManager.resolveRoot(args.workspaceId);
+    const projectInfo = await detectProject(root);
+
+    // Try to read key config files for more context
+    let dependencies = "";
+    try {
+        if (projectInfo.language === "java" && projectInfo.buildTool === "maven") {
+            const pom = await readFile(path.join(root, "pom.xml"), "utf8");
+            // Extract just the dependencies section (trimmed)
+            const depsMatch = pom.match(/<dependencies>([\s\S]*?)<\/dependencies>/);
+            dependencies = depsMatch ? depsMatch[1].trim() : "No dependencies section found";
+        } else if (projectInfo.language === "node") {
+            const pkg = JSON.parse(await readFile(path.join(root, "package.json"), "utf8"));
+            dependencies = JSON.stringify({
+                dependencies: pkg.dependencies || {},
+                devDependencies: pkg.devDependencies || {}
+            }, null, 2);
+        } else if (projectInfo.language === "python") {
+            try {
+                dependencies = await readFile(path.join(root, "requirements.txt"), "utf8");
+            } catch {
+                try {
+                    dependencies = await readFile(path.join(root, "pyproject.toml"), "utf8");
+                } catch {
+                    dependencies = "No dependency file found";
+                }
+            }
+        }
+    } catch {
+        dependencies = "Could not read dependencies";
+    }
+
+    return textResponse(
+        `Project Info:\n` +
+        `  Language: ${projectInfo.language}\n` +
+        `  Build Tool: ${projectInfo.buildTool}\n` +
+        `  Marker File: ${projectInfo.marker}\n` +
+        `  Root: ${root}\n\n` +
+        `Dependencies:\n${dependencies}`
+    );
+}
+
+async function handleApplyPatch(args) {
+    const root = workspaceManager.resolveRoot(args.workspaceId);
+    const diff = args.diff;
+
+    const result = await applyUnifiedDiff(root, diff);
+
+    return textResponse(
+        `Patch applied successfully!\n` +
+        `  Target: ${result.target}\n` +
+        `  Size: ${result.bytes} bytes`
+    );
+}
+
+async function handleGetWorkspaceStatus(args) {
+    if (args.workspaceId) {
+        const ws = workspaceManager.get(args.workspaceId);
+        if (!ws) return errorResponse(`Workspace not found: ${args.workspaceId}`);
+        return textResponse(JSON.stringify(ws, null, 2));
+    }
+
+    const all = workspaceManager.list();
+    return textResponse(
+        `Open workspaces: ${all.length}\nDefault: ${workspaceManager.defaultWorkspaceId || "none"}\n\n` +
+        JSON.stringify(all, null, 2)
+    );
+}
+
+// ============================================
+// HELPERS
+// ============================================
+
+function textResponse(text) {
+    return {
+        content: [{ type: "text", text }],
+    };
+}
+
+function errorResponse(message) {
+    return {
+        content: [{ type: "text", text: `ERROR: ${message}` }],
+        isError: true,
+    };
+}
+
+// ============================================
+// HTTP/SSE TRANSPORT — Para o Gateway chamar
+// ============================================
+
+/**
+ * Inicia o MCP Server com transporte SSE numa porta HTTP.
+ * O Gateway liga-se via HTTP POST com SSE.
+ */
+export async function startMCPHttpServer(wsManager, port = 5056) {
+    const express = (await import("express")).default;
+    const app = express();
+
+    const server = createMCPServer(wsManager);
+
+    // Map para guardar transportes activos
+    const transports = new Map();
+
+    // SSE endpoint — o client liga-se aqui
+    app.get("/sse", (req, res) => {
+        const sessionId = `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        console.log(`🔌 MCP SSE connection: ${sessionId}`);
+
+        const transport = new SSEServerTransport(`/messages/${sessionId}`, res);
+        transports.set(sessionId, transport);
+
+        server.connect(transport).catch(err => {
+            console.error(`❌ MCP transport error: ${err.message}`);
+        });
+
+        req.on("close", () => {
+            console.log(`🔌 MCP SSE disconnected: ${sessionId}`);
+            transports.delete(sessionId);
+        });
+    });
+
+    // Message endpoint — o client envia mensagens aqui
+    app.post("/messages/:sessionId", express.json(), (req, res) => {
+        const { sessionId } = req.params;
+        const transport = transports.get(sessionId);
+        if (!transport) {
+            return res.status(404).json({ error: "Session not found" });
+        }
+        transport.handlePostMessage(req, res);
+    });
+
+    // Health check
+    app.get("/health", (_req, res) => {
+        res.json({
+            status: "ok",
+            protocol: "mcp",
+            workspaces: wsManager.count,
+            defaultWorkspace: wsManager.defaultWorkspaceId
+        });
+    });
+
+    // Simple REST wrapper — para o Gateway chamar tools directamente via HTTP
+    // Isto é mais simples que MCP SSE para integração Java
+    app.post("/tool/:toolName", express.json(), async (req, res) => {
+        const { toolName } = req.params;
+        const args = req.body || {};
+
+        try {
+            const result = await server.callTool({ name: toolName, arguments: args });
+            res.json(result);
+        } catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+
+    // List available tools
+    app.get("/tools", async (_req, res) => {
+        try {
+            const result = await server.listTools();
+            res.json(result);
+        } catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+
+    app.listen(port, () => {
+        console.log(`🧠 DeepDebug MCP Server listening on http://localhost:${port}`);
+        console.log(`   SSE: http://localhost:${port}/sse`);
+        console.log(`   REST: http://localhost:${port}/tool/{toolName}`);
+        console.log(`   Tools: http://localhost:${port}/tools`);
+    });
+
+    return { server, app };
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "deepdebug-local-agent",
+  "version": "0.3.1",
+  "type": "module",
+  "main": "src/server.js",
+  "scripts": {
+    "start": "node src/server.js",
+    "dev": "NODE_ENV=development node src/server.js",
+    "mcp": "node src/mcp-server.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "body-parser": "^1.20.3",
+    "cors": "^2.8.5",
+    "express": "^4.19.2",
+    "js-yaml": "^4.1.0",
+    "pidusage": "^3.0.2",
+    "properties-reader": "^2.3.0",
+    "strip-ansi": "^7.1.0",
+    "unidiff": "^1.0.2"
+  }
+}