@adiholick/nvstudio-mcp 2.0.3 → 2.1.0

package/dist/index.js

@@ -22,12 +22,13 @@ function backupScript(target, code) {
     const fileName = `${safeTargetName}_${timestamp}.luau`;
     fs_1.default.writeFileSync(path_1.default.join(HISTORY_DIR, fileName), code);
 }
+const isDaemon = process.argv.includes('--daemon') || process.argv.includes('-d');
 // 1. Impor dan jalankan server Express lokal di port 3055
 (0, roblox_bridge_1.startBridgeServer)(3055);
 // 2. Inisialisasi server MCP
 const server = new index_js_1.Server({
     name: "nvstudio-mcp",
-    version: "2.0.1",
+    version: "2.1.0",
 }, {
     capabilities: {
         tools: {},
@@ -134,12 +135,46 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             };
         }
     }
-    // 8. Teruskan ke antrean dan kembalikan hasilnya sebagai string JSON
+    // 8. Teruskan ke antrean tugas
     try {
         if (command === "update_script_source" && data) {
             backupScript(target, String(data));
         }
-        const result = await (0, task_queue_1.addTaskToQueue)(command, target, data);
+        let result;
+        if (roblox_bridge_1.isBridgeHosting) {
+            // Instance ini sendiri yang meng-host bridge server
+            result = await (0, task_queue_1.addTaskToQueue)(command, target, data);
+        }
+        else {
+            // Bridge server aktif di proses background lain (port 3055)
+            let forwardedToBridge = false;
+            try {
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), 35000);
+                const bridgeRes = await fetch("http://localhost:3055/api/tasks/enqueue", {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ command, target, data }),
+                    signal: controller.signal
+                });
+                clearTimeout(timeoutId);
+                if (bridgeRes.ok) {
+                    forwardedToBridge = true;
+                    const bridgeJson = await bridgeRes.json();
+                    if (bridgeJson.status === "error") {
+                        throw new Error(bridgeJson.error);
+                    }
+                    result = bridgeJson.result;
+                }
+            }
+            catch (err) {
+                if (forwardedToBridge) {
+                    throw err;
+                }
+                // Fallback in-process jika HTTP gagal dihubungi
+                result = await (0, task_queue_1.addTaskToQueue)(command, target, data);
+            }
+        }
         return {
             content: [
                 {
@@ -164,16 +199,19 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
         };
     }
 });
-// 8. Jalankan koneksi MCP menggunakan StdioServerTransport
+// 8. Jalankan koneksi MCP menggunakan StdioServerTransport (hanya jika bukan mode Daemon)
 async function main() {
     const transport = new stdio_js_1.StdioServerTransport();
     await server.connect(transport);
     console.error("[nvstudio-mcp] MCP Server aktif melalui StdioServerTransport.");
+    // Beritahu SSE plugin bahwa MCP agent sekarang aktif
+    (0, roblox_bridge_1.setMcpConnected)(true);
     let isShuttingDown = false;
     const shutdown = () => {
         if (isShuttingDown)
             return;
         isShuttingDown = true;
+        (0, roblox_bridge_1.setMcpConnected)(false); // Beritahu SSE plugin bahwa MCP agent sudah menutup koneksi
         console.error("[nvstudio-mcp] Koneksi ditutup oleh IDE. Mematikan server...");
         process.exit(0);
     };
@@ -182,7 +220,6 @@ async function main() {
     process.stdin.on('end', shutdown);
     process.stdin.on('error', shutdown);
     // Fallback khusus Windows: cek apakah stdin masih readable secara berkala
-    // process.kill(ppid, 0) tidak reliable di Windows, jadi kita pakai cara ini
     setInterval(() => {
         if (!process.stdin.readable) {
             console.error("[nvstudio-mcp] stdin tidak readable lagi. IDE kemungkinan sudah ditutup.");
@@ -190,7 +227,14 @@ async function main() {
         }
     }, 3000);
 }
-main().catch((err) => {
-    console.error("[nvstudio-mcp] Gagal menjalankan MCP server:", err);
-    process.exit(1);
-});
+if (isDaemon) {
+    console.error("[nvstudio-mcp] Berjalan dalam mode DAEMON (Background Bridge Server di port 3055).");
+    process.on('SIGINT', () => process.exit(0));
+    process.on('SIGTERM', () => process.exit(0));
+}
+else {
+    main().catch((err) => {
+        console.error("[nvstudio-mcp] Gagal menjalankan MCP server:", err);
+        process.exit(1);
+    });
+}

package/dist/roblox-bridge.js

@@ -3,6 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBridgeHosting = void 0;
+exports.setMcpConnected = setMcpConnected;
 exports.startBridgeServer = startBridgeServer;
 const express_1 = __importDefault(require("express"));
 const http_1 = require("http");
@@ -10,11 +12,65 @@ const socket_io_1 = require("socket.io");
 const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
 const task_queue_1 = require("./task-queue");
+exports.isBridgeHosting = false;
 const activityLogs = [];
 let totalTasks = 0;
 let successCount = 0;
 let errorCount = 0;
 const sessionStart = new Date().toISOString();
+const ssePeers = new Map();
+// Apakah MCP agent (Antigravity/Cursor) sedang terhubung ke stdio transport?
+let mcpConnected = false;
+function setMcpConnected(connected) {
+    mcpConnected = connected;
+    broadcastStatus();
+}
+/**
+ * Kirim event SSE ke semua Studio peer yang terhubung.
+ */
+function broadcastEvent(kind, payload) {
+    const data = JSON.stringify({ kind, ...payload });
+    for (const peer of ssePeers.values()) {
+        try {
+            peer.res.write(`data: ${data}\n\n`);
+        }
+        catch { /* peer disconnected */ }
+    }
+}
+/**
+ * Kirim event SSE ke satu peer tertentu.
+ */
+function sendEvent(peer, kind, payload) {
+    const data = JSON.stringify({ kind, ...payload });
+    try {
+        peer.res.write(`data: ${data}\n\n`);
+    }
+    catch { /* peer disconnected */ }
+}
+/**
+ * Push status koneksi ke semua peer (apakah mcpConnected, jumlah peer aktif dll).
+ */
+function broadcastStatus() {
+    broadcastEvent('status', {
+        mcpConnected,
+        studioCount: ssePeers.size,
+        serverVersion: '2.1.0',
+    });
+}
+/**
+ * Push task ke semua Studio peer (broadcast ke semua Studio yang terbuka).
+ * Hanya satu yang akan memprosesnya (first-come first-served via requestId).
+ */
+function broadcastTask(task) {
+    broadcastEvent('request', {
+        requestId: task.id,
+        command: task.command,
+        target: task.target,
+        data: task.data ?? null,
+        remainingMs: 29000,
+    });
+}
+// ── Logging ───────────────────────────────────────────────────────────────────
 function addLog(io, type, message) {
     const log = {
         id: Date.now().toString(),
@@ -30,7 +86,6 @@ function addLog(io, type, message) {
 }
 /**
  * Membunuh proses zombie yang masih menyandera port tertentu.
- * Ini menyelesaikan masalah EADDRINUSE yang terjadi setelah restart IDE.
  */
 function killZombieOnPort(port) {
     try {
@@ -51,7 +106,6 @@ function killZombieOnPort(port) {
             return true;
         }
         else {
-            // macOS / Linux
             const output = (0, child_process_1.execSync)(`lsof -ti :${port}`, { encoding: 'utf8', timeout: 5000 });
             const pids = output.trim().split('\n');
             for (const pid of pids) {
@@ -66,109 +120,232 @@ function killZombieOnPort(port) {
         }
     }
     catch {
-        // Tidak ada proses yang menyandera port — ini normal
         return false;
     }
 }
 function startBridgeServer(port = 3055) {
     const app = (0, express_1.default)();
     const httpServer = (0, http_1.createServer)(app);
-    const io = new socket_io_1.Server(httpServer, { cors: { origin: "*" } });
+    const io = new socket_io_1.Server(httpServer, { cors: { origin: '*' } });
     app.use(express_1.default.json({ limit: '50mb' }));
     app.use(express_1.default.static(path_1.default.join(__dirname, '../public')));
     let dashboardOpened = false;
-    let studioConnected = false;
-    // Provide initial state to newly connected dashboard clients
+    // Sediakan initial state ke dashboard browser baru
     io.on('connection', (socket) => {
         socket.emit('init', {
             logs: activityLogs,
-            stats: { totalTasks, successCount, errorCount, sessionStart, studioConnected, port },
+            stats: { totalTasks, successCount, errorCount, sessionStart, studioConnected: ssePeers.size > 0, port },
         });
     });
-    // API endpoint to get current stats
+    // ── /api/stats ─────────────────────────────────────────────────────────────
     app.get('/api/stats', (req, res) => {
-        res.json({ totalTasks, successCount, errorCount, sessionStart, studioConnected, port });
+        res.json({
+            totalTasks, successCount, errorCount, sessionStart,
+            studioConnected: ssePeers.size > 0,
+            studioCount: ssePeers.size,
+            mcpConnected,
+            port,
+        });
     });
-    const waitingPollers = [];
-    task_queue_1.taskEmitter.on('new_task', () => {
-        if (task_queue_1.taskQueue.length > 0 && waitingPollers.length > 0) {
-            const res = waitingPollers.shift();
-            const task = task_queue_1.taskQueue.shift();
-            totalTasks++;
-            addLog(io, 'task', `Mengirim perintah '${task?.command}' ke Studio${task?.target ? ` → ${task.target}` : ''}.`);
-            res?.json(task);
-        }
+    // ── /api/ping ─────────────────────────────────────────────────────────────
+    // Dipertahankan untuk backward-compat (installer check, health check).
+    app.get('/api/ping', (req, res) => {
+        res.json({ status: 'ok', studioCount: ssePeers.size, mcpConnected, timestamp: Date.now() });
     });
-    // Endpoint Studio Polling
-    app.get('/api/tasks', (req, res) => {
-        if (!studioConnected) {
-            studioConnected = true;
-            io.emit('studio-status', { connected: true });
-            addLog(io, 'system', 'Roblox Studio terhubung ke Bridge Server.');
+    // ── /api/stream (SSE endpoint utama) ─────────────────────────────────────
+    app.get('/api/stream', (req, res) => {
+        const studioId = req.query.studioId || `anon-${Date.now()}`;
+        // Set SSE headers
+        res.setHeader('Content-Type', 'text/event-stream');
+        res.setHeader('Cache-Control', 'no-cache');
+        res.setHeader('Connection', 'keep-alive');
+        res.setHeader('X-Accel-Buffering', 'no'); // Untuk Nginx proxy
+        res.flushHeaders();
+        // Heartbeat setiap 5 detik agar koneksi tidak timeout
+        const heartbeatTimer = setInterval(() => {
+            try {
+                res.write(`data: ${JSON.stringify({ kind: 'heartbeat', timestamp: Date.now() })}\n\n`);
+            }
+            catch {
+                cleanup();
+            }
+        }, 5000);
+        // Silence timeout: jika kita sendiri tidak bisa kirim apapun dalam 30 detik, bersihkan
+        let silenceTimer = setTimeout(() => cleanup(), 30000);
+        const resetSilence = () => {
+            clearTimeout(silenceTimer);
+            silenceTimer = setTimeout(() => cleanup(), 30000);
+        };
+        const peer = { studioId, res, connectedAt: Date.now(), heartbeatTimer, silenceTimer };
+        ssePeers.set(studioId, peer);
+        // Kirim status awal sesaat setelah koneksi
+        sendEvent(peer, 'status', {
+            mcpConnected,
+            studioCount: ssePeers.size,
+            serverVersion: '2.1.0',
+        });
+        // Jika ada task yang sudah antri sebelum Studio terhubung, kirim sekarang
+        if (task_queue_1.taskQueue.length > 0) {
+            const task = task_queue_1.taskQueue[0]; // preview saja, jangan shift di sini (broadcastTask akan handle)
+            sendEvent(peer, 'request', {
+                requestId: task.id,
+                command: task.command,
+                target: task.target,
+                data: task.data ?? null,
+                remainingMs: 29000,
+            });
         }
+        io.emit('studio-status', { connected: true, studioCount: ssePeers.size, studioId });
+        addLog(io, 'system', `Roblox Studio terhubung via SSE. (ID: ${studioId.substring(0, 8)}…, Peer aktif: ${ssePeers.size})`);
         if (!dashboardOpened) {
             dashboardOpened = true;
             const url = `http://localhost:${port}`;
             const startCmd = process.platform === 'win32' ? `start "" "${url}"` : process.platform === 'darwin' ? `open "${url}"` : `xdg-open "${url}"`;
-            (0, child_process_1.exec)(startCmd, (error) => {
-                if (error)
-                    console.error(`[Bridge] Gagal membuka browser:`, error);
-            });
-            console.error(`[Bridge] Pertama kali terhubung dengan Studio! Membuka Dashboard...`);
+            const isDaemon = process.argv.includes('--daemon') || process.argv.includes('-d');
+            if (!isDaemon) {
+                (0, child_process_1.exec)(startCmd, (error) => {
+                    if (error)
+                        console.error(`[Bridge] Gagal membuka browser:`, error);
+                });
+                console.error(`[Bridge] Studio terhubung pertama kali! Membuka Dashboard...`);
+            }
         }
-        if (task_queue_1.taskQueue.length > 0) {
-            const task = task_queue_1.taskQueue.shift();
-            totalTasks++;
-            addLog(io, 'task', `Mengirim perintah '${task?.command}' ke Studio${task?.target ? ` → ${task.target}` : ''}.`);
-            res.json(task);
+        function cleanup() {
+            clearInterval(heartbeatTimer);
+            clearTimeout(silenceTimer);
+            ssePeers.delete(studioId);
+            io.emit('studio-status', { connected: ssePeers.size > 0, studioCount: ssePeers.size, studioId });
+            addLog(io, 'system', `Roblox Studio terputus. (ID: ${studioId.substring(0, 8)}…, Peer tersisa: ${ssePeers.size})`);
+            try {
+                res.end();
+            }
+            catch { /* sudah tutup */ }
+        }
+        req.on('close', cleanup);
+        req.on('error', cleanup);
+        // Semua write berhasil → reset silence timer
+        const origWrite = res.write.bind(res);
+        res.write = (...args) => {
+            const result = origWrite(...args);
+            resetSilence();
+            return result;
+        };
+    });
+    // ── /api/response/:taskId (Studio POSTs hasil eksekusi) ───────────────────
+    app.post('/api/response/:taskId', (req, res) => {
+        const { taskId } = req.params;
+        const { status, result, error } = req.body;
+        if (status === 'success') {
+            successCount++;
+            addLog(io, 'response', `Perintah selesai: ${String(result ?? '').substring(0, 120)}`);
         }
         else {
-            // Long-polling: tunggu maksimal 20 detik
-            const timeoutId = setTimeout(() => {
-                const index = waitingPollers.indexOf(res);
-                if (index !== -1) {
-                    waitingPollers.splice(index, 1);
-                    res.json({ id: null });
-                }
-            }, 20000);
-            waitingPollers.push(res);
-            // Bersihkan jika terputus prematur
-            req.on('close', () => {
-                clearTimeout(timeoutId);
-                const index = waitingPollers.indexOf(res);
-                if (index !== -1) {
-                    waitingPollers.splice(index, 1);
-                }
-            });
+            errorCount++;
+            addLog(io, 'error', `Gagal: ${error}`);
         }
+        (0, task_queue_1.resolvePendingTask)(taskId, status, result, error);
+        res.json({ ok: true });
     });
-    // Endpoint Studio Response
+    // ── /api/response (legacy — lama, tetap didukung) ────────────────────────
     app.post('/api/response', (req, res) => {
         const { id, status, result, error } = req.body;
         if (status === 'success') {
             successCount++;
-            addLog(io, 'response', `Perintah selesai: ${String(result).substring(0, 120)}`);
+            addLog(io, 'response', `Perintah selesai: ${String(result ?? '').substring(0, 120)}`);
         }
         else {
             errorCount++;
             addLog(io, 'error', `Gagal: ${error}`);
         }
         (0, task_queue_1.resolvePendingTask)(id, status, result, error);
-        res.json({ message: "Response diterima" });
+        res.json({ ok: true });
+    });
+    // ── Push task ke SSE stream saat ada task baru ────────────────────────────
+    task_queue_1.taskEmitter.on('new_task', () => {
+        if (task_queue_1.taskQueue.length === 0)
+            return;
+        if (ssePeers.size === 0) {
+            // Tidak ada Studio terhubung — task tetap antri, akan dikirim saat Studio connect
+            return;
+        }
+        const task = task_queue_1.taskQueue.shift();
+        totalTasks++;
+        addLog(io, 'task', `Mengirim perintah '${task.command}' ke Studio${task.target ? ` → ${task.target}` : ''}.`);
+        broadcastTask(task);
     });
-    // ── ANTI-ZOMBIE: Coba listen, jika gagal bunuh zombie lalu retry ──
+    // ── /api/tasks/enqueue (dari proses MCP eksternal / bridge forwarding) ────
+    app.post('/api/tasks/enqueue', async (req, res) => {
+        const { command, target, data } = req.body;
+        try {
+            const result = await (0, task_queue_1.addTaskToQueue)(command, target, data);
+            res.json({ status: 'success', result });
+        }
+        catch (err) {
+            res.json({ status: 'error', error: err.message });
+        }
+    });
+    // ── /api/tasks (legacy long-poll — dipertahankan untuk backward-compat) ───
+    // Studio lama yang belum update plugin masih bisa bekerja via polling.
+    const waitingPollers = [];
+    task_queue_1.taskEmitter.on('new_task_legacy', () => {
+        if (task_queue_1.taskQueue.length > 0 && waitingPollers.length > 0) {
+            const pollRes = waitingPollers.shift();
+            const task = task_queue_1.taskQueue.shift();
+            totalTasks++;
+            addLog(io, 'task', `[Legacy] Mengirim perintah '${task?.command}' ke Studio.`);
+            pollRes?.json(task);
+        }
+    });
+    app.get('/api/tasks', (req, res) => {
+        if (task_queue_1.taskQueue.length > 0) {
+            const task = task_queue_1.taskQueue.shift();
+            totalTasks++;
+            addLog(io, 'task', `[Legacy] Mengirim perintah '${task?.command}' ke Studio.`);
+            return res.json(task);
+        }
+        const timeoutId = setTimeout(() => {
+            const index = waitingPollers.indexOf(res);
+            if (index !== -1) {
+                waitingPollers.splice(index, 1);
+                res.json({ id: null });
+            }
+        }, 20000);
+        waitingPollers.push(res);
+        req.on('close', () => {
+            clearTimeout(timeoutId);
+            const index = waitingPollers.indexOf(res);
+            if (index !== -1)
+                waitingPollers.splice(index, 1);
+        });
+    });
+    // ── Port-sharing & anti-zombie ────────────────────────────────────────────
     function tryListen(retriesLeft = 2) {
         const server = httpServer.listen(port, () => {
-            console.error(`[Bridge] Dashboard visual & server aktif di http://localhost:${port}`);
+            exports.isBridgeHosting = true;
+            console.error(`[Bridge] SSE Bridge Server aktif di http://localhost:${port}`);
         });
-        server.on('error', (err) => {
-            if (err.code === 'EADDRINUSE' && retriesLeft > 0) {
-                console.error(`[Bridge] Port ${port} sedang digunakan oleh proses zombie. Mencoba membunuh...`);
-                killZombieOnPort(port);
-                setTimeout(() => {
-                    console.error(`[Bridge] Mencoba listen ulang pada port ${port}... (sisa ${retriesLeft - 1} percobaan)`);
-                    tryListen(retriesLeft - 1);
-                }, 1500);
+        server.on('error', async (err) => {
+            if (err.code === 'EADDRINUSE') {
+                try {
+                    const controller = new AbortController();
+                    const timeoutId = setTimeout(() => controller.abort(), 1000);
+                    const pingRes = await fetch(`http://localhost:${port}/api/ping`, { signal: controller.signal });
+                    clearTimeout(timeoutId);
+                    if (pingRes.ok) {
+                        exports.isBridgeHosting = false;
+                        console.error(`[Bridge] Port ${port} sudah digunakan oleh NVStudio Bridge aktif. Menggunakan instance yang sudah berjalan.`);
+                        return;
+                    }
+                }
+                catch { /* bukan NVStudio bridge */ }
+                if (retriesLeft > 0) {
+                    console.error(`[Bridge] Port ${port} zombie. Mencoba membunuh...`);
+                    killZombieOnPort(port);
+                    setTimeout(() => tryListen(retriesLeft - 1), 1500);
+                }
+                else {
+                    console.error(`[Bridge] FATAL: Port ${port} tidak dapat dibuka.`);
+                }
             }
             else {
                 console.error(`[Bridge] FATAL: Gagal mendengarkan port ${port}:`, err.message);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adiholick/nvstudio-mcp",
-  "version": "2.0.3",
+  "version": "2.1.0",
   "description": "Local Bridge Server MCP for Roblox Studio",
   "main": "dist/index.js",
   "bin": {