devglow-mcp 0.1.0

package/build/deeplink.js

@@ -0,0 +1,40 @@
+import { execFile } from "child_process";
+function openDeepLink(url) {
+    return new Promise((resolve, reject) => {
+        execFile("open", [url], (error) => {
+            if (error) {
+                reject(new Error(`Failed to open deep link: ${error.message}`));
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+}
+function buildUrl(action, params) {
+    const query = Object.entries(params)
+        .filter(([, v]) => v !== undefined && v !== "")
+        .map(([k, v]) => `${k}=${encodeURIComponent(v)}`)
+        .join("&");
+    return `devglow://${action}${query ? "?" + query : ""}`;
+}
+export async function startProject(id) {
+    await openDeepLink(buildUrl("start", { id }));
+}
+export async function stopProject(id) {
+    await openDeepLink(buildUrl("stop", { id }));
+}
+export async function runProcess(name, path, command, port, source) {
+    const params = { name, path, command };
+    if (port !== undefined)
+        params.port = String(port);
+    if (source)
+        params.source = source;
+    await openDeepLink(buildUrl("run", params));
+}
+export async function stopProcess(name) {
+    await openDeepLink(buildUrl("stop-process", { name }));
+}
+export async function exportLogs(id) {
+    await openDeepLink(buildUrl("export-logs", { id }));
+}

package/build/index.js

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+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`;
+        }
+    }
+    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) {
+        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: `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 (optional)"),
+    },
+}, async ({ name, path, command, port }) => {
+    await runProcess(name, path, command, port, "claude");
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    const text = `AI process "${name}" started.\nCommand: ${command}\nPath: ${path}${port ? `\nPort: ${port}` : ""}`;
+    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}"` },
+        ],
+    };
+});
+// ── Utility ──
+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", () => {
+            socket.destroy();
+            resolve(true);
+        });
+        socket.on("timeout", () => {
+            socket.destroy();
+            resolve(false);
+        });
+        socket.on("error", () => {
+            resolve(false);
+        });
+    });
+}
+// ── Main ──
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("devglow MCP server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/build/storage.js

@@ -0,0 +1,44 @@
+import { readFileSync } from "fs";
+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) {
+    try {
+        const filePath = join(DATA_DIR, filename);
+        const content = readFileSync(filePath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return fallback;
+    }
+}
+export function loadProjects() {
+    const data = readJsonFile("projects.json", {
+        projects: [],
+    });
+    return data.projects;
+}
+export function loadAiProcesses() {
+    const data = readJsonFile("ai_processes.json", {
+        processes: [],
+    });
+    return data.processes;
+}
+export function loadStatuses() {
+    const data = readJsonFile("status.json", {
+        statuses: [],
+    });
+    return data.statuses;
+}
+export function loadExportedLogs(projectId) {
+    try {
+        const filePath = join(TMP_DIR, `logs-${projectId}.json`);
+        const content = readFileSync(filePath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return [];
+    }
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "devglow-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for DevGlow — manage local dev processes through AI agents",
+  "type": "module",
+  "bin": {
+    "devglow-mcp": "build/index.js"
+  },
+  "files": [
+    "build"
+  ],
+  "scripts": {
+    "build": "tsc && chmod 755 build/index.js",
+    "dev": "tsc --watch"
+  },
+  "keywords": ["mcp", "devglow", "ai", "claude", "process-manager"],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.2",
+    "typescript": "^5.9.3"
+  }
+}