agent-enderun 0.9.4 → 1.0.0

package/framework-mcp/dist/index.js

@@ -1,257 +1,32 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import fs from "fs";
-import path from "path";
-import { execSync } from "child_process";
+import { TOOLS, toolHandlers } from "./tools/index.js";
+// ─── Server Setup ─────────────────────────────────────────────────
 const server = new Server({
-    name: "agent-enderun-mcp",
-    version: "0.9.4",
+    name: "agent-enderun",
+    version: "1.0.0",
 }, {
     capabilities: {
         tools: {},
     },
 });
-const TOOLS = [
-    {
-        name: "read_file",
-        description: "Read the content of a file within the project.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: { type: "string", description: "Path to the file relative to project root" },
-            },
-            required: ["path"],
-        },
-    },
-    {
-        name: "write_file",
-        description: "Write content to a file. Creates directories if missing.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: { type: "string", description: "Path to the file relative to project root" },
-                content: { type: "string", description: "Complete content of the file" },
-            },
-            required: ["path", "content"],
-        },
-    },
-    {
-        name: "replace_text",
-        description: "Surgically replace a string in a file with another string.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: { type: "string", description: "Path to the file" },
-                oldText: { type: "string", description: "The exact text to find" },
-                newText: { type: "string", description: "The text to replace it with" },
-            },
-            required: ["path", "oldText", "newText"],
-        },
-    },
-    {
-        name: "patch_file",
-        description: "Safely update a file by replacing a specific line range with new content.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: { type: "string", description: "Path to the file" },
-                startLine: { type: "number", description: "Starting line number (1-indexed)" },
-                endLine: { type: "number", description: "Ending line number (inclusive)" },
-                newContent: { type: "string", description: "The new lines to insert" },
-            },
-            required: ["path", "startLine", "endLine", "newContent"],
-        },
-    },
-    {
-        name: "get_framework_status",
-        description: "Get the current project phase, active traces, and agent states.",
-        inputSchema: { type: "object", properties: {} },
-    },
-    {
-        name: "update_project_memory",
-        description: "Update a specific section in PROJECT_MEMORY.md.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                section: { type: "string", description: "Section name (e.g., HISTORY, ACTIVE TASKS)" },
-                content: { type: "string", description: "Markdown content to append or set" },
-            },
-            required: ["section", "content"],
-        },
-    },
-    {
-        name: "orchestrate_loop",
-        description: "Process the pending Hermes messages and trigger dynamic state transitions.",
-        inputSchema: { type: "object", properties: {} },
-    },
-    {
-        name: "send_agent_message",
-        description: "Send a Hermes protocol message to another agent.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                to: { type: "string", description: "Target agent (e.g., @backend, @qa)" },
-                category: { type: "string", enum: ["ACTION", "DELEGATION", "INFO", "ALERT"] },
-                content: { type: "string", description: "Message content" },
-                traceId: { type: "string", description: "Active Trace ID" },
-            },
-            required: ["to", "category", "content", "traceId"],
-        },
-    },
-    {
-        name: "log_agent_action",
-        description: "Log an agent action to the framework logs.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                agent: { type: "string", description: "The agent name (e.g., @manager, @backend)" },
-                action: { type: "string", description: "Action type or name" },
-                traceId: { type: "string", description: "The active Trace ID" },
-                status: { type: "string", enum: ["SUCCESS", "FAILURE"], description: "The status of the action" },
-                summary: { type: "string", description: "Brief description of the action taken" },
-                findings: { type: "array", items: { type: "string" }, description: "Optional findings or details" }
-            },
-            required: ["agent", "action", "traceId", "status", "summary"]
-        }
-    },
-    {
-        name: "update_contract_hash",
-        description: "Re-generate and synchronize the backend contract SHA-256 hash.",
-        inputSchema: { type: "object", properties: {} }
-    }
-];
-server.onRequest(ListToolsRequestSchema, async () => {
+server.setRequestHandler(ListToolsRequestSchema, async () => {
     return { tools: TOOLS };
 });
-server.onRequest(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    const projectRoot = process.cwd();
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const typedRequest = request;
+    const { name, arguments: args } = typedRequest.params;
+    const projectRoot = process.env.ENDERUN_PROJECT_ROOT || process.cwd();
     try {
-        switch (name) {
-            case "read_file": {
-                const filePath = path.join(projectRoot, args?.path);
-                const content = fs.readFileSync(filePath, "utf8");
-                return { content: [{ type: "text", text: content }] };
-            }
-            case "write_file": {
-                const filePath = path.join(projectRoot, args?.path);
-                fs.mkdirSync(path.dirname(filePath), { recursive: true });
-                fs.writeFileSync(filePath, args?.content);
-                return { content: [{ type: "text", text: `✅ File written: ${args?.path}` }] };
-            }
-            case "replace_text": {
-                const filePath = path.join(projectRoot, args?.path);
-                let content = fs.readFileSync(filePath, "utf8");
-                const oldText = args?.oldText;
-                const newText = args?.newText;
-                if (!content.includes(oldText)) {
-                    throw new Error(`Text not found in file: ${oldText}`);
-                }
-                content = content.replace(oldText, newText);
-                fs.writeFileSync(filePath, content);
-                return { content: [{ type: "text", text: `✅ Surgical edit successful in ${args?.path}` }] };
-            }
-            case "patch_file": {
-                const filePath = path.join(projectRoot, args?.path);
-                const lines = fs.readFileSync(filePath, "utf8").split("\n");
-                const start = args?.startLine - 1;
-                const end = args?.endLine;
-                const newContent = (args?.newContent).split("\n");
-                if (start < 0 || start > lines.length)
-                    throw new Error("Invalid start line.");
-                lines.splice(start, end - start, ...newContent);
-                fs.writeFileSync(filePath, lines.join("\n"));
-                return { content: [{ type: "text", text: `✅ File patched successfully: ${args?.path}` }] };
-            }
-            case "get_framework_status": {
-                const output = execSync("npx agent-enderun status").toString();
-                return { content: [{ type: "text", text: output }] };
-            }
-            case "update_project_memory": {
-                const section = args?.section;
-                const content = args?.content;
-                // Escape quotes for shell
-                const safeContent = content.replace(/"/g, "\\\"");
-                execSync(`npx agent-enderun update_project_memory "${section}" "${safeContent}"`);
-                return { content: [{ type: "text", text: `✅ Section ${section} updated.` }] };
-            }
-            case "orchestrate_loop": {
-                const output = execSync("npx agent-enderun orchestrate").toString();
-                return { content: [{ type: "text", text: output }] };
-            }
-            case "send_agent_message": {
-                const { to, category, content, traceId } = args;
-                const candidates = [
-                    ".gemini/antigravity",
-                    ".gemini/antigravity-cli",
-                    ".gemini",
-                    ".claude",
-                    ".grok",
-                    ".agent",
-                    ".enderun",
-                ];
-                let frameworkDir = ".gemini";
-                for (const c of candidates) {
-                    if (fs.existsSync(path.join(projectRoot, c))) {
-                        frameworkDir = c;
-                        break;
-                    }
-                }
-                const messagePath = path.join(projectRoot, frameworkDir, "messages", `${to.replace("@", "")}.json`);
-                const message = {
-                    timestamp: new Date().toISOString(),
-                    from: "@mcp",
-                    to,
-                    category,
-                    traceId,
-                    content,
-                    status: "PENDING"
-                };
-                fs.mkdirSync(path.dirname(messagePath), { recursive: true });
-                fs.appendFileSync(messagePath, JSON.stringify(message) + "\n");
-                return { content: [{ type: "text", text: `✅ Message sent to ${to}` }] };
-            }
-            case "log_agent_action": {
-                const { agent, action, traceId, status, summary, findings } = args;
-                const candidates = [
-                    ".gemini/antigravity",
-                    ".gemini/antigravity-cli",
-                    ".gemini",
-                    ".claude",
-                    ".grok",
-                    ".agent",
-                    ".enderun",
-                ];
-                let frameworkDir = ".enderun";
-                for (const c of candidates) {
-                    if (fs.existsSync(path.join(projectRoot, c))) {
-                        frameworkDir = c;
-                        break;
-                    }
-                }
-                const agentName = agent.replace("@", "");
-                const logPath = path.join(projectRoot, frameworkDir, "logs", `${agentName}.json`);
-                const logEntry = {
-                    timestamp: new Date().toISOString(),
-                    agent,
-                    action,
-                    requestId: traceId,
-                    status,
-                    summary,
-                    findings: findings || []
-                };
-                fs.mkdirSync(path.dirname(logPath), { recursive: true });
-                fs.appendFileSync(logPath, JSON.stringify(logEntry) + "\n");
-                return { content: [{ type: "text", text: `✅ Action logged for ${agent} to ${path.join(frameworkDir, "logs", `${agentName}.json`)}` }] };
-            }
-            case "update_contract_hash": {
-                const output = execSync("npx agent-enderun update-contract").toString();
-                return { content: [{ type: "text", text: output }] };
-            }
-            default:
-                throw new Error(`Unknown tool: ${name}`);
+        const handler = toolHandlers[name];
+        if (!handler) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Unknown tool: ${name}` }],
+            };
         }
+        return handler(projectRoot, args || {});
     }
     catch (error) {
         const message = error instanceof Error ? error.message : "Unknown error occurred";
@@ -261,8 +36,35 @@ server.onRequest(CallToolRequestSchema, async (request) => {
         };
     }
 });
+// ─── Graceful Startup & Shutdown ──────────────────────────────────
 async function run() {
     const transport = new StdioServerTransport();
+    // Prevent unhandled errors from crashing the MCP stream
+    process.on("uncaughtException", (error) => {
+        process.stderr.write(`[agent-enderun-mcp] Uncaught exception: ${error.message}
+`);
+    });
+    process.on("unhandledRejection", (reason) => {
+        const message = reason instanceof Error ? reason.message : String(reason);
+        process.stderr.write(`[agent-enderun-mcp] Unhandled rejection: ${message}
+`);
+    });
+    // Graceful shutdown on SIGINT/SIGTERM
+    const shutdown = async () => {
+        try {
+            await server.close();
+        }
+        catch {
+            // Already closed or failed — safe to ignore
+        }
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
     await server.connect(transport);
 }
-run().catch(console.error);
+run().catch((error) => {
+    process.stderr.write(`[agent-enderun-mcp] Fatal startup error: ${error.message}
+`);
+    process.exit(1);
+});

package/framework-mcp/dist/tools/definitions.js

@@ -0,0 +1,109 @@
+export const TOOLS = [
+    {
+        name: "read_file",
+        description: "Read the content of a file within the project.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the file relative to project root" },
+            },
+            required: ["path"],
+        },
+    },
+    {
+        name: "write_file",
+        description: "Write content to a file. Creates directories if missing.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the file relative to project root" },
+                content: { type: "string", description: "Complete content of the file" },
+            },
+            required: ["path", "content"],
+        },
+    },
+    {
+        name: "replace_text",
+        description: "Surgically replace a string in a file with another string.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the file" },
+                oldText: { type: "string", description: "The exact text to find" },
+                newText: { type: "string", description: "The text to replace it with" },
+            },
+            required: ["path", "oldText", "newText"],
+        },
+    },
+    {
+        name: "patch_file",
+        description: "Safely update a file by replacing a specific line range with new content.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the file" },
+                startLine: { type: "number", description: "Starting line number (1-indexed)" },
+                endLine: { type: "number", description: "Ending line number (inclusive)" },
+                newContent: { type: "string", description: "The new lines to insert" },
+            },
+            required: ["path", "startLine", "endLine", "newContent"],
+        },
+    },
+    {
+        name: "get_framework_status",
+        description: "Get the current project phase, active traces, and agent states.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "update_project_memory",
+        description: "Update a specific section in PROJECT_MEMORY.md.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                section: { type: "string", description: "Section name (e.g., HISTORY, ACTIVE TASKS)" },
+                content: { type: "string", description: "Markdown content to append or set" },
+            },
+            required: ["section", "content"],
+        },
+    },
+    {
+        name: "orchestrate_loop",
+        description: "Process the pending Hermes messages and trigger dynamic state transitions.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "send_agent_message",
+        description: "Send a Hermes protocol message to another agent.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                to: { type: "string", description: "Target agent (e.g., @backend, @qa)" },
+                category: { type: "string", enum: ["ACTION", "DELEGATION", "INFO", "ALERT"] },
+                content: { type: "string", description: "Message content" },
+                traceId: { type: "string", description: "Active Trace ID" },
+            },
+            required: ["to", "category", "content", "traceId"],
+        },
+    },
+    {
+        name: "log_agent_action",
+        description: "Log an agent action to the framework logs.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                agent: { type: "string", description: "The agent name (e.g., @manager, @backend)" },
+                action: { type: "string", description: "Action type or name" },
+                traceId: { type: "string", description: "The active Trace ID" },
+                status: { type: "string", enum: ["SUCCESS", "FAILURE"], description: "The status of the action" },
+                summary: { type: "string", description: "Brief description of the action taken" },
+                findings: { type: "string", description: "Optional comma-separated findings or details" }
+            },
+            required: ["agent", "action", "traceId", "status", "summary"]
+        }
+    },
+    {
+        name: "update_contract_hash",
+        description: "Re-generate and synchronize the backend contract SHA-256 hash.",
+        inputSchema: { type: "object", properties: {} }
+    }
+];

package/framework-mcp/dist/tools/file_system/patch_file.js

@@ -0,0 +1,18 @@
+import fs from "fs";
+import { safePath } from "../../utils/security.js";
+export function handlePatchFile(projectRoot, args) {
+    const filePath = safePath(projectRoot, args.path);
+    const lines = fs.readFileSync(filePath, "utf8").split("\n");
+    const start = args.startLine - 1;
+    const end = args.endLine;
+    const newContent = args.newContent.split("\n");
+    if (start < 0 || start > lines.length) {
+        throw new Error(`Invalid start line: ${start + 1}. File has ${lines.length} lines.`);
+    }
+    if (end < start + 1 || end > lines.length) {
+        throw new Error(`Invalid end line: ${end}. Must be between ${start + 1} and ${lines.length}.`);
+    }
+    lines.splice(start, end - start, ...newContent);
+    fs.writeFileSync(filePath, lines.join("\n"));
+    return { content: [{ type: "text", text: `✅ File patched successfully: ${args.path}` }] };
+}

package/framework-mcp/dist/tools/file_system/read_file.js

@@ -0,0 +1,7 @@
+import fs from "fs";
+import { safePath } from "../../utils/security.js";
+export function handleReadFile(projectRoot, args) {
+    const filePath = safePath(projectRoot, args.path);
+    const content = fs.readFileSync(filePath, "utf8");
+    return { content: [{ type: "text", text: content }] };
+}

package/framework-mcp/dist/tools/file_system/replace_text.js

@@ -0,0 +1,14 @@
+import fs from "fs";
+import { safePath } from "../../utils/security.js";
+export function handleReplaceText(projectRoot, args) {
+    const filePath = safePath(projectRoot, args.path);
+    let content = fs.readFileSync(filePath, "utf8");
+    const oldText = args.oldText;
+    const newText = args.newText;
+    if (!content.includes(oldText)) {
+        throw new Error(`Text not found in file: ${oldText.slice(0, 100)}...`);
+    }
+    content = content.replace(oldText, newText);
+    fs.writeFileSync(filePath, content);
+    return { content: [{ type: "text", text: `✅ Surgical edit successful in ${args.path}` }] };
+}

package/framework-mcp/dist/tools/file_system/write_file.js

@@ -0,0 +1,9 @@
+import fs from "fs";
+import path from "path";
+import { safePath } from "../../utils/security.js";
+export function handleWriteFile(projectRoot, args) {
+    const filePath = safePath(projectRoot, args.path);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, args.content);
+    return { content: [{ type: "text", text: `✅ File written: ${args.path}` }] };
+}

package/framework-mcp/dist/tools/framework/get_status.js

@@ -0,0 +1,5 @@
+import { safeExec } from "../../utils/cli.js";
+export function handleGetFrameworkStatus(projectRoot) {
+    const output = safeExec("npx", ["agent-enderun", "status"], projectRoot);
+    return { content: [{ type: "text", text: output }] };
+}

package/framework-mcp/dist/tools/framework/orchestrate.js

@@ -0,0 +1,5 @@
+import { safeExec } from "../../utils/cli.js";
+export function handleOrchestrateLoop(projectRoot) {
+    const output = safeExec("npx", ["agent-enderun", "orchestrate"], projectRoot);
+    return { content: [{ type: "text", text: output }] };
+}

package/framework-mcp/dist/tools/framework/update_contract_hash.js

@@ -0,0 +1,5 @@
+import { safeExec } from "../../utils/cli.js";
+export function handleUpdateContractHash(projectRoot) {
+    const output = safeExec("npx", ["agent-enderun", "update-contract"], projectRoot);
+    return { content: [{ type: "text", text: output }] };
+}

package/framework-mcp/dist/tools/framework/update_memory.js

@@ -0,0 +1,8 @@
+import { safeExec } from "../../utils/cli.js";
+export function handleUpdateProjectMemory(projectRoot, args) {
+    const section = args.section;
+    const content = args.content;
+    // Using execFileSync with array args prevents command injection
+    safeExec("npx", ["agent-enderun", "update_project_memory", section, content], projectRoot);
+    return { content: [{ type: "text", text: `✅ Section ${section} updated.` }] };
+}

package/framework-mcp/dist/tools/index.js

@@ -0,0 +1,25 @@
+import { TOOLS } from "./definitions.js";
+import { handleReadFile } from "./file_system/read_file.js";
+import { handleWriteFile } from "./file_system/write_file.js";
+import { handleReplaceText } from "./file_system/replace_text.js";
+import { handlePatchFile } from "./file_system/patch_file.js";
+import { handleGetFrameworkStatus } from "./framework/get_status.js";
+import { handleUpdateProjectMemory } from "./framework/update_memory.js";
+import { handleOrchestrateLoop } from "./framework/orchestrate.js";
+import { handleUpdateContractHash } from "./framework/update_contract_hash.js";
+import { handleSendAgentMessage } from "./messaging/send_message.js";
+import { handleLogAgentAction } from "./messaging/log_action.js";
+// Map of tool names to their handler functions
+export const toolHandlers = {
+    read_file: handleReadFile,
+    write_file: handleWriteFile,
+    replace_text: handleReplaceText,
+    patch_file: handlePatchFile,
+    get_framework_status: handleGetFrameworkStatus,
+    update_project_memory: handleUpdateProjectMemory,
+    orchestrate_loop: handleOrchestrateLoop,
+    send_agent_message: handleSendAgentMessage,
+    log_agent_action: handleLogAgentAction,
+    update_contract_hash: handleUpdateContractHash,
+};
+export { TOOLS };

package/framework-mcp/dist/tools/messaging/log_action.js

@@ -0,0 +1,22 @@
+import fs from "fs";
+import path from "path";
+import { resolveFrameworkDir } from "../../utils/security.js";
+export function handleLogAgentAction(projectRoot, args) {
+    const { agent, action, traceId, status, summary } = args;
+    const findings = args.findings ? args.findings.split(",").map(f => f.trim()) : [];
+    const frameworkDir = resolveFrameworkDir(projectRoot);
+    const agentName = agent.replace("@", "");
+    const logPath = path.join(projectRoot, frameworkDir, "logs", `${agentName}.json`);
+    const logEntry = {
+        timestamp: new Date().toISOString(),
+        agent,
+        action,
+        requestId: traceId,
+        status,
+        summary,
+        findings
+    };
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    fs.appendFileSync(logPath, JSON.stringify(logEntry) + "\n");
+    return { content: [{ type: "text", text: `✅ Action logged for ${agent} to ${path.join(frameworkDir, "logs", `${agentName}.json`)}` }] };
+}

package/framework-mcp/dist/tools/messaging/send_message.js

@@ -0,0 +1,21 @@
+import fs from "fs";
+import path from "path";
+import { resolveFrameworkDir } from "../../utils/security.js";
+export function handleSendAgentMessage(projectRoot, args) {
+    const { to, category, content, traceId } = args;
+    const frameworkDir = resolveFrameworkDir(projectRoot);
+    const agentName = to.replace("@", "");
+    const messagePath = path.join(projectRoot, frameworkDir, "messages", `${agentName}.json`);
+    const message = {
+        timestamp: new Date().toISOString(),
+        from: "@mcp",
+        to,
+        category,
+        traceId,
+        content,
+        status: "PENDING"
+    };
+    fs.mkdirSync(path.dirname(messagePath), { recursive: true });
+    fs.appendFileSync(messagePath, JSON.stringify(message) + "\n");
+    return { content: [{ type: "text", text: `✅ Message sent to ${to}` }] };
+}

package/framework-mcp/dist/tools/types.js

@@ -0,0 +1 @@
+export {};

package/framework-mcp/dist/utils/cli.js

@@ -0,0 +1,20 @@
+import { execFileSync } from "child_process";
+/**
+ * Executes a CLI command safely using execFileSync (no shell injection risk).
+ * Captures stderr gracefully to prevent stream crashes.
+ */
+export function safeExec(command, args, cwd) {
+    try {
+        return execFileSync(command, args, {
+            cwd,
+            encoding: "utf8",
+            timeout: 30000,
+            maxBuffer: 1024 * 1024,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+    }
+    catch (error) {
+        const err = error;
+        throw new Error(err.stderr || err.message || "Command execution failed", { cause: error });
+    }
+}

package/framework-mcp/dist/utils/security.js

@@ -0,0 +1,35 @@
+import path from "path";
+import fs from "fs";
+/**
+ * Validates and resolves a user-provided path to prevent path traversal attacks.
+ * Ensures the resolved path stays within the project root boundary.
+ */
+export function safePath(projectRoot, userPath) {
+    const resolved = path.resolve(projectRoot, userPath);
+    const normalizedRoot = path.resolve(projectRoot);
+    if (!resolved.startsWith(normalizedRoot + path.sep) && resolved !== normalizedRoot) {
+        throw new Error(`Access denied: path "${userPath}" escapes project root.`);
+    }
+    return resolved;
+}
+/**
+ * Resolves the active framework directory by scanning known candidates.
+ */
+export function resolveFrameworkDir(projectRoot) {
+    const candidates = [
+        ".gemini/antigravity",
+        ".gemini/antigravity-cli",
+        ".gemini",
+        ".claude",
+        ".grok",
+        ".agent",
+        ".enderun",
+    ];
+    for (const candidate of candidates) {
+        const candidatePath = path.join(projectRoot, candidate);
+        if (fs.existsSync(candidatePath)) {
+            return candidate;
+        }
+    }
+    return ".enderun";
+}

package/framework-mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-enderun/mcp",
-  "version": "0.9.4",
+  "version": "1.0.0",
   "description": "Agent Enderun Model Context Protocol (MCP) Server",
   "type": "module",
   "scripts": {