devglow-mcp 0.2.1 → 1.0.0

package/build/deeplink.js

@@ -1,7 +1,7 @@
 import { execFile } from "child_process";
 function openDeepLink(url) {
     return new Promise((resolve, reject) => {
-        execFile("open", [url], (error) => {
+        execFile("open", ["-g", url], (error) => {
             if (error) {
                 reject(new Error(`Failed to open deep link: ${error.message}`));
             }

package/build/index.js

@@ -1,206 +1,215 @@
 #!/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 { randomUUID } from "node:crypto";
 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`;
+// --- Server factory ---
+// Each transport connection gets its own McpServer instance
+function createMcpServer() {
+    const server = new McpServer({
+        name: "devglow-mcp",
+        version: "1.0.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`;
+            }
         }
-    }
-    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 = 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) {
+        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.`,
+                    },
+                ],
+            };
+        }
+        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) {
+            return {
+                content: [{ type: "text", text: `Project not found: ${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: `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");
+        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}"` },
+            ],
+        };
+    });
+    return server;
+}
 // ── Utility ──
 function detectPortFromCommand(command) {
     // Match patterns: --port 3000, --port=3000, -p 3000, -p=3000
@@ -227,11 +236,133 @@ 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) => {
+            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);
+            res.end("Not found");
+        });
+        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)
+                await t.close();
+            for (const [, t] of streamableTransports)
+                await t.close();
+            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");
+    }
+}
+function parseBody(req) {
+    return new Promise((resolve) => {
+        let data = "";
+        req.on("data", (chunk) => (data += chunk));
+        req.on("end", () => {
+            try {
+                resolve(JSON.parse(data));
+            }
+            catch {
+                resolve(undefined);
+            }
+        });
+    });
 }
 main().catch((error) => {
     console.error("Fatal error:", error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devglow-mcp",
-  "version": "0.2.1",
+  "version": "1.0.0",
   "description": "MCP server for DevGlow — manage local dev processes through AI agents",
   "type": "module",
   "bin": {