@ebowwa/workspace-mcp 1.0.0

package/dist/index.js

@@ -0,0 +1,658 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from "@modelcontextprotocol/sdk/types.js";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { readdir, readFile, stat } from "fs/promises";
+import { join } from "path";
+import * as psList from "ps-list";
+const execAsync = promisify(exec);
+class WorkspaceMCPServer {
+    server;
+    constructor() {
+        this.server = new Server({
+            name: "workspace-mcp",
+            version: "1.0.0",
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+        this.setupTools();
+        this.setupErrorHandling();
+    }
+    setupErrorHandling() {
+        this.server.onerror = (error) => console.error("[MCP Error]", error);
+        process.on("SIGINT", async () => {
+            await this.server.close();
+            process.exit(0);
+        });
+    }
+    setupTools() {
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+            tools: [
+                {
+                    name: "workspace_dirs_list",
+                    description: "List all directories in the workspace root",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            includeProcesses: {
+                                type: "boolean",
+                                description: "Include running processes for each directory",
+                                default: false,
+                            },
+                        },
+                    },
+                },
+                {
+                    name: "workspace_dirs_get_info",
+                    description: "Get detailed information about a specific workspace directory",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            dirPath: {
+                                type: "string",
+                                description: "Path to the directory",
+                            },
+                        },
+                        required: ["dirPath"],
+                    },
+                },
+                {
+                    name: "workspace_dirs_run_command",
+                    description: "Run a command in a specific workspace directory",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            dirPath: {
+                                type: "string",
+                                description: "Path to the directory",
+                            },
+                            command: {
+                                type: "string",
+                                description: "Command to run (e.g., 'npm install', 'npm run dev')",
+                            },
+                            timeout: {
+                                type: "number",
+                                description: "Timeout in milliseconds (default: 30000)",
+                                default: 30000,
+                            },
+                        },
+                        required: ["dirPath", "command"],
+                    },
+                },
+                {
+                    name: "workspace_services_list",
+                    description: "List all running development services and their status",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            filter: {
+                                type: "string",
+                                description: "Filter services by name or type",
+                            },
+                        },
+                    },
+                },
+                {
+                    name: "workspace_services_manage",
+                    description: "Start, stop, or restart a development service",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            serviceName: {
+                                type: "string",
+                                description: "Name of the service to manage",
+                            },
+                            action: {
+                                type: "string",
+                                enum: ["start", "stop", "restart", "status"],
+                                description: "Action to perform on the service",
+                            },
+                            dirPath: {
+                                type: "string",
+                                description: "Path to the directory (if applicable)",
+                            },
+                        },
+                        required: ["serviceName", "action"],
+                    },
+                },
+                {
+                    name: "workspace_files_read",
+                    description: "Read a file from a workspace directory",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            filePath: {
+                                type: "string",
+                                description: "Path to the file to read",
+                            },
+                            encoding: {
+                                type: "string",
+                                description: "File encoding (default: utf8)",
+                                default: "utf8",
+                            },
+                        },
+                        required: ["filePath"],
+                    },
+                },
+                {
+                    name: "check_integrations",
+                    description: "Check the health of all integrations (GitHub CLI, Doppler, Node, etc.)",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            verbose: {
+                                type: "boolean",
+                                description: "Include detailed diagnostic information",
+                                default: false,
+                            },
+                        },
+                    },
+                },
+            ],
+        }));
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            try {
+                switch (name) {
+                    case "workspace_dirs_list":
+                        return await this.listProjects(args?.includeProcesses);
+                    case "workspace_dirs_get_info":
+                        return await this.getProjectInfo(args?.dirPath);
+                    case "workspace_dirs_run_command":
+                        return await this.runProjectCommand(args?.dirPath, args?.command, args?.timeout);
+                    case "workspace_services_list":
+                        return await this.listServices(args?.filter);
+                    case "workspace_services_manage":
+                        return await this.manageService(args?.serviceName, args?.action, args?.dirPath);
+                    case "workspace_files_read":
+                        return await this.readProjectFile(args?.filePath, args?.encoding);
+                    case "check_integrations":
+                        return await this.checkIntegrations(args?.verbose);
+                    default:
+                        throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+                }
+            }
+            catch (error) {
+                throw new McpError(ErrorCode.InternalError, `Tool execution failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
+    }
+    async listProjects(includeProcesses = false) {
+        try {
+            const rootDir = "/root";
+            const entries = await readdir(rootDir, { withFileTypes: true });
+            const projects = [];
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const projectPath = join(rootDir, entry.name);
+                const projectStat = await stat(projectPath);
+                // Skip hidden directories and common system dirs
+                if (entry.name.startsWith('.') ||
+                    ['node_modules', '.git', '.npm', '.cache', '.local'].includes(entry.name)) {
+                    continue;
+                }
+                const hasPackageJson = await this.checkFileExists(join(projectPath, "package.json"));
+                const isGitRepo = await this.checkFileExists(join(projectPath, ".git"));
+                let projectType = "unknown";
+                if (hasPackageJson)
+                    projectType = "node";
+                else if (await this.checkFileExists(join(projectPath, "go.mod")))
+                    projectType = "go";
+                else if (await this.checkFileExists(join(projectPath, "requirements.txt")) ||
+                    await this.checkFileExists(join(projectPath, "pyproject.toml")))
+                    projectType = "python";
+                else if (entry.name.includes("mcp-"))
+                    projectType = "mcp-server";
+                const project = {
+                    name: entry.name,
+                    path: projectPath,
+                    type: projectType,
+                    lastModified: projectStat.mtime,
+                    hasPackageJson,
+                };
+                if (includeProcesses) {
+                    project.processes = await this.getProjectProcesses(projectPath);
+                }
+                projects.push(project);
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            projects: projects.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime()),
+                            count: projects.length,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to list projects: ${error}`);
+        }
+    }
+    async getProjectInfo(dirPath) {
+        try {
+            const projectStat = await stat(dirPath);
+            const hasPackageJson = await this.checkFileExists(join(dirPath, "package.json"));
+            const isGitRepo = await this.checkFileExists(join(dirPath, ".git"));
+            let packageInfo = null;
+            if (hasPackageJson) {
+                try {
+                    const packageContent = await readFile(join(dirPath, "package.json"), "utf8");
+                    packageInfo = JSON.parse(packageContent);
+                }
+                catch (e) {
+                    // Ignore package.json read errors
+                }
+            }
+            let gitStatus = null;
+            if (isGitRepo) {
+                try {
+                    const { stdout } = await execAsync(`cd "${dirPath}" && git status --porcelain`);
+                    gitStatus = {
+                        clean: stdout.trim() === "",
+                        changes: stdout.split('\n').filter(line => line.trim()).length,
+                    };
+                }
+                catch (e) {
+                    gitStatus = { error: "Failed to get git status" };
+                }
+            }
+            const processes = await this.getProjectProcesses(dirPath);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            path: dirPath,
+                            lastModified: projectStat.mtime,
+                            hasPackageJson,
+                            isGitRepo,
+                            packageInfo,
+                            gitStatus,
+                            processes,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to get project info: ${error}`);
+        }
+    }
+    async runProjectCommand(dirPath, command, timeout = 30000) {
+        try {
+            const { stdout, stderr } = await execAsync(`cd "${dirPath}" && ${command}`, {
+                timeout,
+                maxBuffer: 1024 * 1024, // 1MB buffer
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            command,
+                            dirPath,
+                            stdout,
+                            stderr,
+                            success: true,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            command,
+                            dirPath,
+                            error: error.message,
+                            stdout: error.stdout || "",
+                            stderr: error.stderr || "",
+                            success: false,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+    }
+    async listServices(filter) {
+        try {
+            const processes = await psList.default();
+            const services = [];
+            const servicePatterns = [
+                { name: "node", pattern: /node/ },
+                { name: "npm", pattern: /npm/ },
+                { name: "python", pattern: /python/ },
+                { name: "uvicorn", pattern: /uvicorn/ },
+                { name: "mcp-server", pattern: /mcp.*server/ },
+                { name: "next", pattern: /next/ },
+                { name: "vercel", pattern: /vercel/ },
+            ];
+            for (const process of processes) {
+                if (!process.cmd)
+                    continue;
+                for (const service of servicePatterns) {
+                    if (service.pattern.test(process.cmd)) {
+                        const serviceInfo = {
+                            name: service.name,
+                            status: "running",
+                            pid: process.pid,
+                            cpu: process.cpu,
+                            memory: process.memory,
+                            command: process.cmd,
+                        };
+                        if (!filter || service.name.includes(filter) || process.cmd.includes(filter)) {
+                            services.push(serviceInfo);
+                        }
+                        break;
+                    }
+                }
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            services,
+                            count: services.length,
+                            timestamp: new Date().toISOString(),
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to list services: ${error}`);
+        }
+    }
+    async manageService(serviceName, action, dirPath) {
+        try {
+            let command = "";
+            const cwd = dirPath || "/root";
+            switch (action) {
+                case "start":
+                    if (serviceName.includes("mcp")) {
+                        command = `cd "${cwd}" && npm start`;
+                    }
+                    else if (serviceName === "next") {
+                        command = `cd "${cwd}" && npm run dev`;
+                    }
+                    else {
+                        throw new Error(`Don't know how to start service: ${serviceName}`);
+                    }
+                    break;
+                case "stop":
+                    // Find and kill the process
+                    const { stdout } = await execAsync(`ps aux | grep "${serviceName}" | grep -v grep | awk '{print $2}'`);
+                    if (stdout.trim()) {
+                        const pids = stdout.trim().split('\n');
+                        for (const pid of pids) {
+                            await execAsync(`kill ${pid}`);
+                        }
+                    }
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({
+                                    action: "stopped",
+                                    serviceName,
+                                    pids: stdout.trim().split('\n'),
+                                    success: true,
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                case "restart":
+                    // Stop then start
+                    await this.manageService(serviceName, "stop", dirPath);
+                    await new Promise(resolve => setTimeout(resolve, 2000));
+                    return await this.manageService(serviceName, "start", dirPath);
+                case "status":
+                    const services = await this.listServices(serviceName);
+                    return services;
+                default:
+                    throw new Error(`Unknown action: ${action}`);
+            }
+            if (command) {
+                const { stdout, stderr } = await execAsync(command);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                action,
+                                serviceName,
+                                dirPath: cwd,
+                                command,
+                                stdout,
+                                stderr,
+                                success: true,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to manage service ${serviceName}: ${error}`);
+        }
+    }
+    async readProjectFile(filePath, encoding = "utf8") {
+        try {
+            const content = await readFile(filePath, encoding);
+            const stats = await stat(filePath);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            filePath,
+                            content,
+                            size: stats.size,
+                            lastModified: stats.mtime,
+                            encoding,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to read file ${filePath}: ${error}`);
+        }
+    }
+    async checkFileExists(filePath) {
+        try {
+            await stat(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getProjectProcesses(projectPath) {
+        try {
+            const processes = await psList.default();
+            const projectProcesses = [];
+            for (const process of processes) {
+                if (process.cmd && process.cmd.includes(projectPath)) {
+                    projectProcesses.push(`${process.name} (PID: ${process.pid})`);
+                }
+            }
+            return projectProcesses;
+        }
+        catch {
+            return [];
+        }
+    }
+    async checkIntegrations(verbose = false) {
+        const results = {
+            timestamp: new Date().toISOString(),
+            integrations: {},
+            summary: {
+                total: 0,
+                healthy: 0,
+                degraded: 0,
+                failed: 0
+            }
+        };
+        // Check Node.js
+        try {
+            const { stdout: nodeVersion } = await execAsync("node --version");
+            results.integrations.node = {
+                status: "healthy",
+                version: nodeVersion.trim(),
+                method: "cli"
+            };
+            results.summary.healthy++;
+        }
+        catch (error) {
+            results.integrations.node = {
+                status: "failed",
+                error: `Node.js not accessible: ${error}`,
+                method: "cli"
+            };
+            results.summary.failed++;
+        }
+        results.summary.total++;
+        // Check GitHub CLI
+        try {
+            // First try JSON auth status
+            const { stdout: ghStatus } = await execAsync("gh auth status --json 2>/dev/null || echo 'not_authenticated'", {
+                timeout: 5000
+            });
+            let authStatus = false;
+            if (ghStatus.includes('"isAuthenticated": true')) {
+                authStatus = true;
+            }
+            else {
+                // Fallback: test a simple GitHub API call
+                try {
+                    const { stdout: testCall } = await execAsync("gh api user --jq '.login' 2>/dev/null", { timeout: 3000 });
+                    authStatus = testCall.trim().length > 0;
+                }
+                catch (testError) {
+                    authStatus = false;
+                }
+            }
+            results.integrations.github_cli = {
+                status: authStatus ? "healthy" : "degraded",
+                authenticated: authStatus,
+                details: authStatus ? "GitHub CLI working" : "GitHub CLI not authenticated",
+                method: "cli"
+            };
+            if (authStatus) {
+                results.summary.healthy++;
+            }
+            else {
+                results.summary.degraded++;
+            }
+        }
+        catch (error) {
+            results.integrations.github_cli = {
+                status: "failed",
+                error: `GitHub CLI error: ${error}`,
+                method: "cli"
+            };
+            results.summary.failed++;
+        }
+        results.summary.total++;
+        // Check GitHub MCP Server (if available)
+        try {
+            const { stdout } = await execAsync("ps aux | grep -i 'github-mcp' | grep -v grep || echo 'not_running'", {
+                timeout: 3000
+            });
+            const mcpRunning = !stdout.includes('not_running') && stdout.trim().length > 0;
+            results.integrations.github_mcp = {
+                status: mcpRunning ? "healthy" : "degraded",
+                running: mcpRunning,
+                details: mcpRunning ? "GitHub MCP server detected" : "GitHub MCP server not detected",
+                method: "mcp"
+            };
+            if (mcpRunning) {
+                results.summary.healthy++;
+            }
+            else {
+                results.summary.degraded++;
+            }
+        }
+        catch (error) {
+            results.integrations.github_mcp = {
+                status: "failed",
+                error: `GitHub MCP check failed: ${error}`,
+                method: "mcp"
+            };
+            results.summary.failed++;
+        }
+        results.summary.total++;
+        // Check Doppler CLI
+        try {
+            const { stdout: dopplerVersion } = await execAsync("doppler --version", {
+                timeout: 5000
+            });
+            results.integrations.doppler = {
+                status: "healthy",
+                version: dopplerVersion.trim(),
+                method: "cli"
+            };
+            results.summary.healthy++;
+        }
+        catch (error) {
+            results.integrations.doppler = {
+                status: "failed",
+                error: `Doppler CLI not accessible: ${error}`,
+                method: "cli"
+            };
+            results.summary.failed++;
+        }
+        results.summary.total++;
+        // Add verbose details if requested
+        if (verbose) {
+            results.integrations.system_info = {
+                platform: process.platform,
+                node_version: process.version,
+                environment_vars: {
+                    GITHUB_TOKEN: process.env.GITHUB_TOKEN ? 'set' : 'not_set',
+                    DOPPLER_TOKEN: process.env.DOPPLER_TOKEN ? 'set' : 'not_set'
+                }
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(results, null, verbose ? 2 : 0),
+                },
+            ],
+        };
+    }
+    async run() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        console.error("Workspace MCP server running on stdio");
+        // Keep the process alive and handle graceful shutdown
+        process.on('SIGINT', () => {
+            console.error('Received SIGINT, shutting down gracefully...');
+            process.exit(0);
+        });
+        process.on('SIGTERM', () => {
+            console.error('Received SIGTERM, shutting down gracefully...');
+            process.exit(0);
+        });
+        // Prevent the process from exiting
+        process.stdin.resume();
+    }
+}
+const server = new WorkspaceMCPServer();
+server.run().catch(console.error);
+//# sourceMappingURL=index.js.map