@rse/ase 0.0.14 → 0.0.16

package/dst/ase-config.js

@@ -324,16 +324,18 @@ export class Config {
             if (sc.kind === "default") {
                 const doc = new Document();
                 doc.contents = doc.createNode({});
-                const preset = projectClassificationPresets.default;
-                for (const [k, val] of Object.entries(preset)) {
-                    const segments = k.split(".");
-                    for (let j = 1; j < segments.length; j++) {
-                        const prefix = segments.slice(0, j);
-                        const node = doc.getIn(prefix, true);
-                        if (node === undefined)
-                            doc.setIn(prefix, doc.createNode({}));
+                if (this.name === "config") {
+                    const preset = projectClassificationPresets.default;
+                    for (const [k, val] of Object.entries(preset)) {
+                        const segments = k.split(".");
+                        for (let j = 1; j < segments.length; j++) {
+                            const prefix = segments.slice(0, j);
+                            const node = doc.getIn(prefix, true);
+                            if (node === undefined)
+                                doc.setIn(prefix, doc.createNode({}));
+                        }
+                        doc.setIn(segments, doc.createNode(val));
                     }
-                    doc.setIn(segments, doc.createNode(val));
                 }
                 docs.push({ scope: sc, filename: "", doc });
                 continue;

package/dst/ase-diagram.js

@@ -1,35 +1,158 @@
 /*
 **  Agentic Software Engineering (ASE)
-**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>, Matthias Brusdeylins <matthias@brusdeylins.info>
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
 **  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
 */
 import fs from "node:fs";
-import tty from "node:tty";
+import { InvalidArgumentError } from "commander";
 import { renderMermaidASCII } from "beautiful-mermaid";
-/*  detect terminal color capability via /dev/tty  */
-/*  (stdout is piped to capture diagram output, so query the controlling terminal directly)  */
+/*  custom argument parser for Commander: non-negative integer  */
+const parseInteger = (name) => (value) => {
+    const n = Number.parseInt(value, 10);
+    if (!Number.isFinite(n) || n < 0)
+        throw new InvalidArgumentError(`${name} must be a non-negative integer`);
+    return n;
+};
+/*  custom argument parser for Commander: color mode  */
+const parseColorMode = (name) => (value) => {
+    if (value !== "none" && value !== "ansi16" && value !== "ansi256")
+        throw new InvalidArgumentError(`${name} must be "none", "ansi16", or "ansi256"`);
+    return value;
+};
+/*  detect terminal column width  */
+const detectTermWidth = () => {
+    let width = 0;
+    /*  attempt 1: query environment variable  */
+    if (process.env.ASE_TERM_WIDTH !== undefined) {
+        const cols = Number.parseInt(process.env.ASE_TERM_WIDTH, 10);
+        if (Number.isFinite(cols) && cols > 0)
+            width = cols;
+    }
+    /*  attempt 2: query stdout  */
+    if (width === 0 && process.stdout.isTTY) {
+        const cols = process.stdout.columns;
+        if (typeof cols === "number" && cols > 0)
+            width = cols;
+    }
+    return width;
+};
+/*  detect terminal row height  */
+const detectTermHeight = () => {
+    let height = 0;
+    /*  attempt 1: query environment variable  */
+    if (process.env.ASE_TERM_HEIGHT !== undefined) {
+        const rows = Number.parseInt(process.env.ASE_TERM_HEIGHT, 10);
+        if (Number.isFinite(rows) && rows > 0)
+            height = rows;
+    }
+    /*  attempt 2: query stdout  */
+    if (height === 0 && process.stdout.isTTY) {
+        const rows = process.stdout.rows;
+        if (typeof rows === "number" && rows > 0)
+            height = rows;
+    }
+    return height;
+};
+/*  detect terminal color capability  */
 const detectColorMode = () => {
-    let fd = -1;
-    try {
-        fd = fs.openSync("/dev/tty", "r+");
-        const stream = new tty.WriteStream(fd);
-        const depth = stream.getColorDepth();
-        stream.destroy();
+    let mode = "none";
+    /*  attempt 1: query environment variable (explicitly)  */
+    if (process.env.ASE_TERM_COLORS !== undefined)
+        if (process.env.ASE_TERM_COLORS.match(/^(?:none|ansi16|ansi256)$/) !== null)
+            mode = process.env.ASE_TERM_COLORS;
+    /*  attempt 2: query stdout  */
+    if (mode === "none" && process.stdout.isTTY) {
+        const depth = process.stdout.getColorDepth();
         if (depth >= 8)
-            return "ansi256";
-        if (depth >= 4)
-            return "ansi16";
-        return "none";
+            mode = "ansi256";
+        else if (depth >= 4)
+            mode = "ansi16";
     }
-    catch {
-        if (fd >= 0) {
-            try {
-                fs.closeSync(fd);
+    return mode;
+};
+/*  truncate a single rendered line to a maximum visible column,
+    preserving ANSI escape sequences (CSI ...m) and appending an ANSI
+    reset sequence if any styling was active at the truncation point  */
+const truncateAnsiLine = (line, budget) => {
+    if (budget <= 0)
+        return "";
+    let out = "";
+    let visible = 0;
+    let styled = false;
+    let i = 0;
+    while (i < line.length) {
+        const ch = line[i];
+        if (ch === "\x1b" && line[i + 1] === "[") {
+            let j = i + 2;
+            while (j < line.length && !/[A-Za-z]/.test(line[j]))
+                j++;
+            if (j < line.length) {
+                const seq = line.slice(i, j + 1);
+                out += seq;
+                if (seq.endsWith("m")) {
+                    const body = seq.slice(2, -1);
+                    if (body === "" || body === "0")
+                        styled = false;
+                    else
+                        styled = true;
+                }
+                i = j + 1;
+                continue;
             }
-            catch { /*  ignore  */ }
+            i++;
+            continue;
         }
-        return "none";
+        if (visible >= budget)
+            break;
+        out += ch;
+        visible++;
+        i++;
     }
+    if (styled)
+        out += "\x1b[0m";
+    return out;
+};
+/*  pure rendering helper: turn a Mermaid source string plus options into
+    a rendered Unicode/ASCII diagram string. Throws on render failure.  */
+export const renderDiagram = (src, opts) => {
+    /*  create diagram rendering  */
+    let out = renderMermaidASCII(src, {
+        useAscii: opts.ascii,
+        paddingX: opts.nodeMarginX,
+        paddingY: opts.nodeMarginY,
+        boxBorderPadding: opts.nodePadding,
+        colorMode: opts.colorMode,
+        theme: opts.colorMode !== "none" ? {
+            fg: "#000000",
+            border: "#a0a0a0",
+            junction: "#a0a0a0",
+            arrow: "#404040",
+            line: "#707070",
+            corner: "#707070"
+        } : {
+            fg: "#000000",
+            border: "#000000",
+            junction: "#000000",
+            arrow: "#000000",
+            line: "#000000",
+            corner: "#000000"
+        }
+    });
+    /*  optionally clip diagram rendering  */
+    const termWidth = opts.terminalWidth;
+    const termHeight = opts.terminalHeight;
+    if (termWidth > 0 || termHeight > 0) {
+        const maxWidth = termWidth > 0 ? termWidth - opts.diagramClipX : 0;
+        const maxHeight = termHeight > 0 ? termHeight - opts.diagramClipY : 0;
+        const trailingNL = out.endsWith("\n");
+        let lines = (trailingNL ? out.slice(0, -1) : out).split("\n");
+        if (maxWidth > 0)
+            lines = lines.map((l) => truncateAnsiLine(l, maxWidth));
+        if (maxHeight > 0 && lines.length > maxHeight)
+            lines = lines.slice(0, maxHeight);
+        out = lines.join("\n") + (trailingNL ? "\n" : "");
+    }
+    return out;
 };
 /*  read stdin into a single string  */
 const readStdin = async () => {
@@ -48,83 +171,52 @@ export default class DiagramCommand {
     register(program) {
         program
             .command("diagram")
-            .description("Render Mermaid source (stdin or --input) to aligned Unicode/ASCII diagram")
-            .option("-a, --ascii", "emit plain ASCII (+-|) instead of Unicode box-drawing", false)
-            .option("-c, --color-mode <mode>", "force particular color mode to use (\"none\", \"ansi16\", or \"ansi256\")")
+            .description("Render Mermaid diagram specification as Unicode/ASCII art")
             .option("-i, --input <file>", "read Mermaid source from file instead of stdin")
-            .option("-x, --pad-x <n>", "horizontal spacing between nodes", "3")
-            .option("-y, --pad-y <n>", "vertical spacing between nodes", "3")
-            .option("-b, --pad-box <n>", "inner node box spacing", "1")
+            .option("-a, --ascii", "emit plain ASCII (+-|) instead of Unicode box-drawing", false)
+            .option("-c, --color-mode <mode>", "force color mode (\"none\", \"ansi16\", or \"ansi256\")", parseColorMode("--color-mode"), detectColorMode())
+            .option("--node-margin-x <n>", "horizontal margin between nodes of <n> characters", parseInteger("--node-margin-x"), 3)
+            .option("--node-margin-y <n>", "vertical margin between nodes of <n> lines", parseInteger("--node-margin-y"), 3)
+            .option("--node-padding <n>", "horizontal and vertical inner node padding with <n> characters", parseInteger("--node-padding"), 1)
+            .option("--diagram-clip-x <n>", "extra horizontal clipping of diagram to terminal width minus <n> characters", parseInteger("--diagram-clip-x"), 0)
+            .option("--diagram-clip-y <n>", "extra vertical clipping of diagram to terminal height minus <n> lines", parseInteger("--diagram-clip-y"), 0)
+            .option("--terminal-width <n>", "width of terminal of <n> characters (for diagram clipping)", parseInteger("--terminal-width"), detectTermWidth())
+            .option("--terminal-height <n>", "height of terminal of <n> lines (for diagram clipping)", parseInteger("--terminal-height"), detectTermHeight())
             .action(async (opts) => {
-            /*  load Mermaid source  */
+            /*  fetch Mermaid diagram specification from stdin  */
             let src;
             if (opts.input !== undefined)
                 src = fs.readFileSync(opts.input, "utf8");
             else
                 src = await readStdin();
             if (src.trim() === "") {
-                this.log.write("error", "diagram: empty Mermaid source");
-                process.exit(1);
-            }
-            /*  parse spacing options  */
-            const paddingX = Number.parseInt(opts.padX ?? "3", 10);
-            if (!Number.isFinite(paddingX)) {
-                this.log.write("error", "diagram: --pad-x must be integer");
-                process.exit(1);
-            }
-            const paddingY = Number.parseInt(opts.padY ?? "3", 10);
-            if (!Number.isFinite(paddingY)) {
-                this.log.write("error", "diagram: --pad-y must be integer");
-                process.exit(1);
-            }
-            const boxBorderPadding = Number.parseInt(opts.padBox ?? "1", 10);
-            if (!Number.isFinite(boxBorderPadding)) {
-                this.log.write("error", "diagram: --pad-box must be integer");
-                process.exit(1);
-            }
-            /*  determine color mode (explicit option overrides auto-detection)  */
-            let colorMode;
-            if (opts.colorMode === "none" || opts.colorMode === "ansi16" || opts.colorMode === "ansi256")
-                colorMode = opts.colorMode;
-            else if (opts.colorMode === undefined)
-                colorMode = detectColorMode();
-            else {
-                this.log.write("error", "diagram: --color-mode must be \"none\", \"ansi16\", or \"ansi256\"");
+                this.log.write("error", "diagram: empty Mermaid diagram specification");
                 process.exit(1);
             }
-            /*  render to ASCII  */
+            /*  create diagram rendering  */
+            let out;
             try {
-                const out = renderMermaidASCII(src, {
-                    useAscii: opts.ascii ?? false,
-                    paddingX,
-                    paddingY,
-                    boxBorderPadding,
-                    colorMode,
-                    theme: colorMode !== "none" ? {
-                        fg: "#000000",
-                        border: "#a0a0a0",
-                        junction: "#a0a0a0",
-                        arrow: "#404040",
-                        line: "#707070",
-                        corner: "#707070"
-                    } : {
-                        fg: "#000000",
-                        border: "#000000",
-                        junction: "#000000",
-                        arrow: "#000000",
-                        line: "#000000",
-                        corner: "#000000"
-                    }
+                out = renderDiagram(src, {
+                    ascii: opts.ascii ?? false,
+                    colorMode: opts.colorMode,
+                    nodeMarginX: opts.nodeMarginX,
+                    nodeMarginY: opts.nodeMarginY,
+                    nodePadding: opts.nodePadding,
+                    diagramClipX: opts.diagramClipX,
+                    diagramClipY: opts.diagramClipY,
+                    terminalWidth: opts.terminalWidth,
+                    terminalHeight: opts.terminalHeight
                 });
-                process.stdout.write(out);
-                if (!out.endsWith("\n"))
-                    process.stdout.write("\n");
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
                 this.log.write("error", `diagram: render failed: ${message}`);
                 process.exit(1);
             }
+            /*  output diagram rendering  */
+            process.stdout.write(out);
+            if (!out.endsWith("\n"))
+                process.stdout.write("\n");
         });
     }
 }

package/dst/ase-hook.js

@@ -80,6 +80,10 @@ export default class HookCommand {
             approve = true;
             reason = "ASE skill invocation auto-approved";
         }
+        else if (/^mcp__plugin_ase_ase__.+/.test(toolName)) {
+            approve = true;
+            reason = "ASE MCP tool invocation auto-approved";
+        }
         /*  emit permission decision (or stay silent to defer to default flow)  */
         if (approve) {
             process.stdout.write(JSON.stringify({

package/dst/ase-mcp.js

@@ -0,0 +1,156 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
+*/
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import axios from "axios";
+import * as v from "valibot";
+import { execa } from "execa";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { Config, configSchema } from "./ase-config.js";
+const HOST = "127.0.0.1";
+/*  schema for ".ase/service.yaml" (same shape as in ase-service.ts)  */
+const serviceSchema = v.nullish(v.strictObject({
+    port: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1024), v.maxValue(65535)))
+}));
+/*  distinguish ECONNREFUSED from other Axios transport errors  */
+const isConnRefused = (err) => {
+    const e = err;
+    return e?.code === "ECONNREFUSED" || e?.cause?.code === "ECONNREFUSED";
+};
+/*  probe the service and verify ASE identity banner  */
+const probe = async (port, projectId) => {
+    try {
+        const r = await axios.request({
+            method: "OPTIONS",
+            url: `http://${HOST}:${port}/`,
+            timeout: 2000,
+            validateStatus: () => true
+        });
+        if (r.status < 200 || r.status >= 300)
+            return false;
+        const d = r.data;
+        return d?.ase === true && d?.projectId === projectId;
+    }
+    catch (err) {
+        if (isConnRefused(err))
+            return null;
+        throw err;
+    }
+};
+/*  CLI command "ase mcp"  */
+export default class MCPCommand {
+    log;
+    constructor(log) {
+        this.log = log;
+    }
+    /*  load service identity context  */
+    loadContext() {
+        const cfg = new Config("config", configSchema, this.log);
+        cfg.read();
+        const svc = new Config("service", serviceSchema, this.log);
+        svc.read();
+        const rawId = cfg.get("project.id");
+        const projectId = rawId ?? path.basename(process.cwd());
+        const rawPort = svc.get("port");
+        const port = rawPort ?? null;
+        return { projectId, port, svc };
+    }
+    /*  spawn "ase service start" detached and wait for it to come up  */
+    async ensureService() {
+        let ctx = this.loadContext();
+        /*  fast path: already running  */
+        if (ctx.port !== null) {
+            const match = await probe(ctx.port, ctx.projectId);
+            if (match === true)
+                return { projectId: ctx.projectId, port: ctx.port };
+        }
+        /*  spawn "ase service start" using the same node entry point  */
+        const entry = fileURLToPath(new URL("./ase.js", import.meta.url));
+        await execa(process.execPath, [entry, "service", "start"], {
+            stdio: "ignore",
+            detached: false
+        });
+        /*  re-load context to pick up the freshly persisted port  */
+        ctx = this.loadContext();
+        if (ctx.port === null)
+            throw new Error("mcp: service did not register a port after start");
+        const match = await probe(ctx.port, ctx.projectId);
+        if (match !== true)
+            throw new Error(`mcp: service not responding on port ${ctx.port} after start`);
+        return { projectId: ctx.projectId, port: ctx.port };
+    }
+    /*  bridge stdio to a Streamable HTTP MCP endpoint on the local service  */
+    async runBridge() {
+        /*  ensure the service is running  */
+        const { port } = await this.ensureService();
+        /*  create MCP HTTP client  */
+        const url = new URL(`http://${HOST}:${port}/mcp`);
+        const client = new StreamableHTTPClientTransport(url);
+        /*  create MCP STDIO server  */
+        const server = new StdioServerTransport();
+        /*  handle shutdown  */
+        let closed = false;
+        const shutdown = async () => {
+            if (closed)
+                return;
+            closed = true;
+            await Promise.allSettled([
+                server.close(),
+                client.close()
+            ]);
+        };
+        /*  connect server to client (forward transport)  */
+        server.onmessage = (msg) => {
+            client.send(msg).catch((_err) => {
+                const err = _err instanceof Error ? _err : new Error(String(_err));
+                this.log.write("error", `mcp: http send: ${err.message}`);
+            });
+        };
+        server.onerror = (_err) => {
+            const err = _err instanceof Error ? _err : new Error(String(_err));
+            this.log.write("error", `mcp: stdio: ${err.message}`);
+        };
+        server.onclose = () => {
+            shutdown().catch(() => { });
+        };
+        /*  connect client to server (backward transport)  */
+        client.onmessage = (msg) => {
+            server.send(msg).catch((_err) => {
+                const err = _err instanceof Error ? _err : new Error(String(_err));
+                this.log.write("error", `mcp: stdout send: ${err.message}`);
+            });
+        };
+        client.onerror = (_err) => {
+            const err = _err instanceof Error ? _err : new Error(String(_err));
+            this.log.write("error", `mcp: http: ${err.message}`);
+        };
+        client.onclose = () => {
+            shutdown().catch(() => { });
+        };
+        /*  start server and client  */
+        await server.start();
+        await client.start();
+        /*  await stdio to be closed  */
+        await new Promise((resolve) => {
+            const done = () => resolve();
+            process.stdin.once("end", done);
+            process.stdin.once("close", done);
+        });
+        /*  shutdown services  */
+        await shutdown();
+        return 0;
+    }
+    /*  register commands  */
+    register(program) {
+        program
+            .command("mcp")
+            .description("Bridge stdio MCP to the per-project background service over Streamable HTTP")
+            .action(async () => {
+            process.exit(await this.runBridge());
+        });
+    }
+}

package/dst/ase-service.js

@@ -13,7 +13,12 @@ import axios from "axios";
 import { isMap } from "yaml";
 import * as v from "valibot";
 import prettyMs from "pretty-ms";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { z } from "zod";
 import { Config, configSchema } from "./ase-config.js";
+import { renderDiagram } from "./ase-diagram.js";
+import pkg from "../package.json" with { type: "json" };
 const SERVE_ENV = "ASE_SERVICE_SERVE";
 const PORT_ENV = "ASE_SERVICE_PORT";
 const HOST = "127.0.0.1";
@@ -177,6 +182,86 @@ export default class ServiceCommand {
             lastActivity = Date.now();
             return h.continue;
         });
+        /*  build a fresh MCP server instance with the demo "ping" tool  */
+        const buildMcpServer = () => {
+            const mcp = new McpServer({ name: "ase", version: pkg.version });
+            mcp.registerTool("ping", {
+                title: "ASE service ping",
+                description: "Return ASE service identity, port, and uptime.",
+                inputSchema: {}
+            }, async () => {
+                const status = {
+                    ok: true,
+                    projectId: ctx.projectId,
+                    port: ctx.port,
+                    uptimeMs: Date.now() - startTime
+                };
+                return {
+                    content: [{ type: "text", text: JSON.stringify(status) }]
+                };
+            });
+            mcp.registerTool("diagram", {
+                title: "ASE diagram render",
+                description: "Render a Mermaid diagram as Unicode/ASCII art. " +
+                    "Use for visualizing " +
+                    "structure/layout/components/dependencies as a Flowchart, " +
+                    "control-flow/branching/concurrency as a Flowchart, " +
+                    "state-machine/states/transitions as an UML State Diagram, " +
+                    "data-flow/actors/messages/protocols as an UML Sequence Diagram, " +
+                    "data-structure/classes/methods as an UML Class Diagram " +
+                    "data-model/entities/relationships as an ER Diagram, or " +
+                    "metrics/distributions/time-series as a XY-Charts. " +
+                    "Pass the Mermaid diagram specification as `diagram`. " +
+                    "Returns the rendered art as `text`.",
+                inputSchema: {
+                    diagram: z.string()
+                        .describe("Mermaid diagram specification"),
+                    ascii: z.boolean().default(false)
+                        .describe("emit plain ASCII (+-|) instead of Unicode box-drawing characters"),
+                    colorMode: z.enum(["none", "ansi16", "ansi256"]).default("none")
+                        .describe("color mode for ANSI escape sequences in the rendered output"),
+                    nodeMarginX: z.number().int().min(0).default(3)
+                        .describe("horizontal margin between nodes, in characters"),
+                    nodeMarginY: z.number().int().min(0).default(3)
+                        .describe("vertical margin between nodes, in lines"),
+                    nodePadding: z.number().int().min(0).default(1)
+                        .describe("inner horizontal and vertical padding within each node, in characters"),
+                    diagramClipX: z.number().int().min(0).default(0)
+                        .describe("extra horizontal clipping: subtract this many characters from `terminalWidth`"),
+                    diagramClipY: z.number().int().min(0).default(0)
+                        .describe("extra vertical clipping: subtract this many lines from `terminalHeight`"),
+                    terminalWidth: z.number().int().min(0).default(0)
+                        .describe("terminal width in characters; 0 disables horizontal clipping"),
+                    terminalHeight: z.number().int().min(0).default(0)
+                        .describe("terminal height in lines; 0 disables vertical clipping")
+                }
+            }, async (args) => {
+                try {
+                    const out = renderDiagram(args.diagram, {
+                        ascii: args.ascii,
+                        colorMode: args.colorMode,
+                        nodeMarginX: args.nodeMarginX,
+                        nodeMarginY: args.nodeMarginY,
+                        nodePadding: args.nodePadding,
+                        diagramClipX: args.diagramClipX,
+                        diagramClipY: args.diagramClipY,
+                        terminalWidth: args.terminalWidth,
+                        terminalHeight: args.terminalHeight
+                    });
+                    return {
+                        content: [{ type: "text", text: out }]
+                    };
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `diagram: render failed: ${message}` }]
+                    };
+                }
+            });
+            return mcp;
+        };
         /*  listen to HTTP/REST endpoints  */
         server.route({
             method: "OPTIONS",
@@ -196,6 +281,38 @@ export default class ServiceCommand {
                 return h.response({ ok: true }).code(200);
             }
         });
+        const mcpHandler = async (request, h, body) => {
+            const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+            const mcp = buildMcpServer();
+            request.raw.res.on("close", () => {
+                transport.close().catch(() => { });
+                mcp.close().catch(() => { });
+            });
+            try {
+                await mcp.connect(transport);
+                await transport.handleRequest(request.raw.req, request.raw.res, body);
+            }
+            catch (_err) {
+                const err = _err instanceof Error ? _err : new Error(String(_err));
+                this.log.write("error", `mcp: ${err.message}`);
+                if (!request.raw.res.headersSent) {
+                    request.raw.res.statusCode = 500;
+                    request.raw.res.end();
+                }
+            }
+            return h.abandon;
+        };
+        server.route({
+            method: "POST",
+            path: "/mcp",
+            options: { payload: { parse: true, allow: "application/json" } },
+            handler: (request, h) => mcpHandler(request, h, request.payload)
+        });
+        server.route({
+            method: ["GET", "DELETE"],
+            path: "/mcp",
+            handler: (request, h) => mcpHandler(request, h)
+        });
         server.route({
             method: "POST",
             path: "/command",