cwtools-mcp 0.1.0

package/dist/mcp/bridgeProxy.js

@@ -0,0 +1,281 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBridgeProxyMcpServer = createBridgeProxyMcpServer;
+exports.assertBridgeWorkspaceMatches = assertBridgeWorkspaceMatches;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const url_1 = require("url");
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const vscodeCache_1 = require("../hosts/vscodeCache");
+const resources_1 = require("./resources");
+const toolRegistrar_1 = require("./toolRegistrar");
+const toolHandlers_1 = require("./toolHandlers");
+const BRIDGE_MANIFEST_FILE = 'bridge-manifest.json';
+const BRIDGE_PROTOCOL_VERSION = 1;
+function createBridgeProxyMcpServer(config) {
+    const server = new index_js_1.Server({
+        name: 'cwtools-mcp',
+        version: '0.1.0',
+    }, {
+        capabilities: {
+            resources: {},
+            tools: {},
+        },
+        instructions: [
+            'CWTools MCP is served by the active VS Code-compatible extension host.',
+            'This proxy does not start its own CWTools language server. If calls report',
+            'bridge_unavailable, open the project in the compatible host where the extension',
+            'is installed and active, or rerun with --standalone to use the legacy isolated mode.',
+        ].join('\n'),
+    });
+    server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+        try {
+            return await bridgeRpc(config, server, 'tools/list', {});
+        }
+        catch {
+            return { tools: (0, toolRegistrar_1.listRegisteredTools)() };
+        }
+    });
+    server.setRequestHandler(types_js_1.ListResourcesRequestSchema, async () => {
+        try {
+            return await bridgeRpc(config, server, 'resources/list', {});
+        }
+        catch {
+            return { resources: (0, resources_1.listResources)() };
+        }
+    });
+    server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) => {
+        try {
+            return await bridgeRpc(config, server, 'resources/read', {
+                uri: request.params.uri,
+            });
+        }
+        catch (error) {
+            return {
+                contents: [
+                    {
+                        uri: request.params.uri,
+                        mimeType: 'application/json',
+                        text: `${JSON.stringify(unavailableResult(error), null, 2)}\n`,
+                    },
+                ],
+            };
+        }
+    });
+    server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+        try {
+            const args = request.params.arguments && typeof request.params.arguments === 'object'
+                ? request.params.arguments
+                : {};
+            const result = await bridgeRpc(config, server, 'tools/call', {
+                name: request.params.name,
+                arguments: args,
+            });
+            return normalizeCallToolResult(result);
+        }
+        catch (error) {
+            return (0, toolHandlers_1.toMcpCallToolResult)(unavailableResult(error));
+        }
+    });
+    return server;
+}
+async function bridgeRpc(config, server, method, params) {
+    const manifest = await readBridgeManifest(config, server);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 30000);
+    try {
+        const response = await fetch(manifest.rpcUrl, {
+            method: 'POST',
+            headers: {
+                'authorization': `Bearer ${manifest.token}`,
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: `${Date.now()}:${Math.random().toString(36).slice(2)}`,
+                method,
+                params,
+            }),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`Bridge HTTP ${response.status}: ${await response.text()}`);
+        }
+        const payload = await response.json();
+        if (payload.error) {
+            throw new Error(payload.error.message ?? `Bridge JSON-RPC error ${payload.error.code ?? ''}`.trim());
+        }
+        return payload.result;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function readBridgeManifest(config, server) {
+    const manifestPath = resolveBridgeManifestPath(config);
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    }
+    catch (error) {
+        throw new Error(`CWTools MCP bridge is unavailable: could not read ${manifestPath}. ` +
+            `Open this project in a VS Code-compatible host with the extension active, or pass --standalone to start a separate CWTools server. ` +
+            `Details: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (parsed.kind !== 'cwtools-mcp-extension-bridge' || parsed.protocolVersion !== BRIDGE_PROTOCOL_VERSION) {
+        throw new Error(`CWTools MCP bridge manifest at ${manifestPath} is not compatible with this proxy. ` +
+            `Open the project in the updated extension host, or pass --standalone for legacy isolated mode.`);
+    }
+    if (!parsed.rpcUrl || !parsed.token) {
+        throw new Error(`CWTools MCP bridge manifest at ${manifestPath} is missing rpcUrl/token.`);
+    }
+    const expected = await resolveExpectedWorkspace(config, server);
+    assertBridgeWorkspaceMatches(expected.roots, parsed.workspaceRoot, expected.source);
+    return parsed;
+}
+async function resolveExpectedWorkspace(config, server) {
+    if (config.workspaceRootExplicit) {
+        return { roots: [config.workspaceRoot], source: '--workspace' };
+    }
+    const clientRoots = await readClientWorkspaceRoots(server);
+    if (clientRoots.length > 0) {
+        return { roots: clientRoots, source: 'MCP client roots' };
+    }
+    const envRoot = process.env.CLAUDE_PROJECT_DIR || process.env.CWTOOLS_MCP_WORKSPACE;
+    if (envRoot) {
+        return { roots: [envRoot], source: 'environment workspace' };
+    }
+    return { roots: [config.workspaceRoot], source: 'MCP process cwd' };
+}
+async function readClientWorkspaceRoots(server) {
+    if (!server.getClientCapabilities()?.roots)
+        return [];
+    try {
+        const result = await server.listRoots(undefined, { timeout: 1000 });
+        const roots = result.roots
+            .map(root => rootUriToPath(root.uri))
+            .filter((root) => !!root);
+        return uniquePaths(roots);
+    }
+    catch {
+        return [];
+    }
+}
+function rootUriToPath(uri) {
+    try {
+        const parsed = new URL(uri);
+        if (parsed.protocol !== 'file:')
+            return undefined;
+        return (0, url_1.fileURLToPath)(parsed);
+    }
+    catch {
+        return undefined;
+    }
+}
+function uniquePaths(roots) {
+    const result = [];
+    for (const root of roots) {
+        if (!result.some(existing => samePath(existing, root))) {
+            result.push(root);
+        }
+    }
+    return result;
+}
+function assertBridgeWorkspaceMatches(expectedWorkspaceRoot, servedWorkspaceRoot, source = 'MCP process workspace') {
+    const expectedRoots = Array.isArray(expectedWorkspaceRoot) ? expectedWorkspaceRoot : [expectedWorkspaceRoot];
+    if (expectedRoots.some(expected => samePath(expected, servedWorkspaceRoot)))
+        return;
+    const expected = expectedRoots.map(root => path.resolve(root)).join(', ');
+    throw new Error(`CWTools MCP bridge workspace mismatch. ${source} expects ${expected}, ` +
+        `but the active extension bridge serves ${servedWorkspaceRoot}. ` +
+        'Open the same project in the compatible host, or make sure the MCP client exposes its current workspace roots/cwd.');
+}
+function resolveBridgeManifestPath(config) {
+    if (config.bridgeManifestPath)
+        return config.bridgeManifestPath;
+    const envPath = process.env.CWTOOLS_MCP_BRIDGE_MANIFEST;
+    if (envPath)
+        return path.resolve(envPath);
+    const scriptPath = process.argv[1] ? path.resolve(process.argv[1]) : __filename;
+    const scriptSibling = path.join(path.dirname(scriptPath), BRIDGE_MANIFEST_FILE);
+    if (fs.existsSync(scriptSibling))
+        return scriptSibling;
+    // Independently installed (npx / npm -g) proxies live nowhere near the
+    // extension's globalStorage — fall back to the manifest the active
+    // VS Code-compatible host writes there.
+    const detected = (0, vscodeCache_1.detectExtensionBridgeManifestPath)();
+    return detected ?? scriptSibling;
+}
+function normalizeCallToolResult(result) {
+    if (result
+        && Array.isArray(result.content)
+        && result.content.every(item => item?.type === 'text' && typeof item.text === 'string')) {
+        return result;
+    }
+    return (0, toolHandlers_1.toMcpCallToolResult)({
+        ok: false,
+        status: 'error',
+        source: 'cwtools-mcp-bridge-proxy',
+        error: {
+            code: 'invalid_bridge_response',
+            message: 'The extension MCP bridge returned an invalid tool result.',
+        },
+    });
+}
+function unavailableResult(error) {
+    return {
+        ok: false,
+        status: 'unavailable',
+        source: 'cwtools-mcp-bridge-proxy',
+        error: {
+            code: 'bridge_unavailable',
+            message: error instanceof Error ? error.message : String(error),
+        },
+        nextSteps: [
+            'Open the workspace in a VS Code-compatible host with the CWTools extension installed and active.',
+            'Point the MCP client at cwtools-mcp (npx -y cwtools-mcp) or pass --bridge-manifest to the host globalStorage/mcp/bridge-manifest.json.',
+            'Use --standalone only if you intentionally want a separate CWTools Server process.',
+        ],
+    };
+}
+function samePath(a, b) {
+    const ra = path.resolve(a);
+    const rb = path.resolve(b);
+    return process.platform === 'win32'
+        ? ra.toLowerCase() === rb.toLowerCase()
+        : ra === rb;
+}

package/dist/mcp/resources.d.ts

@@ -0,0 +1,15 @@
+import { type HostServices } from 'cwtools-shared';
+export declare const RESOURCE_URIS: readonly ["cwtools://knowledge/game", "cwtools://knowledge/diagnostic-routing", "cwtools://knowledge/workflow-hints", "cwtools://project/profile", "cwtools://project/knowledge-manifest"];
+export declare function listResources(): {
+    uri: string;
+    name: string;
+    description: string;
+    mimeType: string;
+}[];
+export declare function readResource(host: HostServices, uri: string): Promise<{
+    contents: {
+        uri: string;
+        mimeType: string;
+        text: string;
+    }[];
+}>;

package/dist/mcp/resources.js

@@ -0,0 +1,151 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESOURCE_URIS = void 0;
+exports.listResources = listResources;
+exports.readResource = readResource;
+const cwtools_shared_1 = require("cwtools-shared");
+const path = __importStar(require("path"));
+exports.RESOURCE_URIS = [
+    'cwtools://knowledge/game',
+    'cwtools://knowledge/diagnostic-routing',
+    'cwtools://knowledge/workflow-hints',
+    'cwtools://project/profile',
+    'cwtools://project/knowledge-manifest',
+];
+function listResources() {
+    return [
+        {
+            uri: 'cwtools://knowledge/game',
+            name: 'CWTools game knowledge',
+            description: 'Current-game semantic catalog summary and stable evidence-routing guidance.',
+            mimeType: 'application/json',
+        },
+        {
+            uri: 'cwtools://knowledge/diagnostic-routing',
+            name: 'CWTools diagnostic routing',
+            description: 'Structured diagnostic routing guidance and suggested tools.',
+            mimeType: 'application/json',
+        },
+        {
+            uri: 'cwtools://knowledge/workflow-hints',
+            name: 'CWTools workflow hints',
+            description: 'Reusable workflow hints for diagnostics, localisation, and entity lookup.',
+            mimeType: 'application/json',
+        },
+        {
+            uri: 'cwtools://project/profile',
+            name: 'CWTools project profile',
+            description: 'The generated .cwtools/project/profile.json if available.',
+            mimeType: 'application/json',
+        },
+        {
+            uri: 'cwtools://project/knowledge-manifest',
+            name: 'CWTools project knowledge manifest',
+            description: 'Freshness, domains, counts, and fingerprints for the /init-generated semantic knowledge pack.',
+            mimeType: 'application/json',
+        },
+    ];
+}
+async function readResource(host, uri) {
+    const data = await readResourceData(host, uri);
+    return {
+        contents: [
+            {
+                uri,
+                mimeType: 'application/json',
+                text: `${JSON.stringify(data, null, 2)}\n`,
+            },
+        ],
+    };
+}
+async function readResourceData(host, uri) {
+    switch (uri) {
+        case 'cwtools://knowledge/game': {
+            const catalog = await host.lsp.executeCommand('cwtools.ai.getSemanticCatalog', [[], []], { timeoutMs: 10000 }).catch(() => undefined);
+            return (0, cwtools_shared_1.queryGameKnowledge)('paradox', catalog);
+        }
+        case 'cwtools://knowledge/diagnostic-routing':
+            return {
+                status: 'ready',
+                routes: [
+                    (0, cwtools_shared_1.analyzeDiagnosticKnowledge)({ message: 'syntax error' }),
+                    (0, cwtools_shared_1.analyzeDiagnosticKnowledge)({ message: 'missing localisation key' }),
+                    (0, cwtools_shared_1.analyzeDiagnosticKnowledge)({ message: 'scope mismatch' }),
+                    (0, cwtools_shared_1.analyzeDiagnosticKnowledge)({ message: 'unknown' }),
+                ],
+            };
+        case 'cwtools://knowledge/workflow-hints':
+            return (0, cwtools_shared_1.queryWorkflowHints)();
+        case 'cwtools://project/profile': {
+            const profilePath = (0, cwtools_shared_1.getProjectProfilePath)(host.workspaceRoot);
+            const read = await host.filesystem.readTextFile(profilePath);
+            return read.exists
+                ? JSON.parse(read.content)
+                : {
+                    status: 'missing',
+                    profilePath,
+                    _hint: 'Run /init in the VS Code extension or create .cwtools/project/profile.json.',
+                };
+        }
+        case 'cwtools://project/knowledge-manifest': {
+            let manifestPath = path.join(host.workspaceRoot, '.cwtools', 'project', 'knowledge', 'manifest.json');
+            let read = await host.filesystem.readTextFile(manifestPath);
+            if (!read.exists) {
+                const legacyPath = path.join(host.workspaceRoot, '.cwtools-ai', 'project', 'knowledge', 'manifest.json');
+                const legacyRead = await host.filesystem.readTextFile(legacyPath);
+                if (legacyRead.exists) {
+                    manifestPath = legacyPath;
+                    read = legacyRead;
+                }
+            }
+            return read.exists
+                ? JSON.parse(read.content)
+                : {
+                    status: 'missing',
+                    manifestPath,
+                    _hint: 'Run /init in the VS Code extension and wait for the deep semantic phase.',
+                };
+        }
+        default:
+            return {
+                status: 'error',
+                error: {
+                    code: 'resource_not_found',
+                    message: `Unknown CWTools MCP resource: ${uri}`,
+                },
+            };
+    }
+}

package/dist/mcp/toolHandlers.d.ts

@@ -0,0 +1,9 @@
+import { type HostServices, type SharedToolDispatcher, type SharedToolResult } from 'cwtools-shared';
+export declare function createToolCallHandler(host: HostServices, dispatcher?: SharedToolDispatcher): (name: string, args?: Record<string, unknown>) => Promise<SharedToolResult>;
+export declare function toMcpCallToolResult(result: SharedToolResult): {
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+};

package/dist/mcp/toolHandlers.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createToolCallHandler = createToolCallHandler;
+exports.toMcpCallToolResult = toMcpCallToolResult;
+const cwtools_shared_1 = require("cwtools-shared");
+function createToolCallHandler(host, dispatcher = cwtools_shared_1.defaultSharedToolDispatcher) {
+    // The game stays loaded once ready, so probe readiness only until it flips true.
+    let ready = false;
+    const probeReadiness = async () => {
+        if (ready)
+            return { ready: true };
+        try {
+            const status = await host.lsp.executeCommand('cwtools.ai.getValidationStatus', [], { timeoutMs: 8000 });
+            const verdict = (0, cwtools_shared_1.parseReadiness)(status);
+            if (verdict.ready)
+                ready = true;
+            return verdict;
+        }
+        catch {
+            return { ready: false, reason: 'lsp_unavailable' };
+        }
+    };
+    return async (name, args = {}) => {
+        // Read-only surface: reject anything outside the registered (read-only) tools,
+        // including any write tool called directly. Writes go through the host agent.
+        if (!(0, cwtools_shared_1.isMcpToolName)(name)) {
+            return {
+                ok: false,
+                status: 'denied',
+                source: 'cwtools-mcp',
+                error: {
+                    code: 'tool_not_available',
+                    message: `Tool '${name}' is not available: this MCP server is read-only. Perform file writes through your own environment.`,
+                },
+            };
+        }
+        const result = await dispatcher(host, name, args);
+        // Tag vanilla-dependent results with cache provenance so clients never read a
+        // mod-only answer as complete.
+        const withVanilla = (0, cwtools_shared_1.annotateVanillaCache)(name, result, host.vanillaCache);
+        // For load-dependent tools, mark results produced before the game is ready as
+        // `loading` so clients retry instead of trusting an empty answer.
+        if (!cwtools_shared_1.LOAD_DEPENDENT_TOOLS.has(name))
+            return withVanilla;
+        return (0, cwtools_shared_1.annotateReadiness)(name, withVanilla, await probeReadiness());
+    };
+}
+function toMcpCallToolResult(result) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `${JSON.stringify(result, null, 2)}\n`,
+            },
+        ],
+        isError: !result.ok,
+    };
+}

package/dist/mcp/toolRegistrar.d.ts

@@ -0,0 +1,2 @@
+import { type McpToolSchema } from 'cwtools-shared';
+export declare function listRegisteredTools(): McpToolSchema[];

package/dist/mcp/toolRegistrar.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listRegisteredTools = listRegisteredTools;
+const cwtools_shared_1 = require("cwtools-shared");
+function listRegisteredTools() {
+    return (0, cwtools_shared_1.listMcpToolSchemas)();
+}

package/dist/mcp/transportHttp.d.ts

@@ -0,0 +1,7 @@
+import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
+export interface HttpTransportOptions {
+    host: string;
+    port: number;
+    path?: string;
+}
+export declare function runHttpTransport(createServer: () => Server, options: HttpTransportOptions): Promise<void>;

package/dist/mcp/transportHttp.js

@@ -0,0 +1,101 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runHttpTransport = runHttpTransport;
+const http = __importStar(require("http"));
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+async function runHttpTransport(createServer, options) {
+    const endpointPath = options.path ?? '/mcp';
+    const httpServer = http.createServer(async (request, response) => {
+        const url = new URL(request.url ?? '/', `http://${request.headers.host ?? `${options.host}:${options.port}`}`);
+        if (url.pathname === '/healthz') {
+            response.writeHead(200, { 'content-type': 'application/json' });
+            response.end(JSON.stringify({ ok: true, name: 'cwtools-mcp' }));
+            return;
+        }
+        if (url.pathname !== endpointPath) {
+            response.writeHead(404, { 'content-type': 'application/json' });
+            response.end(JSON.stringify({ error: 'not_found' }));
+            return;
+        }
+        if (!['GET', 'POST', 'DELETE'].includes(request.method ?? '')) {
+            response.writeHead(405, { 'content-type': 'application/json' });
+            response.end(JSON.stringify({ error: 'method_not_allowed' }));
+            return;
+        }
+        const requestServer = createServer();
+        const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+            sessionIdGenerator: undefined,
+        });
+        try {
+            await requestServer.connect(transport);
+            await transport.handleRequest(request, response);
+        }
+        catch (error) {
+            if (!response.headersSent) {
+                response.writeHead(500, { 'content-type': 'application/json' });
+            }
+            response.end(JSON.stringify({
+                jsonrpc: '2.0',
+                error: {
+                    code: -32603,
+                    message: error instanceof Error ? error.message : String(error),
+                },
+                id: null,
+            }));
+        }
+        finally {
+            response.once('close', () => {
+                transport.close().catch(() => undefined);
+                requestServer.close();
+            });
+        }
+    });
+    await new Promise((resolve, reject) => {
+        httpServer.once('error', reject);
+        httpServer.listen(options.port, options.host, () => {
+            httpServer.off('error', reject);
+            console.error(`[cwtools-mcp] Streamable HTTP listening at http://${options.host}:${options.port}${endpointPath}`);
+            resolve();
+        });
+    });
+    await new Promise(resolve => {
+        const shutdown = async () => {
+            httpServer.close(() => resolve());
+        };
+        process.once('SIGINT', shutdown);
+        process.once('SIGTERM', shutdown);
+    });
+}

package/dist/mcp/transportStdio.d.ts

@@ -0,0 +1,2 @@
+import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
+export declare function runStdioTransport(server: Server): Promise<void>;

package/dist/mcp/transportStdio.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runStdioTransport = runStdioTransport;
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+async function runStdioTransport(server) {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+}

package/dist/server.d.ts

@@ -0,0 +1,5 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import type { HostServices, SharedToolDispatcher } from 'cwtools-shared';
+export declare function createCwtoolsMcpServer(host: HostServices, options?: {
+    dispatcher?: SharedToolDispatcher;
+}): Server;