devglow-mcp 0.9.0 → 1.0.1

package/build/index.js

@@ -1,206 +1,234 @@
 #!/usr/bin/env node
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createServer } from "node:http";
+import { createConnection } from "node:net";
+import { randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
 import { z } from "zod";
 import { loadProjects, loadAiProcesses, loadStatuses, loadExportedLogs, } from "./storage.js";
 import { startProject, stopProject, runProcess, stopProcess, exportLogs, } from "./deeplink.js";
-const server = new McpServer({
-    name: "devglow-mcp",
-    version: "0.1.0",
-}, {
-    instructions: [
-        "devglow is the user's local process manager (macOS menu bar app).",
-        "",
-        "## When starting a process",
-        "- Call `list_projects` first to check if the user already has a registered project.",
-        "- If found, use `start_project` (runs the user's registered command as-is).",
-        "- Only use `run_process` when no matching project exists.",
-        "",
-        "## Reading logs",
-        "- `get_logs` triggers a log export from DevGlow, waits briefly, then reads the file.",
-        "- If logs are empty, DevGlow may not have finished writing. Try again after a moment.",
-    ].join("\n"),
-});
-// ── Tool: list_projects ──
-server.registerTool("list_projects", {
-    title: "List all projects",
-    description: "List all registered user projects and AI temporary processes with their status.",
-    inputSchema: {},
-}, async () => {
-    const projects = loadProjects();
-    const aiProcesses = loadAiProcesses();
-    const statuses = loadStatuses();
-    const statusMap = new Map(statuses.map((s) => [s.id, s]));
-    let text = "";
-    if (projects.length > 0) {
-        text += "## Projects\n";
-        for (const p of projects) {
-            const status = statusMap.get(p.id);
-            const running = status?.running ? "running" : "stopped";
-            const pid = status?.pid ? ` (PID: ${status.pid})` : "";
-            const port = p.port ? ` :${p.port}` : "";
-            text += `- [${running}] ${p.name}${port}${pid} — ${p.command} (id: ${p.id})\n`;
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
+// --- Server factory ---
+// Each transport connection gets its own McpServer instance
+function createMcpServer() {
+    const server = new McpServer({
+        name: "devglow-mcp",
+        version: pkg.version,
+    }, {
+        instructions: [
+            "devglow is the user's local process manager (macOS menu bar app).",
+            "",
+            "## When starting a process",
+            "- Call `list_projects` first to check if the user already has a registered project.",
+            "- If found, use `start_project` (runs the user's registered command as-is).",
+            "- Only use `run_process` when no matching project exists.",
+            "",
+            "## Reading logs",
+            "- `get_logs` triggers a log export from DevGlow, waits briefly, then reads the file.",
+            "- If logs are empty, DevGlow may not have finished writing. Try again after a moment.",
+        ].join("\n"),
+    });
+    // ── Tool: list_projects ──
+    server.registerTool("list_projects", {
+        title: "List all projects",
+        description: "List all registered user projects and AI temporary processes with their status.",
+        inputSchema: {},
+    }, async () => {
+        const projects = await loadProjects();
+        const aiProcesses = await loadAiProcesses();
+        const statuses = await loadStatuses();
+        const statusMap = new Map(statuses.map((s) => [s.id, s]));
+        let text = "";
+        if (projects.length > 0) {
+            text += "## Projects\n";
+            for (const p of projects) {
+                const status = statusMap.get(p.id);
+                const running = status?.running ? "running" : "stopped";
+                const pid = status?.pid ? ` (PID: ${status.pid})` : "";
+                const port = p.port ? ` :${p.port}` : "";
+                text += `- [${running}] ${p.name}${port}${pid} — ${p.command} (id: ${p.id})\n`;
+            }
         }
-    }
-    if (aiProcesses.length > 0) {
-        text += "\n## AI Processes\n";
-        for (const p of aiProcesses) {
-            const status = statusMap.get(p.id);
-            const running = status?.running ? "running" : "stopped";
-            const pid = status?.pid ? ` (PID: ${status.pid})` : "";
-            const port = p.port ? ` :${p.port}` : "";
-            text += `- [${running}] ${p.name}${port}${pid} — ${p.command} [${p.source}] (id: ${p.id})\n`;
+        if (aiProcesses.length > 0) {
+            text += "\n## AI Processes\n";
+            for (const p of aiProcesses) {
+                const status = statusMap.get(p.id);
+                const running = status?.running ? "running" : "stopped";
+                const pid = status?.pid ? ` (PID: ${status.pid})` : "";
+                const port = p.port ? ` :${p.port}` : "";
+                text += `- [${running}] ${p.name}${port}${pid} — ${p.command} [${p.source}] (id: ${p.id})\n`;
+            }
+        }
+        if (!text) {
+            text = "No projects or AI processes registered.";
+        }
+        return { content: [{ type: "text", text }] };
+    });
+    // ── Tool: get_status ──
+    server.registerTool("get_status", {
+        title: "Get project status",
+        description: "Get the running status of a specific project or AI process.",
+        inputSchema: {
+            id: z.string().describe("Project or AI process ID"),
+        },
+    }, async ({ id }) => {
+        const statuses = await loadStatuses();
+        const status = statuses.find((s) => s.id === id);
+        if (!status) {
+            return {
+                content: [{ type: "text", text: `No status found for ID: ${id}` }],
+            };
+        }
+        const text = `ID: ${status.id}\nRunning: ${status.running}\nPID: ${status.pid ?? "N/A"}\nSource: ${status.source}`;
+        return { content: [{ type: "text", text }] };
+    });
+    // ── Tool: get_logs ──
+    server.registerTool("get_logs", {
+        title: "Get process logs",
+        description: "Export and retrieve recent logs from a running or stopped process.",
+        inputSchema: {
+            id: z.string().describe("Project or AI process ID"),
+            lines: z
+                .number()
+                .optional()
+                .describe("Number of recent lines to return (default: 100)"),
+        },
+    }, async ({ id, lines }) => {
+        // Trigger log export via deep link
+        await exportLogs(id);
+        // Retry up to 5 times (100ms intervals) to read exported logs
+        const limit = lines ?? 100;
+        let recent = [];
+        for (let i = 0; i < 5; i++) {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            const logs = await loadExportedLogs(id);
+            recent = logs.slice(-limit);
+            if (recent.length > 0)
+                break;
+        }
+        if (recent.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No logs found for ID: ${id}. The process may not have produced output yet.`,
+                    },
+                ],
+            };
+        }
+        const text = recent
+            .map((l) => `[${l.timestamp}] [${l.level}] ${l.message}`)
+            .join("\n");
+        return { content: [{ type: "text", text }] };
+    });
+    // ── Tool: check_port ──
+    server.registerTool("check_port", {
+        title: "Check port availability",
+        description: "Check if a TCP port is in use on localhost.",
+        inputSchema: {
+            port: z.number().describe("Port number to check"),
+        },
+    }, async ({ port }) => {
+        const inUse = await checkPort(port);
+        const text = inUse
+            ? `Port ${port} is in use.`
+            : `Port ${port} is available.`;
+        return { content: [{ type: "text", text }] };
+    });
+    // ── Tool: start_project ──
+    server.registerTool("start_project", {
+        title: "Start a registered project",
+        description: "Start a user-registered project using its configured command. Cannot modify the command.",
+        inputSchema: {
+            id: z.string().describe("Project ID (from list_projects)"),
+        },
+    }, async ({ id }) => {
+        const projects = await loadProjects();
+        const project = projects.find((p) => p.id === id);
+        if (!project) {
+            return {
+                content: [{ type: "text", text: `Project not found: ${id}` }],
+            };
+        }
+        await startProject(id);
+        // Retry up to 5 times (200ms intervals) to check if started
+        let running = "may still be starting";
+        for (let i = 0; i < 5; i++) {
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            const statuses = await loadStatuses();
+            const status = statuses.find((s) => s.id === id);
+            if (status?.running) {
+                running = "started";
+                break;
+            }
         }
-    }
-    if (!text) {
-        text = "No projects or AI processes registered.";
-    }
-    return { content: [{ type: "text", text }] };
-});
-// ── Tool: get_status ──
-server.registerTool("get_status", {
-    title: "Get project status",
-    description: "Get the running status of a specific project or AI process.",
-    inputSchema: {
-        id: z.string().describe("Project or AI process ID"),
-    },
-}, async ({ id }) => {
-    const statuses = loadStatuses();
-    const status = statuses.find((s) => s.id === id);
-    if (!status) {
-        return {
-            content: [{ type: "text", text: `No status found for ID: ${id}` }],
-        };
-    }
-    const text = `ID: ${status.id}\nRunning: ${status.running}\nPID: ${status.pid ?? "N/A"}\nSource: ${status.source}`;
-    return { content: [{ type: "text", text }] };
-});
-// ── Tool: get_logs ──
-server.registerTool("get_logs", {
-    title: "Get process logs",
-    description: "Export and retrieve recent logs from a running or stopped process.",
-    inputSchema: {
-        id: z.string().describe("Project or AI process ID"),
-        lines: z
-            .number()
-            .optional()
-            .describe("Number of recent lines to return (default: 100)"),
-    },
-}, async ({ id, lines }) => {
-    // Trigger log export via deep link
-    await exportLogs(id);
-    // Wait for DevGlow to write the file
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    const logs = loadExportedLogs(id);
-    const limit = lines ?? 100;
-    const recent = logs.slice(-limit);
-    if (recent.length === 0) {
         return {
             content: [
                 {
                     type: "text",
-                    text: `No logs found for ID: ${id}. The process may not have produced output yet.`,
+                    text: `Project "${project.name}" ${running}. Command: ${project.command}`,
                 },
             ],
         };
-    }
-    const text = recent
-        .map((l) => `[${l.timestamp}] [${l.level}] ${l.message}`)
-        .join("\n");
-    return { content: [{ type: "text", text }] };
-});
-// ── Tool: check_port ──
-server.registerTool("check_port", {
-    title: "Check port availability",
-    description: "Check if a TCP port is in use on localhost.",
-    inputSchema: {
-        port: z.number().describe("Port number to check"),
-    },
-}, async ({ port }) => {
-    const inUse = await checkPort(port);
-    const text = inUse
-        ? `Port ${port} is in use.`
-        : `Port ${port} is available.`;
-    return { content: [{ type: "text", text }] };
-});
-// ── Tool: start_project ──
-server.registerTool("start_project", {
-    title: "Start a registered project",
-    description: "Start a user-registered project using its configured command. Cannot modify the command.",
-    inputSchema: {
-        id: z.string().describe("Project ID (from list_projects)"),
-    },
-}, async ({ id }) => {
-    const projects = loadProjects();
-    const project = projects.find((p) => p.id === id);
-    if (!project) {
+    });
+    // ── Tool: stop_project ──
+    server.registerTool("stop_project", {
+        title: "Stop a project",
+        description: "Stop a running project or AI process.",
+        inputSchema: {
+            id: z.string().describe("Project or AI process ID"),
+        },
+    }, async ({ id }) => {
+        await stopProject(id);
         return {
-            content: [{ type: "text", text: `Project not found: ${id}` }],
+            content: [{ type: "text", text: `Stop signal sent for: ${id}` }],
         };
-    }
-    await startProject(id);
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-    const statuses = loadStatuses();
-    const status = statuses.find((s) => s.id === id);
-    const running = status?.running ? "started" : "may still be starting";
-    return {
-        content: [
-            {
-                type: "text",
-                text: `Project "${project.name}" ${running}. Command: ${project.command}`,
-            },
-        ],
-    };
-});
-// ── Tool: stop_project ──
-server.registerTool("stop_project", {
-    title: "Stop a project",
-    description: "Stop a running project or AI process.",
-    inputSchema: {
-        id: z.string().describe("Project or AI process ID"),
-    },
-}, async ({ id }) => {
-    await stopProject(id);
-    return {
-        content: [{ type: "text", text: `Stop signal sent for: ${id}` }],
-    };
-});
-// ── Tool: run_process ──
-server.registerTool("run_process", {
-    title: "Run a new AI process",
-    description: "Create and start a new temporary process. Shows in DevGlow's AI Processes section. User can later [keep] or [dismiss] it.",
-    inputSchema: {
-        name: z.string().describe("Display name for the process"),
-        path: z.string().describe("Working directory (supports ~/)"),
-        command: z.string().describe("Shell command to execute"),
-        port: z
-            .number()
-            .optional()
-            .describe("Port number the process will listen on. Check package.json scripts or config files for --port flags. Important for DevGlow to show the correct port badge."),
-    },
-}, async ({ name, path, command, port }) => {
-    // Auto-detect port from command if not explicitly provided
-    const resolvedPort = port ?? detectPortFromCommand(command);
-    await runProcess(name, path, command, resolvedPort, "claude");
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-    const text = `AI process "${name}" started.\nCommand: ${command}\nPath: ${path}${resolvedPort ? `\nPort: ${resolvedPort}` : ""}`;
-    return { content: [{ type: "text", text }] };
-});
-// ── Tool: stop_process ──
-server.registerTool("stop_process", {
-    title: "Stop an AI process",
-    description: "Stop a running AI temporary process by name.",
-    inputSchema: {
-        name: z.string().describe("AI process name"),
-    },
-}, async ({ name }) => {
-    await stopProcess(name);
-    return {
-        content: [
-            { type: "text", text: `Stop signal sent for AI process: "${name}"` },
-        ],
-    };
-});
+    });
+    // ── Tool: run_process ──
+    server.registerTool("run_process", {
+        title: "Run a new AI process",
+        description: "Create and start a new temporary process. Shows in DevGlow's AI Processes section. User can later [keep] or [dismiss] it.",
+        inputSchema: {
+            name: z.string().describe("Display name for the process"),
+            path: z.string().describe("Working directory (supports ~/)"),
+            command: z.string().describe("Shell command to execute"),
+            port: z
+                .number()
+                .optional()
+                .describe("Port number the process will listen on. Check package.json scripts or config files for --port flags. Important for DevGlow to show the correct port badge."),
+        },
+    }, async ({ name, path, command, port }) => {
+        // Auto-detect port from command if not explicitly provided
+        const resolvedPort = port ?? detectPortFromCommand(command);
+        await runProcess(name, path, command, resolvedPort, "claude");
+        // Brief wait for DevGlow to register the process
+        await new Promise((resolve) => setTimeout(resolve, 300));
+        const text = `AI process "${name}" started.\nCommand: ${command}\nPath: ${path}${resolvedPort ? `\nPort: ${resolvedPort}` : ""}`;
+        return { content: [{ type: "text", text }] };
+    });
+    // ── Tool: stop_process ──
+    server.registerTool("stop_process", {
+        title: "Stop an AI process",
+        description: "Stop a running AI temporary process by name.",
+        inputSchema: {
+            name: z.string().describe("AI process name"),
+        },
+    }, async ({ name }) => {
+        await stopProcess(name);
+        return {
+            content: [
+                { type: "text", text: `Stop signal sent for AI process: "${name}"` },
+            ],
+        };
+    });
+    return server;
+}
 // ── Utility ──
 function detectPortFromCommand(command) {
     // Match patterns: --port 3000, --port=3000, -p 3000, -p=3000
@@ -211,7 +239,6 @@ function detectPortFromCommand(command) {
 }
 function checkPort(port) {
     return new Promise((resolve) => {
-        const { createConnection } = require("net");
         const socket = createConnection({ port, host: "127.0.0.1" });
         socket.setTimeout(1000);
         socket.on("connect", () => {
@@ -227,11 +254,157 @@ function checkPort(port) {
         });
     });
 }
+// ── Args ──
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let transport = "stdio";
+    let port = 26215;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--transport" && args[i + 1]) {
+            const value = args[i + 1];
+            // "sse" is an alias for "http" (backwards compat)
+            transport = value === "sse" || value === "http" ? "http" : "stdio";
+            i++;
+        }
+        else if (args[i] === "--port" && args[i + 1]) {
+            port = parseInt(args[i + 1], 10);
+            i++;
+        }
+    }
+    return { transport, port };
+}
 // ── Main ──
 async function main() {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    console.error("devglow MCP server running on stdio");
+    const { transport: mode, port } = parseArgs();
+    if (mode === "http") {
+        const sseTransports = new Map();
+        const streamableTransports = new Map();
+        const httpServer = createServer(async (req, res) => {
+            try {
+                const url = new URL(req.url || "", `http://localhost:${port}`);
+                // CORS headers
+                res.setHeader("Access-Control-Allow-Origin", "*");
+                res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+                res.setHeader("Access-Control-Allow-Headers", "Content-Type, mcp-session-id");
+                if (req.method === "OPTIONS") {
+                    res.writeHead(204);
+                    res.end();
+                    return;
+                }
+                // --- Streamable HTTP: /mcp ---
+                if (url.pathname === "/mcp") {
+                    const sessionId = req.headers["mcp-session-id"];
+                    if (sessionId && streamableTransports.has(sessionId)) {
+                        const transport = streamableTransports.get(sessionId);
+                        await transport.handleRequest(req, res, await parseBody(req));
+                        return;
+                    }
+                    if (!sessionId && req.method === "POST") {
+                        const transport = new StreamableHTTPServerTransport({
+                            sessionIdGenerator: () => randomUUID(),
+                            onsessioninitialized: (sid) => {
+                                streamableTransports.set(sid, transport);
+                            },
+                        });
+                        transport.onclose = () => {
+                            const sid = transport.sessionId;
+                            if (sid)
+                                streamableTransports.delete(sid);
+                        };
+                        const mcpServer = createMcpServer();
+                        await mcpServer.connect(transport);
+                        await transport.handleRequest(req, res, await parseBody(req));
+                        return;
+                    }
+                    res.writeHead(400, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "Bad request" }));
+                    return;
+                }
+                // --- SSE (legacy): /sse + /messages ---
+                if (req.method === "GET" && url.pathname === "/sse") {
+                    const sseTransport = new SSEServerTransport("/messages", res);
+                    sseTransports.set(sseTransport.sessionId, sseTransport);
+                    res.on("close", () => {
+                        sseTransports.delete(sseTransport.sessionId);
+                    });
+                    const mcpServer = createMcpServer();
+                    await mcpServer.connect(sseTransport);
+                    return;
+                }
+                if (req.method === "POST" && url.pathname === "/messages") {
+                    const sessionId = url.searchParams.get("sessionId");
+                    const sseTransport = sessionId
+                        ? sseTransports.get(sessionId)
+                        : undefined;
+                    if (!sseTransport) {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "No transport found for sessionId" }));
+                        return;
+                    }
+                    await sseTransport.handlePostMessage(req, res, await parseBody(req));
+                    return;
+                }
+                res.writeHead(404, { "Content-Type": "text/plain" });
+                res.end("Not found");
+            }
+            catch (err) {
+                if (!res.headersSent) {
+                    const status = err instanceof Error && err.message === "Request body too large" ? 413 : 500;
+                    res.writeHead(status, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err instanceof Error ? err.message : "Internal server error" }));
+                }
+            }
+        });
+        httpServer.listen(port, () => {
+            console.error(`devglow MCP server running on http://localhost:${port}\n` +
+                `  Streamable HTTP: http://localhost:${port}/mcp\n` +
+                `  SSE (legacy):    http://localhost:${port}/sse`);
+        });
+        process.on("SIGINT", async () => {
+            for (const [, t] of sseTransports) {
+                try {
+                    await t.close();
+                }
+                catch { }
+            }
+            for (const [, t] of streamableTransports) {
+                try {
+                    await t.close();
+                }
+                catch { }
+            }
+            httpServer.close();
+            process.exit(0);
+        });
+    }
+    else {
+        // stdio: single connection, single server
+        const mcpServer = createMcpServer();
+        const transport = new StdioServerTransport();
+        await mcpServer.connect(transport);
+        console.error("devglow MCP server running on stdio");
+    }
+}
+const MAX_BODY_SIZE = 1024 * 1024; // 1MB
+function parseBody(req) {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        req.on("data", (chunk) => {
+            data += chunk;
+            if (data.length > MAX_BODY_SIZE) {
+                req.destroy();
+                reject(new Error("Request body too large"));
+            }
+        });
+        req.on("end", () => {
+            try {
+                resolve(JSON.parse(data));
+            }
+            catch {
+                resolve(undefined);
+            }
+        });
+    });
 }
 main().catch((error) => {
     console.error("Fatal error:", error);

package/build/storage.js

@@ -1,41 +1,41 @@
-import { readFileSync } from "fs";
+import { readFile } from "fs/promises";
 import { join } from "path";
 import { homedir } from "os";
 const DATA_DIR = join(homedir(), "Library", "Application Support", "app.devglow.macos");
 const TMP_DIR = join(DATA_DIR, "tmp");
 // ── File readers ──
-function readJsonFile(filename, fallback) {
+async function readJsonFile(filename, fallback) {
     try {
         const filePath = join(DATA_DIR, filename);
-        const content = readFileSync(filePath, "utf-8");
+        const content = await readFile(filePath, "utf-8");
         return JSON.parse(content);
     }
     catch {
         return fallback;
     }
 }
-export function loadProjects() {
-    const data = readJsonFile("projects.json", {
+export async function loadProjects() {
+    const data = await readJsonFile("projects.json", {
         projects: [],
     });
     return data.projects;
 }
-export function loadAiProcesses() {
-    const data = readJsonFile("ai_processes.json", {
+export async function loadAiProcesses() {
+    const data = await readJsonFile("ai_processes.json", {
         processes: [],
     });
     return data.processes;
 }
-export function loadStatuses() {
-    const data = readJsonFile("status.json", {
+export async function loadStatuses() {
+    const data = await readJsonFile("status.json", {
         statuses: [],
     });
     return data.statuses;
 }
-export function loadExportedLogs(projectId) {
+export async function loadExportedLogs(projectId) {
     try {
         const filePath = join(TMP_DIR, `logs-${projectId}.json`);
-        const content = readFileSync(filePath, "utf-8");
+        const content = await readFile(filePath, "utf-8");
         return JSON.parse(content);
     }
     catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devglow-mcp",
-  "version": "0.9.0",
+  "version": "1.0.1",
   "description": "MCP server for DevGlow — manage local dev processes through AI agents",
   "type": "module",
   "bin": {
@@ -14,6 +14,7 @@
     "dev": "tsc --watch"
   },
   "keywords": ["mcp", "devglow", "ai", "claude", "process-manager"],
+  "os": ["darwin"],
   "license": "MIT",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",