gopeak 2.2.0 → 2.2.1

package/build/cli/utils.js

@@ -0,0 +1,149 @@
+/**
+ * GoPeak CLI Utilities
+ * Shared helpers for version checking, caching, and shell detection.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { get as httpsGet } from 'https';
+const execAsync = promisify(exec);
+/* ------------------------------------------------------------------ */
+/*  Paths                                                              */
+/* ------------------------------------------------------------------ */
+const GOPEAK_DIR = join(homedir(), '.gopeak');
+const LAST_CHECK_FILE = join(GOPEAK_DIR, 'last-check');
+const NOTIFY_FILE = join(GOPEAK_DIR, 'notify');
+const ONBOARDING_SHOWN_FILE = join(GOPEAK_DIR, 'onboarding-shown');
+const STAR_PROMPTED_FILE = join(GOPEAK_DIR, 'star-prompted');
+export { GOPEAK_DIR, LAST_CHECK_FILE, NOTIFY_FILE, ONBOARDING_SHOWN_FILE, STAR_PROMPTED_FILE };
+export function ensureGopeakDir() {
+    if (!existsSync(GOPEAK_DIR)) {
+        mkdirSync(GOPEAK_DIR, { recursive: true });
+    }
+}
+/* ------------------------------------------------------------------ */
+/*  Version                                                            */
+/* ------------------------------------------------------------------ */
+export function getLocalVersion() {
+    try {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        // Walk up from build/cli/utils.js → project root
+        const pkgPath = join(__dirname, '..', '..', 'package.json');
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        return pkg.version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+/** Fetch latest version from npm registry (no dependencies). */
+export function fetchLatestVersion() {
+    return new Promise((resolve) => {
+        const url = 'https://registry.npmjs.org/gopeak/latest';
+        const timeout = setTimeout(() => resolve(null), 5000);
+        httpsGet(url, (res) => {
+            let data = '';
+            res.on('data', (chunk) => { data += chunk; });
+            res.on('end', () => {
+                clearTimeout(timeout);
+                try {
+                    const json = JSON.parse(data);
+                    resolve(json.version ?? null);
+                }
+                catch {
+                    resolve(null);
+                }
+            });
+            res.on('error', () => { clearTimeout(timeout); resolve(null); });
+        }).on('error', () => { clearTimeout(timeout); resolve(null); });
+    });
+}
+/** Compare two semver strings. Returns 1 if a > b, -1 if a < b, 0 if equal. */
+export function compareSemver(a, b) {
+    const pa = a.replace(/^v/, '').split('.').map(Number);
+    const pb = b.replace(/^v/, '').split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        const na = pa[i] ?? 0;
+        const nb = pb[i] ?? 0;
+        if (na > nb)
+            return 1;
+        if (na < nb)
+            return -1;
+    }
+    return 0;
+}
+/* ------------------------------------------------------------------ */
+/*  Cache                                                              */
+/* ------------------------------------------------------------------ */
+/** Check if the last update check was less than `maxAgeSeconds` ago. */
+export function isCacheFresh(maxAgeSeconds = 86400) {
+    try {
+        if (!existsSync(LAST_CHECK_FILE))
+            return false;
+        const ts = parseInt(readFileSync(LAST_CHECK_FILE, 'utf-8').trim(), 10);
+        return (Date.now() / 1000 - ts) < maxAgeSeconds;
+    }
+    catch {
+        return false;
+    }
+}
+export function updateCacheTimestamp() {
+    ensureGopeakDir();
+    writeFileSync(LAST_CHECK_FILE, String(Math.floor(Date.now() / 1000)));
+}
+export function writeNotifyFile(message) {
+    ensureGopeakDir();
+    writeFileSync(NOTIFY_FILE, message);
+}
+export function clearNotifyFile() {
+    try {
+        if (existsSync(NOTIFY_FILE))
+            unlinkSync(NOTIFY_FILE);
+    }
+    catch { /* ignore */ }
+}
+/* ------------------------------------------------------------------ */
+/*  Shell detection                                                    */
+/* ------------------------------------------------------------------ */
+export function getShellRcFile() {
+    const shell = process.env.SHELL ?? '';
+    if (shell.includes('zsh'))
+        return join(homedir(), '.zshrc');
+    return join(homedir(), '.bashrc');
+}
+export function getShellName() {
+    const shell = process.env.SHELL ?? '';
+    if (shell.includes('zsh'))
+        return 'zsh';
+    return 'bash';
+}
+/* ------------------------------------------------------------------ */
+/*  Command helpers                                                    */
+/* ------------------------------------------------------------------ */
+export async function commandExists(cmd) {
+    try {
+        await execAsync(`command -v ${cmd}`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function runCommand(cmd) {
+    try {
+        const { stdout, stderr } = await execAsync(cmd);
+        return { stdout: stdout.trim(), stderr: stderr.trim(), code: 0 };
+    }
+    catch (err) {
+        return {
+            stdout: (err.stdout ?? '').trim(),
+            stderr: (err.stderr ?? '').trim(),
+            code: err.code ?? 1,
+        };
+    }
+}

package/build/cli.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+/**
+ * GoPeak CLI Entrypoint
+ *
+ * Routes subcommands or falls through to the MCP server.
+ *
+ *   gopeak              → Start MCP server (default, backward-compatible)
+ *   gopeak setup        → Install shell hooks
+ *   gopeak check        → Check for updates
+ *   gopeak star         → Star on GitHub
+ *   gopeak uninstall    → Remove shell hooks
+ *   gopeak version      → Print version
+ *   gopeak help         → Show help
+ */
+import { getLocalVersion } from './cli/utils.js';
+const args = process.argv.slice(2);
+const command = args[0];
+const CLI_COMMANDS = ['setup', 'check', 'star', 'notify', 'uninstall', 'version', 'help', '--version', '-v', '--help', '-h'];
+async function main() {
+    // If no args or not a CLI command → start MCP server (original behavior)
+    if (!command || !CLI_COMMANDS.includes(command)) {
+        // Dynamic import to avoid loading MCP SDK for CLI-only commands
+        await import('./index.js');
+        return;
+    }
+    switch (command) {
+        case 'setup': {
+            const { setupShellHooks } = await import('./cli/setup.js');
+            await setupShellHooks();
+            break;
+        }
+        case 'check': {
+            const { checkForUpdates } = await import('./cli/check.js');
+            await checkForUpdates(args.slice(1));
+            break;
+        }
+        case 'star': {
+            const { starGoPeak } = await import('./cli/star.js');
+            await starGoPeak();
+            break;
+        }
+        case 'notify': {
+            const { showNotification } = await import('./cli/notify.js');
+            await showNotification();
+            break;
+        }
+        case 'uninstall': {
+            const { uninstallHooks } = await import('./cli/uninstall.js');
+            await uninstallHooks();
+            break;
+        }
+        case 'version':
+        case '--version':
+        case '-v': {
+            console.log(`gopeak v${getLocalVersion()}`);
+            break;
+        }
+        case 'help':
+        case '--help':
+        case '-h': {
+            printHelp();
+            break;
+        }
+    }
+}
+function printHelp() {
+    const version = getLocalVersion();
+    console.log(`
+GoPeak v${version} — AI-Powered Godot Development via MCP
+
+Usage:
+  gopeak                Start MCP server (default)
+  gopeak setup          Install shell hooks for update notifications
+  gopeak check          Check for GoPeak updates
+  gopeak check --bg     Background check (used by shell hooks)
+  gopeak check --quiet  Print only if update available
+  gopeak star           Star GoPeak on GitHub
+  gopeak uninstall      Remove shell hooks
+  gopeak version        Show current version
+  gopeak help           Show this help
+
+Shell hooks wrap these commands with update notifications:
+  claude, codex, gemini, opencode, omc, omx
+
+More info: https://github.com/HaD0Yun/godot-mcp
+`.trim());
+}
+main().catch((err) => {
+    console.error('gopeak:', err.message ?? err);
+    process.exit(1);
+});

package/build/godot-bridge.js

@@ -1,13 +1,54 @@
 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;
@@ -18,9 +59,10 @@ export class GodotBridge extends EventEmitter {
     pendingRequests = new Map();
     resourceQueues = new Map();
     visualizerHtml = this.getDefaultVisualizerHtml();
-    constructor(port = DEFAULT_PORT, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    constructor(port = DEFAULT_PORT, host = DEFAULT_HOST, timeoutMs = DEFAULT_TIMEOUT_MS) {
         super();
         this.port = port;
+        this.host = host;
         this.timeoutMs = timeoutMs;
     }
     start() {
@@ -49,7 +91,7 @@ export class GodotBridge extends EventEmitter {
                 this.httpServer = server;
                 this.godotWss = godotWss;
                 this.vizWss = vizWss;
-                this.log('info', `Unified HTTP+WS bridge listening on port ${this.port}`);
+                this.log('info', `Unified HTTP+WS bridge listening on ${this.host}:${this.port}`);
                 resolve();
             });
             server.once('error', (error) => {
@@ -66,13 +108,14 @@ export class GodotBridge extends EventEmitter {
             vizWss.on('error', (error) => {
                 this.log('error', `Visualizer WebSocket server error: ${error.message}`);
             });
-            server.listen(this.port);
+            server.listen(this.port, this.host);
         });
     }
-    stop() {
+    async stop() {
         this.stopKeepalive();
         this.rejectAllPending(new Error('GodotBridge stopped'));
         this.resourceQueues.clear();
+        const closeTasks = [];
         if (this.socket) {
             try {
                 this.socket.close();
@@ -82,31 +125,35 @@ export class GodotBridge extends EventEmitter {
             this.socket = null;
         }
         if (this.godotWss) {
-            for (const client of this.godotWss.clients) {
+            const godotWss = this.godotWss;
+            for (const client of godotWss.clients) {
                 try {
                     client.close();
                 }
                 catch {
                 }
             }
-            this.godotWss.close();
+            closeTasks.push(this.closeWebSocketServer(godotWss));
             this.godotWss = null;
         }
         if (this.vizWss) {
-            for (const client of this.vizWss.clients) {
+            const vizWss = this.vizWss;
+            for (const client of vizWss.clients) {
                 try {
                     client.close();
                 }
                 catch {
                 }
             }
-            this.vizWss.close();
+            closeTasks.push(this.closeWebSocketServer(vizWss));
             this.vizWss = null;
         }
         if (this.httpServer) {
-            this.httpServer.close();
+            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');
@@ -116,6 +163,7 @@ export class GodotBridge extends EventEmitter {
     }
     getStatus() {
         return {
+            host: this.host,
             port: this.port,
             connected: this.isConnected(),
             projectPath: this.connectionInfo?.projectPath,
@@ -174,7 +222,7 @@ export class GodotBridge extends EventEmitter {
                             result: {
                                 protocolVersion: typeof parsed.params?.protocolVersion === 'string' ? parsed.params.protocolVersion : '2025-06-18',
                                 capabilities: {},
-                                serverInfo: { name: 'godot-mcp', version: '2.0.1' },
+                                serverInfo: { name: 'gopeak', version: BRIDGE_VERSION },
                             },
                         }));
                         return;
@@ -198,8 +246,8 @@ export class GodotBridge extends EventEmitter {
         if (pathname === '/health') {
             const payload = {
                 status: 'ok',
-                serverName: 'godot-mcp',
-                version: '2.0.1',
+                serverName: 'gopeak',
+                version: BRIDGE_VERSION,
                 bridge: this.getStatus(),
                 uptime: process.uptime(),
                 timestamp: new Date().toISOString(),
@@ -224,12 +272,50 @@ export class GodotBridge extends EventEmitter {
     }
     getRequestPathname(url) {
         try {
-            return new URL(url ?? '/', `http://localhost:${this.port}`).pathname;
+            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');
@@ -461,10 +547,10 @@ export class GodotBridge extends EventEmitter {
 let defaultBridge = null;
 export function getDefaultBridge() {
     if (!defaultBridge) {
-        defaultBridge = new GodotBridge();
+        defaultBridge = new GodotBridge(resolveDefaultBridgePort(), resolveDefaultBridgeHost());
     }
     return defaultBridge;
 }
-export function createBridge(port, timeoutMs) {
-    return new GodotBridge(port, timeoutMs);
+export function createBridge(port, timeoutMs, host) {
+    return new GodotBridge(port, host, timeoutMs);
 }