devglow-mcp 1.0.0 → 1.0.3

package/build/index.js

@@ -4,16 +4,25 @@ 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 __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
+// --- Orphan process prevention constants ---
+const IDLE_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
+const IDLE_CHECK_INTERVAL_MS = 60 * 1000; // Check every 1 minute
 // --- Server factory ---
 // Each transport connection gets its own McpServer instance
 function createMcpServer() {
     const server = new McpServer({
         name: "devglow-mcp",
-        version: "1.0.0",
+        version: pkg.version,
     }, {
         instructions: [
             "devglow is the user's local process manager (macOS menu bar app).",
@@ -34,9 +43,9 @@ function createMcpServer() {
         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 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) {
@@ -72,7 +81,7 @@ function createMcpServer() {
             id: z.string().describe("Project or AI process ID"),
         },
     }, async ({ id }) => {
-        const statuses = loadStatuses();
+        const statuses = await loadStatuses();
         const status = statuses.find((s) => s.id === id);
         if (!status) {
             return {
@@ -96,11 +105,16 @@ function createMcpServer() {
     }, 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);
+        // Retry up to 5 times (100ms intervals) to read exported logs
         const limit = lines ?? 100;
-        const recent = logs.slice(-limit);
+        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: [
@@ -138,7 +152,7 @@ function createMcpServer() {
             id: z.string().describe("Project ID (from list_projects)"),
         },
     }, async ({ id }) => {
-        const projects = loadProjects();
+        const projects = await loadProjects();
         const project = projects.find((p) => p.id === id);
         if (!project) {
             return {
@@ -146,10 +160,17 @@ function createMcpServer() {
             };
         }
         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";
+        // 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;
+            }
+        }
         return {
             content: [
                 {
@@ -177,7 +198,7 @@ function createMcpServer() {
         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"),
+            name: z.string().describe("Display name for the process. Do NOT include port number in the name — use the port parameter instead."),
             path: z.string().describe("Working directory (supports ~/)"),
             command: z.string().describe("Shell command to execute"),
             port: z
@@ -189,7 +210,8 @@ function createMcpServer() {
         // 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));
+        // 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 }] };
     });
@@ -220,7 +242,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", () => {
@@ -262,71 +283,80 @@ async function main() {
         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));
+            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;
                 }
-                if (!sessionId && req.method === "POST") {
-                    const transport = new StreamableHTTPServerTransport({
-                        sessionIdGenerator: () => randomUUID(),
-                        onsessioninitialized: (sid) => {
-                            streamableTransports.set(sid, transport);
-                        },
+                // --- 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);
                     });
-                    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));
+                    await mcpServer.connect(sseTransport);
                     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" }));
+                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;
                 }
-                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" }));
+                }
             }
-            res.writeHead(404);
-            res.end("Not found");
         });
         httpServer.listen(port, () => {
             console.error(`devglow MCP server running on http://localhost:${port}\n` +
@@ -334,10 +364,18 @@ async function main() {
                 `  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();
+            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);
         });
@@ -348,12 +386,52 @@ async function main() {
         const transport = new StdioServerTransport();
         await mcpServer.connect(transport);
         console.error("devglow MCP server running on stdio");
+        // --- Orphan process prevention (stdio mode) ---
+        // When Claude Code exits abnormally, the npx → npm → node chain
+        // may not propagate stdin pipe close properly, leaving this process orphaned.
+        let lastActivityTime = Date.now();
+        let exiting = false;
+        let idleTimer;
+        function gracefulExit(reason) {
+            if (exiting)
+                return;
+            exiting = true;
+            console.error(`devglow-mcp: ${reason}, shutting down`);
+            clearInterval(idleTimer);
+            try {
+                mcpServer.close();
+            }
+            catch { }
+            process.exit(0);
+        }
+        // Track incoming messages for idle detection
+        process.stdin.on("data", () => {
+            lastActivityTime = Date.now();
+        });
+        // 1st defense: detect stdin pipe close (parent process gone)
+        process.stdin.resume();
+        process.stdin.on("end", () => gracefulExit("stdin ended"));
+        process.stdin.on("close", () => gracefulExit("stdin closed"));
+        // 2nd defense: idle timeout (no messages for 30 min)
+        idleTimer = setInterval(() => {
+            if (Date.now() - lastActivityTime >= IDLE_TIMEOUT_MS) {
+                gracefulExit(`idle timeout (${IDLE_TIMEOUT_MS / 60_000}m)`);
+            }
+        }, IDLE_CHECK_INTERVAL_MS);
+        idleTimer.unref();
     }
 }
+const MAX_BODY_SIZE = 1024 * 1024; // 1MB
 function parseBody(req) {
-    return new Promise((resolve) => {
+    return new Promise((resolve, reject) => {
         let data = "";
-        req.on("data", (chunk) => (data += chunk));
+        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));

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": "1.0.0",
+  "version": "1.0.3",
   "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",