gopeak 2.1.0 → 2.2.1

package/build/godot-bridge.js

@@ -0,0 +1,556 @@
+import { randomUUID } from 'node:crypto';
+import { EventEmitter } from 'node:events';
+import { readFileSync } from 'node:fs';
+import http from 'node:http';
+import { WebSocket, WebSocketServer } from 'ws';
+const DEFAULT_PORT = 6505;
+const DEFAULT_HOST = '127.0.0.1';
+const DEFAULT_TIMEOUT_MS = 30_000;
+const KEEPALIVE_INTERVAL_MS = 10_000;
+const SECOND_CONNECTION_CLOSE_CODE = 4000;
+const BRIDGE_PORT_ENV_KEYS = ['GODOT_BRIDGE_PORT', 'MCP_BRIDGE_PORT', 'GOPEAK_BRIDGE_PORT'];
+const BRIDGE_HOST_ENV_KEYS = ['GODOT_BRIDGE_HOST', 'MCP_BRIDGE_HOST', 'GOPEAK_BRIDGE_HOST'];
+const BRIDGE_VERSION = (() => {
+    try {
+        const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+        return typeof pkg.version === 'string' ? pkg.version : '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+})();
+function resolveDefaultBridgePort() {
+    for (const key of BRIDGE_PORT_ENV_KEYS) {
+        const raw = process.env[key];
+        if (!raw || raw.trim().length === 0) {
+            continue;
+        }
+        const parsed = Number.parseInt(raw, 10);
+        if (Number.isInteger(parsed) && parsed >= 1 && parsed <= 65535) {
+            return parsed;
+        }
+        console.error(`[GodotBridge] Ignoring invalid ${key}="${raw}". Expected an integer between 1 and 65535.`);
+    }
+    return DEFAULT_PORT;
+}
+function resolveDefaultBridgeHost() {
+    for (const key of BRIDGE_HOST_ENV_KEYS) {
+        const raw = process.env[key];
+        if (!raw) {
+            continue;
+        }
+        const host = raw.trim();
+        if (host.length > 0) {
+            return host;
+        }
+    }
+    return DEFAULT_HOST;
+}
+export class GodotBridge extends EventEmitter {
+    port;
+    host;
+    timeoutMs;
+    httpServer = null;
+    godotWss = null;
+    vizWss = null;
+    socket = null;
+    pingInterval = null;
+    connectionInfo = null;
+    pendingRequests = new Map();
+    resourceQueues = new Map();
+    visualizerHtml = this.getDefaultVisualizerHtml();
+    constructor(port = DEFAULT_PORT, host = DEFAULT_HOST, timeoutMs = DEFAULT_TIMEOUT_MS) {
+        super();
+        this.port = port;
+        this.host = host;
+        this.timeoutMs = timeoutMs;
+    }
+    start() {
+        if (this.httpServer) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve, reject) => {
+            const server = http.createServer((req, res) => {
+                this.handleHttpRequest(req, res);
+            });
+            const godotWss = new WebSocketServer({ noServer: true });
+            const vizWss = new WebSocketServer({ noServer: true });
+            let settled = false;
+            server.on('upgrade', (request, socket, head) => {
+                const pathname = this.getRequestPathname(request.url);
+                const target = pathname === '/godot' ? godotWss : vizWss;
+                target.handleUpgrade(request, socket, head, (ws) => {
+                    target.emit('connection', ws, request);
+                });
+            });
+            godotWss.on('connection', (socket) => {
+                this.handleConnection(socket);
+            });
+            server.once('listening', () => {
+                settled = true;
+                this.httpServer = server;
+                this.godotWss = godotWss;
+                this.vizWss = vizWss;
+                this.log('info', `Unified HTTP+WS bridge listening on ${this.host}:${this.port}`);
+                resolve();
+            });
+            server.once('error', (error) => {
+                if (!settled) {
+                    settled = true;
+                    reject(error);
+                    return;
+                }
+                this.log('error', `HTTP server error: ${error.message}`);
+            });
+            godotWss.on('error', (error) => {
+                this.log('error', `Godot WebSocket server error: ${error.message}`);
+            });
+            vizWss.on('error', (error) => {
+                this.log('error', `Visualizer WebSocket server error: ${error.message}`);
+            });
+            server.listen(this.port, this.host);
+        });
+    }
+    async stop() {
+        this.stopKeepalive();
+        this.rejectAllPending(new Error('GodotBridge stopped'));
+        this.resourceQueues.clear();
+        const closeTasks = [];
+        if (this.socket) {
+            try {
+                this.socket.close();
+            }
+            catch {
+            }
+            this.socket = null;
+        }
+        if (this.godotWss) {
+            const godotWss = this.godotWss;
+            for (const client of godotWss.clients) {
+                try {
+                    client.close();
+                }
+                catch {
+                }
+            }
+            closeTasks.push(this.closeWebSocketServer(godotWss));
+            this.godotWss = null;
+        }
+        if (this.vizWss) {
+            const vizWss = this.vizWss;
+            for (const client of vizWss.clients) {
+                try {
+                    client.close();
+                }
+                catch {
+                }
+            }
+            closeTasks.push(this.closeWebSocketServer(vizWss));
+            this.vizWss = null;
+        }
+        if (this.httpServer) {
+            const httpServer = this.httpServer;
+            closeTasks.push(this.closeHttpServer(httpServer));
+            this.httpServer = null;
+        }
+        await Promise.all(closeTasks);
+        this.connectionInfo = null;
+        this.visualizerHtml = this.getDefaultVisualizerHtml();
+        this.log('info', 'WebSocket bridge stopped');
+    }
+    isConnected() {
+        return this.socket?.readyState === WebSocket.OPEN;
+    }
+    getStatus() {
+        return {
+            host: this.host,
+            port: this.port,
+            connected: this.isConnected(),
+            projectPath: this.connectionInfo?.projectPath,
+            connectedAt: this.connectionInfo?.connectedAt,
+            lastPongAt: this.connectionInfo?.lastPongAt,
+            pendingRequests: this.pendingRequests.size,
+            queuedResources: this.resourceQueues.size,
+        };
+    }
+    invokeTool(toolName, args) {
+        const resourceKey = this.getResourceKey(args);
+        if (!resourceKey) {
+            return this.invokeToolDirect(toolName, args);
+        }
+        return this.enqueueResourceRequest(resourceKey, () => this.invokeToolDirect(toolName, args, resourceKey));
+    }
+    getVisualizerWss() {
+        return this.vizWss;
+    }
+    broadcastToVisualizer(message) {
+        if (!this.vizWss) {
+            return;
+        }
+        const payload = JSON.stringify(message);
+        this.vizWss.clients.forEach((client) => {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(payload);
+            }
+        });
+    }
+    setVisualizerHtml(html) {
+        this.visualizerHtml = html;
+    }
+    handleHttpRequest(req, res) {
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Accept');
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        if (req.method === 'POST' && (this.getRequestPathname(req.url) === '/' || this.getRequestPathname(req.url) === '/mcp')) {
+            let body = '';
+            req.on('data', (chunk) => {
+                body += chunk.toString();
+            });
+            req.on('end', () => {
+                try {
+                    const parsed = JSON.parse(body);
+                    if (parsed.method === 'initialize') {
+                        res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({
+                            jsonrpc: '2.0',
+                            id: typeof parsed.id === 'number' || typeof parsed.id === 'string' ? parsed.id : 1,
+                            result: {
+                                protocolVersion: typeof parsed.params?.protocolVersion === 'string' ? parsed.params.protocolVersion : '2025-06-18',
+                                capabilities: {},
+                                serverInfo: { name: 'gopeak', version: BRIDGE_VERSION },
+                            },
+                        }));
+                        return;
+                    }
+                    res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(JSON.stringify({ error: 'Unsupported method' }));
+                }
+                catch {
+                    res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(JSON.stringify({ error: 'Invalid JSON' }));
+                }
+            });
+            return;
+        }
+        if (req.method !== 'GET') {
+            res.writeHead(405, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Method not allowed' }));
+            return;
+        }
+        const pathname = this.getRequestPathname(req.url);
+        if (pathname === '/health') {
+            const payload = {
+                status: 'ok',
+                serverName: 'gopeak',
+                version: BRIDGE_VERSION,
+                bridge: this.getStatus(),
+                uptime: process.uptime(),
+                timestamp: new Date().toISOString(),
+            };
+            res.writeHead(200, {
+                'Content-Type': 'application/json; charset=utf-8',
+                'Cache-Control': 'no-cache',
+            });
+            res.end(JSON.stringify(payload));
+            return;
+        }
+        if (pathname === '/' || pathname === '/index.html') {
+            res.writeHead(200, {
+                'Content-Type': 'text/html; charset=utf-8',
+                'Cache-Control': 'no-cache',
+            });
+            res.end(this.visualizerHtml);
+            return;
+        }
+        res.writeHead(404, { 'Content-Type': 'application/json; charset=utf-8' });
+        res.end(JSON.stringify({ error: 'Not found' }));
+    }
+    getRequestPathname(url) {
+        try {
+            return new URL(url ?? '/', `http://${this.host}:${this.port}`).pathname;
+        }
+        catch {
+            return '/';
+        }
+    }
+    closeWebSocketServer(server) {
+        return new Promise((resolve) => {
+            let settled = false;
+            const finish = () => {
+                if (!settled) {
+                    settled = true;
+                    resolve();
+                }
+            };
+            try {
+                server.close(() => {
+                    finish();
+                });
+            }
+            catch {
+                finish();
+            }
+        });
+    }
+    closeHttpServer(server) {
+        return new Promise((resolve) => {
+            let settled = false;
+            const finish = () => {
+                if (!settled) {
+                    settled = true;
+                    resolve();
+                }
+            };
+            try {
+                server.close(() => {
+                    finish();
+                });
+            }
+            catch {
+                finish();
+            }
+        });
+    }
+    handleConnection(nextSocket) {
+        if (this.socket && this.socket.readyState !== WebSocket.CLOSED) {
+            this.log('warn', 'Rejecting second Godot connection');
+            nextSocket.close(SECOND_CONNECTION_CLOSE_CODE, 'Godot already connected');
+            return;
+        }
+        this.socket = nextSocket;
+        this.connectionInfo = {
+            connectedAt: new Date(),
+        };
+        this.startKeepalive();
+        this.log('info', 'Godot editor connected');
+        this.emitBridgeEvent('godot_connected', { projectPath: this.connectionInfo.projectPath });
+        nextSocket.on('message', (data) => {
+            this.handleRawMessage(data);
+        });
+        nextSocket.on('close', (code, reasonBuffer) => {
+            const reason = reasonBuffer.toString();
+            this.log('warn', `Godot disconnected (code=${code}, reason=${reason || 'none'})`);
+            this.handleDisconnect(new Error('Godot disconnected during request'));
+        });
+        nextSocket.on('error', (error) => {
+            this.log('error', `WebSocket error: ${error.message}`);
+        });
+    }
+    handleRawMessage(data) {
+        let parsed;
+        try {
+            parsed = JSON.parse(data.toString());
+        }
+        catch (error) {
+            this.log('error', `Invalid JSON from Godot: ${error instanceof Error ? error.message : String(error)}`);
+            return;
+        }
+        if (!this.isIncomingMessage(parsed)) {
+            this.log('warn', 'Ignoring unknown Godot message payload');
+            return;
+        }
+        this.handleMessage(parsed);
+    }
+    handleMessage(message) {
+        switch (message.type) {
+            case 'tool_result': {
+                const pending = this.pendingRequests.get(message.id);
+                if (!pending) {
+                    this.log('warn', `Received tool_result for unknown id=${message.id}`);
+                    return;
+                }
+                clearTimeout(pending.timeout);
+                this.pendingRequests.delete(message.id);
+                const duration = Date.now() - pending.startedAt;
+                this.log('debug', `Tool ${pending.toolName} finished in ${duration}ms`);
+                this.emitBridgeEvent('tool_end', {
+                    tool: pending.toolName,
+                    id: message.id,
+                    success: message.success,
+                    duration,
+                });
+                if (message.success) {
+                    pending.resolve(message.result);
+                }
+                else {
+                    pending.reject(new Error(message.error ?? `Tool ${pending.toolName} failed`));
+                }
+                return;
+            }
+            case 'godot_ready':
+                if (this.connectionInfo) {
+                    this.connectionInfo.projectPath = message.project_path;
+                    this.log('info', `Godot ready: ${message.project_path}`);
+                    this.emitBridgeEvent('godot_connected', { projectPath: message.project_path });
+                }
+                return;
+            case 'pong':
+                if (this.connectionInfo) {
+                    this.connectionInfo.lastPongAt = new Date();
+                }
+                return;
+        }
+    }
+    invokeToolDirect(toolName, args, resourceKey) {
+        if (!this.isConnected()) {
+            return Promise.reject(new Error('Godot is not connected'));
+        }
+        const requestId = randomUUID();
+        const message = {
+            type: 'tool_invoke',
+            id: requestId,
+            tool: toolName,
+            args,
+        };
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(requestId);
+                reject(new Error(`Tool ${toolName} timed out after ${this.timeoutMs}ms`));
+            }, this.timeoutMs);
+            this.pendingRequests.set(requestId, {
+                toolName,
+                timeout,
+                resolve,
+                reject,
+                startedAt: Date.now(),
+                resourceKey,
+            });
+            this.emitBridgeEvent('tool_start', {
+                tool: toolName,
+                id: requestId,
+                args,
+            });
+            try {
+                this.sendMessage(message);
+            }
+            catch (error) {
+                clearTimeout(timeout);
+                this.pendingRequests.delete(requestId);
+                reject(error);
+            }
+        });
+    }
+    sendMessage(message) {
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+            throw new Error('Godot is not connected');
+        }
+        this.socket.send(JSON.stringify(message));
+    }
+    startKeepalive() {
+        this.stopKeepalive();
+        this.pingInterval = setInterval(() => {
+            if (!this.isConnected()) {
+                return;
+            }
+            try {
+                const ping = { type: 'ping' };
+                this.sendMessage(ping);
+            }
+            catch (error) {
+                this.log('warn', `Failed to send ping: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }, KEEPALIVE_INTERVAL_MS);
+    }
+    stopKeepalive() {
+        if (!this.pingInterval) {
+            return;
+        }
+        clearInterval(this.pingInterval);
+        this.pingInterval = null;
+    }
+    handleDisconnect(reason) {
+        this.stopKeepalive();
+        this.socket = null;
+        this.connectionInfo = null;
+        this.emitBridgeEvent('godot_disconnected', {});
+        this.rejectAllPending(reason);
+        this.resourceQueues.clear();
+    }
+    emitBridgeEvent(eventName, payload) {
+        this.emit(eventName, payload);
+    }
+    getDefaultVisualizerHtml() {
+        return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Godot MCP Visualizer</title>
+  </head>
+  <body>
+    <h1>Godot MCP Visualizer</h1>
+    <p>Run the map_project tool to load visualization data.</p>
+  </body>
+</html>`;
+    }
+    rejectAllPending(error) {
+        for (const pending of this.pendingRequests.values()) {
+            clearTimeout(pending.timeout);
+            pending.reject(error);
+        }
+        this.pendingRequests.clear();
+    }
+    enqueueResourceRequest(resourceKey, task) {
+        const previous = this.resourceQueues.get(resourceKey) ?? Promise.resolve();
+        const taskPromise = previous.catch(() => undefined).then(task);
+        const tail = taskPromise.then(() => undefined, () => undefined);
+        this.resourceQueues.set(resourceKey, tail);
+        return taskPromise.finally(() => {
+            if (this.resourceQueues.get(resourceKey) === tail) {
+                this.resourceQueues.delete(resourceKey);
+            }
+        });
+    }
+    getResourceKey(args) {
+        const scenePath = this.getStringArg(args, 'scenePath') ?? this.getStringArg(args, 'scene_path');
+        if (scenePath) {
+            return `scene:${scenePath}`;
+        }
+        const resourcePath = this.getStringArg(args, 'resourcePath') ?? this.getStringArg(args, 'resource_path');
+        if (resourcePath) {
+            return `resource:${resourcePath}`;
+        }
+        return undefined;
+    }
+    getStringArg(args, key) {
+        const value = args[key];
+        return typeof value === 'string' && value.length > 0 ? value : undefined;
+    }
+    isIncomingMessage(value) {
+        if (!value || typeof value !== 'object') {
+            return false;
+        }
+        const message = value;
+        const type = message.type;
+        if (type !== 'tool_result' && type !== 'pong' && type !== 'godot_ready') {
+            return false;
+        }
+        if (type === 'pong') {
+            return true;
+        }
+        if (type === 'godot_ready') {
+            return typeof message.project_path === 'string';
+        }
+        return (typeof message.id === 'string' &&
+            typeof message.success === 'boolean' &&
+            (message.error === undefined || typeof message.error === 'string'));
+    }
+    log(level, message) {
+        console.error(`[${new Date().toISOString()}] [GodotBridge:${level.toUpperCase()}] ${message}`);
+    }
+}
+let defaultBridge = null;
+export function getDefaultBridge() {
+    if (!defaultBridge) {
+        defaultBridge = new GodotBridge(resolveDefaultBridgePort(), resolveDefaultBridgeHost());
+    }
+    return defaultBridge;
+}
+export function createBridge(port, timeoutMs, host) {
+    return new GodotBridge(port, host, timeoutMs);
+}