bytespost-canvas 0.1.0

package/dist/daemon.js

@@ -0,0 +1,475 @@
+/**
+ * Agent-bridge daemon (SLICE 1).
+ *
+ * Standalone Node process. It does two things:
+ *   1. Serves a tiny localhost-only HTTP API (health + screenshot).
+ *   2. Hosts a WebSocket hub at `/agent` that the browser canvas connects OUT
+ *      to at boot (a tab cannot listen for sockets, so it dials us).
+ *
+ * Each HTTP request is relayed to the connected canvas as a `BridgeCommand`
+ * over WS; we await the id-correlated `BridgeReply` and turn it into the HTTP
+ * response. localhost-only and opt-in by design.
+ */
+import { createServer } from 'node:http';
+import { randomUUID } from 'node:crypto';
+import { WebSocketServer } from 'ws';
+import { PROTOCOL_VERSION, } from './protocol.js';
+const HOST = '127.0.0.1';
+const DEFAULT_PORT = 7777;
+const REQUEST_TIMEOUT_MS = 10_000;
+const WS_PATH = '/agent';
+export function resolvePort() {
+    const raw = process.env.CANVAS_BRIDGE_PORT;
+    if (!raw) {
+        return DEFAULT_PORT;
+    }
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isFinite(parsed) && parsed > 0 && parsed < 65_536 ? parsed : DEFAULT_PORT;
+}
+/**
+ * Start the daemon. Resolves once HTTP is listening. The returned handle can
+ * close both the HTTP and WS servers.
+ */
+export function startDaemon(port = resolvePort()) {
+    const tabs = new Map();
+    const socketTabIds = new Map();
+    const pending = new Map();
+    const settle = (id, run) => {
+        const req = pending.get(id);
+        if (!req) {
+            return;
+        }
+        pending.delete(id);
+        clearTimeout(req.timer);
+        run(req);
+    };
+    const sendCommand = (tab, command) => {
+        return new Promise((resolve, reject) => {
+            if (!tab.socket || tab.socket.readyState !== tab.socket.OPEN) {
+                reject(new Error('NO_CANVAS'));
+                return;
+            }
+            const timer = setTimeout(() => {
+                settle(command.id, (req) => req.reject(new Error('TIMEOUT')));
+            }, REQUEST_TIMEOUT_MS);
+            pending.set(command.id, { resolve, reject, timer });
+            try {
+                tab.info.lastSeenAt = new Date().toISOString();
+                tab.socket.send(JSON.stringify(command));
+            }
+            catch (error) {
+                settle(command.id, (req) => req.reject(error instanceof Error ? error : new Error(String(error))));
+            }
+        });
+    };
+    const httpServer = createServer((req, res) => {
+        // Permit the in-browser chat agent to fetch us. The daemon is bound to
+        // 127.0.0.1 so reflecting the origin (vs `*`) lets us keep cookies-allowed
+        // semantics if a future tool needs them. Preflight is short-circuited.
+        const origin = req.headers.origin;
+        if (origin) {
+            res.setHeader('Access-Control-Allow-Origin', origin);
+            res.setHeader('Vary', 'Origin');
+            res.setHeader('Access-Control-Allow-Credentials', 'true');
+        }
+        else {
+            res.setHeader('Access-Control-Allow-Origin', '*');
+        }
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PATCH, PUT, DELETE, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'content-type, x-canvas-tab');
+        res.setHeader('Access-Control-Max-Age', '86400');
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204).end();
+            return;
+        }
+        handleHttp(req, res, {
+            listTabs: () => listOpenTabs(tabs),
+            findTab: (tabId) => {
+                const tab = tabs.get(tabId);
+                return tab && tab.socket.readyState === tab.socket.OPEN ? tab : null;
+            },
+            sendCommand,
+        }).catch((error) => {
+            const maybeRelay = error;
+            if (typeof maybeRelay.status === 'number') {
+                sendJson(res, maybeRelay.status, maybeRelay.body ?? { error: { code: 'ERROR', message: 'request failed' } });
+                return;
+            }
+            sendError(res, 500, 'INTERNAL_ERROR', error instanceof Error ? error.message : String(error));
+        });
+    });
+    const wss = new WebSocketServer({ server: httpServer, path: WS_PATH });
+    wss.on('connection', (socket) => {
+        const fallbackTab = registerTab(tabs, socketTabIds, socket, {
+            id: `tab_${randomUUID().slice(0, 8)}`,
+            title: 'Canvas',
+            ready: false,
+            capabilities: [],
+        });
+        console.log('[agent-bridge] canvas connected', fallbackTab.info.id);
+        socket.on('message', (raw) => {
+            let message;
+            try {
+                message = JSON.parse(typeof raw === 'string' ? raw : raw.toString());
+            }
+            catch {
+                return;
+            }
+            if (isBrowserHello(message)) {
+                const tab = registerTab(tabs, socketTabIds, socket, message.tab);
+                console.log('[agent-bridge] tab registered', tab.info.id);
+                return;
+            }
+            if (!message || typeof message.id !== 'string') {
+                return;
+            }
+            settle(message.id, (request) => request.resolve(message));
+        });
+        socket.on('close', () => {
+            const tabId = socketTabIds.get(socket);
+            if (tabId) {
+                socketTabIds.delete(socket);
+                tabs.delete(tabId);
+                console.log('[agent-bridge] canvas disconnected', tabId);
+            }
+        });
+        socket.on('error', () => {
+            /* swallow — close handler clears the ref */
+        });
+    });
+    return new Promise((resolve, reject) => {
+        httpServer.once('error', reject);
+        httpServer.listen(port, HOST, () => {
+            httpServer.off('error', reject);
+            console.log(`[agent-bridge] daemon listening on http://${HOST}:${port} (ws ${WS_PATH})`);
+            resolve({
+                port,
+                close: () => new Promise((done) => {
+                    for (const [, req] of pending) {
+                        clearTimeout(req.timer);
+                        req.reject(new Error('SHUTDOWN'));
+                    }
+                    pending.clear();
+                    wss.close();
+                    httpServer.close(() => done());
+                }),
+            });
+        });
+    });
+}
+async function handleHttp(req, res, deps) {
+    const url = new URL(req.url ?? '/', `http://${HOST}`);
+    const pathname = url.pathname;
+    if (req.method === 'GET' && pathname === '/v1/health') {
+        const tabs = deps.listTabs();
+        const body = {
+            canvasConnected: tabs.length > 0,
+            tabCount: tabs.length,
+            version: PROTOCOL_VERSION,
+        };
+        sendJson(res, 200, body);
+        return;
+    }
+    if (req.method === 'GET' && pathname === '/v1/tabs') {
+        sendJson(res, 200, { tabs: deps.listTabs().map((tab) => serializeTab(tab)) });
+        return;
+    }
+    const tabInfoMatch = pathname.match(/^\/v1\/tabs\/([^/]+)$/);
+    if (req.method === 'GET' && tabInfoMatch) {
+        const tab = deps.findTab(decodeURIComponent(tabInfoMatch[1]));
+        if (!tab) {
+            sendError(res, 404, 'TAB_NOT_FOUND', `No connected tab ${tabInfoMatch[1]}`);
+            return;
+        }
+        sendJson(res, 200, { tab: serializeTab(tab) });
+        return;
+    }
+    if (req.method === 'GET' && pathname === '/v1/screenshot') {
+        const reply = await relayToSelectedTab(url, deps, { type: 'screenshot' });
+        if (reply.type !== 'screenshot') {
+            sendError(res, 502, 'UNEXPECTED_REPLY', 'unexpected reply type');
+            return;
+        }
+        const png = Buffer.from(reply.data.pngBase64, 'base64');
+        res.writeHead(200, {
+            'content-type': 'image/png',
+            'content-length': String(png.byteLength),
+            'cache-control': 'no-store',
+        });
+        res.end(png);
+        return;
+    }
+    if (req.method === 'POST' && pathname === '/v1/draw') {
+        let body;
+        try {
+            const raw = await readBody(req);
+            const parsed = JSON.parse(raw);
+            body = validateDrawRequest(parsed);
+        }
+        catch (error) {
+            sendError(res, 400, 'BAD_REQUEST', error instanceof Error ? error.message : 'invalid JSON body');
+            return;
+        }
+        const reply = await relayToSelectedTab(url, deps, { type: 'draw', body: { nodes: body.nodes } });
+        if (reply.type !== 'draw') {
+            sendError(res, 502, 'UNEXPECTED_REPLY', 'unexpected reply type');
+            return;
+        }
+        sendJson(res, 200, { nodeIds: reply.data.nodeIds });
+        return;
+    }
+    if (req.method === 'GET' && pathname === '/v1/document') {
+        const reply = await relayToSelectedTab(url, deps, { type: 'document_get' });
+        sendJson(res, 200, reply.data);
+        return;
+    }
+    if (req.method === 'GET' && pathname === '/v1/document/nodes') {
+        const reply = await relayToSelectedTab(url, deps, { type: 'document_nodes' });
+        sendJson(res, 200, reply.data);
+        return;
+    }
+    const nodeMatch = pathname.match(/^\/v1\/node\/([^/]+)$/);
+    if (nodeMatch && req.method === 'GET') {
+        const reply = await relayToSelectedTab(url, deps, {
+            type: 'node_get',
+            body: { nodeId: decodeURIComponent(nodeMatch[1]) },
+        });
+        sendJson(res, 200, reply.data);
+        return;
+    }
+    if (nodeMatch && req.method === 'DELETE') {
+        const reply = await relayToSelectedTab(url, deps, {
+            type: 'node_delete',
+            body: { nodeId: decodeURIComponent(nodeMatch[1]) },
+        });
+        sendJson(res, 200, reply.data);
+        return;
+    }
+    if (nodeMatch && (req.method === 'PATCH' || req.method === 'PUT')) {
+        const raw = await readBody(req);
+        const parsed = parseJsonBody(raw);
+        const reply = await relayToSelectedTab(url, deps, {
+            type: 'node_update',
+            body: { nodeId: decodeURIComponent(nodeMatch[1]), patch: asObject(parsed.patch ?? parsed) },
+        });
+        sendJson(res, 200, reply.data);
+        return;
+    }
+    if (req.method === 'POST' && pathname === '/v1/select') {
+        const parsed = parseJsonBody(await readBody(req));
+        const nodeIds = Array.isArray(parsed.nodeIds)
+            ? parsed.nodeIds.filter((id) => typeof id === 'string')
+            : typeof parsed.nodeId === 'string'
+                ? [parsed.nodeId]
+                : [];
+        const reply = await relayToSelectedTab(url, deps, { type: 'select_set', body: { nodeIds } });
+        sendJson(res, 200, reply.data);
+        return;
+    }
+    if (req.method === 'POST' && pathname === '/v1/select/clear') {
+        const reply = await relayToSelectedTab(url, deps, { type: 'select_clear' });
+        sendJson(res, 200, reply.data);
+        return;
+    }
+    if (req.method === 'POST' && pathname === '/v1/viewport/fit') {
+        const reply = await relayToSelectedTab(url, deps, { type: 'viewport_fit' });
+        sendJson(res, 200, reply.data);
+        return;
+    }
+    if (req.method === 'POST' && pathname === '/v1/viewport/zoom') {
+        const parsed = parseJsonBody(await readBody(req));
+        const queryZoom = url.searchParams.get('zoom');
+        const zoom = typeof parsed.zoom === 'number' ? parsed.zoom : queryZoom ? Number(queryZoom) : undefined;
+        const reply = await relayToSelectedTab(url, deps, { type: 'viewport_zoom', body: { zoom } });
+        sendJson(res, 200, reply.data);
+        return;
+    }
+    if (req.method === 'POST' && pathname === '/v1/building') {
+        const parsed = parseJsonBody(await readBody(req));
+        const buildingType = typeof parsed.buildingType === 'string' ? parsed.buildingType : undefined;
+        const input = asObject(parsed.input ?? parsed);
+        const reply = await relayToSelectedTab(url, deps, { type: 'building_create', body: { buildingType, input } });
+        sendJson(res, 200, reply.data);
+        return;
+    }
+    if (req.method === 'POST' && pathname === '/v1/command') {
+        const parsed = parseJsonBody(await readBody(req));
+        if (typeof parsed.type !== 'string') {
+            sendError(res, 400, 'BAD_REQUEST', 'command type is required');
+            return;
+        }
+        const reply = await relayToSelectedTab(url, deps, {
+            type: parsed.type,
+            body: asObject(parsed),
+        });
+        sendJson(res, 200, reply.data);
+        return;
+    }
+    sendError(res, 404, 'NOT_FOUND', 'not found');
+}
+/** Read a request body with a small cap so a stray client cannot OOM the daemon. */
+function readBody(req, limitBytes = 1_000_000) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        req.on('data', (chunk) => {
+            size += chunk.length;
+            if (size > limitBytes) {
+                reject(new Error('request body too large'));
+                req.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+        req.on('error', reject);
+    });
+}
+/**
+ * Shallow-validate the draw body. The browser side does the authoritative
+ * per-type validation when constructing NodeIR; here we only guarantee a
+ * well-formed `{nodes: [...]}` envelope so bad input fails fast as 400.
+ */
+function validateDrawRequest(value) {
+    if (!value || typeof value !== 'object') {
+        throw new Error('body must be a JSON object');
+    }
+    const nodes = value.nodes;
+    if (!Array.isArray(nodes) || nodes.length === 0) {
+        throw new Error('body.nodes must be a non-empty array');
+    }
+    for (const node of nodes) {
+        if (!node || typeof node !== 'object' || typeof node.type !== 'string') {
+            throw new Error('each node must be an object with a string "type"');
+        }
+    }
+    return { nodes: nodes };
+}
+function listOpenTabs(tabs) {
+    return Array.from(tabs.values())
+        .filter((tab) => tab.socket.readyState === tab.socket.OPEN)
+        .sort((a, b) => a.info.id.localeCompare(b.info.id));
+}
+function serializeTab(tab) {
+    return {
+        id: tab.info.id,
+        title: tab.info.title,
+        app: tab.info.app,
+        url: tab.info.url,
+        canvasType: tab.info.canvasType,
+        ready: tab.info.ready,
+        document: tab.info.document,
+        capabilities: tab.info.capabilities ?? [],
+        connectedAt: tab.info.connectedAt,
+        lastSeenAt: tab.info.lastSeenAt,
+    };
+}
+function registerTab(tabs, socketTabIds, socket, input) {
+    const now = new Date().toISOString();
+    const previousId = socketTabIds.get(socket);
+    const previous = previousId ? tabs.get(previousId) : null;
+    const id = input.id || previousId || `tab_${randomUUID().slice(0, 8)}`;
+    if (previousId && previousId !== id) {
+        tabs.delete(previousId);
+    }
+    const info = {
+        ...(previous?.info ?? {}),
+        ...input,
+        id,
+        connectedAt: previous?.info.connectedAt ?? now,
+        lastSeenAt: now,
+        capabilities: input.capabilities ?? previous?.info.capabilities ?? [],
+    };
+    const tab = { socket, info };
+    tabs.set(id, tab);
+    socketTabIds.set(socket, id);
+    return tab;
+}
+function isBrowserHello(message) {
+    return Boolean(message &&
+        message.type === 'hello' &&
+        message.tab &&
+        typeof message.tab === 'object');
+}
+async function relayToSelectedTab(url, deps, route) {
+    const tab = selectTab(url.searchParams.get('tab'), deps);
+    let reply;
+    try {
+        reply = await deps.sendCommand(tab, {
+            id: randomUUID(),
+            type: route.type,
+            ...route.body,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message === 'TIMEOUT') {
+            throw relayError(504, 'TIMEOUT', 'canvas did not reply within 10s');
+        }
+        if (message === 'NO_CANVAS') {
+            throw relayError(503, 'NO_TABS', 'no canvas connected');
+        }
+        throw relayError(502, 'RELAY_ERROR', message);
+    }
+    if (!reply.ok) {
+        throw relayError(502, 'TAB_COMMAND_FAILED', reply.error);
+    }
+    const expectedType = route.expectedType ?? route.type;
+    if (reply.type !== expectedType) {
+        throw relayError(502, 'UNEXPECTED_REPLY', `expected ${expectedType}, got ${reply.type}`);
+    }
+    return reply;
+}
+function selectTab(tabId, deps) {
+    if (tabId) {
+        const tab = deps.findTab(tabId);
+        if (!tab) {
+            throw relayError(404, 'TAB_NOT_FOUND', `No connected tab ${tabId}`);
+        }
+        return tab;
+    }
+    const tabs = deps.listTabs();
+    if (tabs.length === 0) {
+        throw relayError(503, 'NO_TABS', 'no canvas connected');
+    }
+    if (tabs.length > 1) {
+        throw relayError(409, 'TAB_REQUIRED', 'Multiple tabs are connected; pass ?tab=<id>.', {
+            availableTabs: tabs.map((tab) => tab.info.id),
+        });
+    }
+    return tabs[0];
+}
+function relayError(status, code, message, extras = {}) {
+    return {
+        status,
+        body: {
+            error: {
+                code,
+                message,
+                ...extras,
+            },
+        },
+    };
+}
+function parseJsonBody(raw) {
+    if (!raw.trim()) {
+        return {};
+    }
+    const parsed = JSON.parse(raw);
+    return asObject(parsed);
+}
+function asObject(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function sendError(res, status, code, message) {
+    sendJson(res, status, { error: { code, message } });
+}
+function sendJson(res, status, body) {
+    const text = JSON.stringify(body);
+    res.writeHead(status, {
+        'content-type': 'application/json',
+        'content-length': String(Buffer.byteLength(text)),
+        'cache-control': 'no-store',
+    });
+    res.end(text);
+}

package/dist/mcp.d.ts

@@ -0,0 +1 @@
+export declare function runMcpServer(): Promise<void>;

package/dist/mcp.js

@@ -0,0 +1,143 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { resolvePort } from './daemon.js';
+const HOST = '127.0.0.1';
+function baseUrl() {
+    return `http://${HOST}:${resolvePort()}`;
+}
+function tabQuery(tab) {
+    return tab ? `?tab=${encodeURIComponent(tab)}` : '';
+}
+async function requestJson(path, init) {
+    const res = await fetch(`${baseUrl()}${path}`, init);
+    const text = await res.text();
+    const body = text ? JSON.parse(text) : {};
+    if (!res.ok) {
+        throw new Error(JSON.stringify(body));
+    }
+    return body;
+}
+async function requestPngBase64(path) {
+    const res = await fetch(`${baseUrl()}${path}`);
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(text || `HTTP ${res.status}`);
+    }
+    const bytes = Buffer.from(await res.arrayBuffer());
+    return bytes.toString('base64');
+}
+function textResult(value) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: typeof value === 'string' ? value : JSON.stringify(value, null, 2),
+            },
+        ],
+    };
+}
+export async function runMcpServer() {
+    const server = new McpServer({
+        name: 'canvas-control-plane',
+        version: '0.1.0',
+    });
+    server.registerTool('canvas_ls', {
+        description: 'List every open Canvas editor tab connected to the local daemon.',
+        inputSchema: {},
+    }, async () => textResult(await requestJson('/v1/tabs')));
+    server.registerTool('canvas_tab_info', {
+        description: 'Get metadata for one connected Canvas tab.',
+        inputSchema: { tab: z.string() },
+    }, async ({ tab }) => textResult(await requestJson(`/v1/tabs/${encodeURIComponent(tab)}`)));
+    server.registerTool('canvas_document_get', {
+        description: 'Read the active document from a Canvas tab.',
+        inputSchema: { tab: z.string().optional() },
+    }, async ({ tab }) => textResult(await requestJson(`/v1/document${tabQuery(tab)}`)));
+    server.registerTool('canvas_document_nodes', {
+        description: 'List flattened nodes in the active document.',
+        inputSchema: { tab: z.string().optional() },
+    }, async ({ tab }) => textResult(await requestJson(`/v1/document/nodes${tabQuery(tab)}`)));
+    server.registerTool('canvas_draw', {
+        description: 'Create one or more 2D nodes in a Canvas tab. Supports rect, frame, text, and line specs.',
+        inputSchema: {
+            tab: z.string().optional(),
+            nodes: z.array(z.record(z.string(), z.unknown())).min(1),
+        },
+    }, async ({ tab, nodes }) => textResult(await requestJson(`/v1/draw${tabQuery(tab)}`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ nodes }),
+    })));
+    server.registerTool('canvas_node_get', {
+        description: 'Get one node by id.',
+        inputSchema: { tab: z.string().optional(), nodeId: z.string() },
+    }, async ({ tab, nodeId }) => textResult(await requestJson(`/v1/node/${encodeURIComponent(nodeId)}${tabQuery(tab)}`)));
+    server.registerTool('canvas_node_update', {
+        description: 'Apply a shallow patch to one node.',
+        inputSchema: {
+            tab: z.string().optional(),
+            nodeId: z.string(),
+            patch: z.record(z.string(), z.unknown()),
+        },
+    }, async ({ tab, nodeId, patch }) => textResult(await requestJson(`/v1/node/${encodeURIComponent(nodeId)}${tabQuery(tab)}`, {
+        method: 'PATCH',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ patch }),
+    })));
+    server.registerTool('canvas_node_delete', {
+        description: 'Delete one node by id.',
+        inputSchema: { tab: z.string().optional(), nodeId: z.string() },
+    }, async ({ tab, nodeId }) => textResult(await requestJson(`/v1/node/${encodeURIComponent(nodeId)}${tabQuery(tab)}`, {
+        method: 'DELETE',
+    })));
+    server.registerTool('canvas_select_set', {
+        description: 'Set the current selection to a list of node ids.',
+        inputSchema: { tab: z.string().optional(), nodeIds: z.array(z.string()) },
+    }, async ({ tab, nodeIds }) => textResult(await requestJson(`/v1/select${tabQuery(tab)}`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ nodeIds }),
+    })));
+    server.registerTool('canvas_select_clear', {
+        description: 'Clear the current selection.',
+        inputSchema: { tab: z.string().optional() },
+    }, async ({ tab }) => textResult(await requestJson(`/v1/select/clear${tabQuery(tab)}`, { method: 'POST' })));
+    server.registerTool('canvas_viewport_screenshot', {
+        description: 'Return a PNG screenshot from a Canvas tab as MCP image content.',
+        inputSchema: { tab: z.string().optional() },
+    }, async ({ tab }) => ({
+        content: [
+            {
+                type: 'image',
+                data: await requestPngBase64(`/v1/screenshot${tabQuery(tab)}`),
+                mimeType: 'image/png',
+            },
+        ],
+    }));
+    server.registerTool('canvas_viewport_fit', {
+        description: 'Fit the viewport to the document.',
+        inputSchema: { tab: z.string().optional() },
+    }, async ({ tab }) => textResult(await requestJson(`/v1/viewport/fit${tabQuery(tab)}`, { method: 'POST' })));
+    server.registerTool('canvas_viewport_zoom', {
+        description: 'Set the viewport zoom.',
+        inputSchema: { tab: z.string().optional(), zoom: z.number() },
+    }, async ({ tab, zoom }) => textResult(await requestJson(`/v1/viewport/zoom${tabQuery(tab)}`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ zoom }),
+    })));
+    server.registerTool('canvas_building_create', {
+        description: 'Call a building-design creation tool such as wall, room, slab, roof, door, window, zone, or furniture.',
+        inputSchema: {
+            tab: z.string().optional(),
+            buildingType: z.string(),
+            input: z.record(z.string(), z.unknown()).default({}),
+        },
+    }, async ({ tab, buildingType, input }) => textResult(await requestJson(`/v1/building${tabQuery(tab)}`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ buildingType, input }),
+    })));
+    await server.connect(new StdioServerTransport());
+}