@adiholick/nvstudio-mcp 2.2.1 → 2.2.3

package/dist/roblox-bridge.js

@@ -3,8 +3,12 @@ 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.bridgeReadyPromise = exports.isBridgeHosting = void 0;
+exports.removePendingStreamTask = removePendingStreamTask;
+exports.checkPendingTasksOnStudioDisconnect = checkPendingTasksOnStudioDisconnect;
 exports.isStudioConnected = isStudioConnected;
+exports.getConnectedStudios = getConnectedStudios;
+exports.getConnectedStudioCount = getConnectedStudioCount;
 exports.setMcpConnected = setMcpConnected;
 exports.startBridgeServer = startBridgeServer;
 const express_1 = __importDefault(require("express"));
@@ -13,8 +17,13 @@ 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");
+const ws_gateway_1 = require("./ws-gateway");
 const { version: SERVER_VERSION } = require('../package.json');
 exports.isBridgeHosting = false;
+let resolveBridgeReady;
+exports.bridgeReadyPromise = new Promise((resolve) => {
+    resolveBridgeReady = resolve;
+});
 // Global process error handlers agar server bridge tidak mati mendadak
 process.on('uncaughtException', (err) => {
     console.error('[Bridge] Uncaught Exception:', err);
@@ -30,22 +39,161 @@ const sessionStart = new Date().toISOString();
 // Per-studio pending events queue: events yang belum diambil oleh Studio
 const studioEventQueues = new Map();
 const studioLastSeen = new Map();
+const studioPlaces = new Map();
+const activeStudioPollers = new Map();
+// Antrean global untuk task request yang menunggu poller long-polling (/api/stream)
+const pendingStreamTasks = [];
+function removePendingStreamTask(taskId) {
+    const idx = pendingStreamTasks.findIndex(t => t.requestId === taskId || t.taskId === taskId);
+    if (idx !== -1) {
+        pendingStreamTasks.splice(idx, 1);
+    }
+}
+let disconnectCheckTimer = null;
+function checkPendingTasksOnStudioDisconnect() {
+    if (disconnectCheckTimer)
+        clearTimeout(disconnectCheckTimer);
+    disconnectCheckTimer = setTimeout(() => {
+        disconnectCheckTimer = null;
+        if (!isStudioConnected() && (0, task_queue_1.hasPendingTasks)()) {
+            pendingStreamTasks.length = 0;
+            (0, task_queue_1.rejectAllPendingTasks)('Roblox Studio terputus sebelum merespons tugas.');
+        }
+    }, 2000);
+}
 setInterval(() => {
     const now = Date.now();
     let changed = false;
     for (const [sid, lastSeen] of studioLastSeen.entries()) {
-        if (now - lastSeen > 6000) {
+        const isPollerActive = activeStudioPollers.has(sid);
+        if (!isPollerActive && now - lastSeen > 10000) {
+            studioEventQueues.delete(sid);
+            studioLastSeen.delete(sid);
+            studioPlaces.delete(sid);
+            changed = true;
+        }
+        else if (now - lastSeen > 25000) {
             studioEventQueues.delete(sid);
             studioLastSeen.delete(sid);
+            studioPlaces.delete(sid);
+            const poller = activeStudioPollers.get(sid);
+            if (poller) {
+                clearTimeout(poller.timer);
+                try {
+                    poller.res.end();
+                }
+                catch { }
+                activeStudioPollers.delete(sid);
+            }
             changed = true;
         }
     }
     if (changed) {
         broadcastStatus();
+        if (!isStudioConnected() && (0, task_queue_1.hasPendingTasks)()) {
+            checkPendingTasksOnStudioDisconnect();
+        }
+    }
+}, 2000);
+function isStudioConnected(filter) {
+    if (filter?.studioId) {
+        if ((0, ws_gateway_1.hasActiveWsPeer)({ studioId: filter.studioId }))
+            return true;
+        if (activeStudioPollers.has(filter.studioId))
+            return true;
+        const seen = studioLastSeen.get(filter.studioId);
+        if (seen && Date.now() - seen <= 5000)
+            return true;
+        return false;
+    }
+    if (filter?.placeId !== undefined && filter?.placeId !== null) {
+        if ((0, ws_gateway_1.hasActiveWsPeer)({ placeId: filter.placeId }))
+            return true;
+        for (const [sid, pid] of studioPlaces.entries()) {
+            if (pid === filter.placeId) {
+                if (activeStudioPollers.has(sid))
+                    return true;
+                const seen = studioLastSeen.get(sid);
+                if (seen && Date.now() - seen <= 5000)
+                    return true;
+            }
+        }
+        return false;
+    }
+    if ((0, ws_gateway_1.hasActiveWsPeer)())
+        return true;
+    if (activeStudioPollers.size > 0)
+        return true;
+    const now = Date.now();
+    for (const lastSeen of studioLastSeen.values()) {
+        if (now - lastSeen <= 3000)
+            return true;
+    }
+    return false;
+}
+function getConnectedStudios() {
+    const list = [];
+    const wsDetails = (0, ws_gateway_1.getWsPeersDetails)();
+    const wsStudioIds = new Set();
+    for (const p of wsDetails) {
+        wsStudioIds.add(p.studioId);
+        list.push({
+            studioId: p.studioId,
+            placeId: p.placeId,
+            transport: 'websocket',
+            lastSeen: p.lastSeen,
+            isAlive: p.isAlive && !p.unresponsive,
+            isBusy: p.isBusy,
+        });
+    }
+    const now = Date.now();
+    for (const [sid, lastSeen] of studioLastSeen.entries()) {
+        if (!wsStudioIds.has(sid) && (activeStudioPollers.has(sid) || now - lastSeen <= 5000)) {
+            list.push({
+                studioId: sid,
+                placeId: studioPlaces.get(sid),
+                transport: 'long-polling',
+                lastSeen,
+                isAlive: true,
+                isBusy: false,
+            });
+        }
+    }
+    return list;
+}
+function getConnectedStudioCount() {
+    const ids = new Set();
+    for (const sid of studioEventQueues.keys())
+        ids.add(sid);
+    for (const sid of (0, ws_gateway_1.getWsStudioIds)())
+        ids.add(sid);
+    return Math.max(ids.size, isStudioConnected() ? 1 : 0);
+}
+function flushEventsToStudio(sid) {
+    const poller = activeStudioPollers.get(sid);
+    if (!poller)
+        return false;
+    const queue = studioEventQueues.get(sid) ?? [];
+    if (queue.length === 0)
+        return false;
+    studioEventQueues.set(sid, []); // kosongkan antrian
+    clearTimeout(poller.timer);
+    activeStudioPollers.delete(sid);
+    const nonStatusEvents = queue.filter(ev => ev.kind !== 'status');
+    const events = [
+        { kind: 'status', mcpConnected, studioCount: Math.max(studioEventQueues.size, 1), serverVersion: SERVER_VERSION },
+        ...nonStatusEvents
+    ];
+    try {
+        poller.res.setHeader('Content-Type', 'text/plain');
+        poller.res.setHeader('Cache-Control', 'no-cache, no-store');
+        const body = events.map(ev => `data: ${JSON.stringify(ev)}`).join('\n');
+        poller.res.send(body);
+        return true;
+    }
+    catch {
+        return false;
     }
-}, 3000);
-function isStudioConnected() {
-    return studioEventQueues.size > 0;
 }
 function enqueueForStudio(studioId, event) {
     if (studioId) {
@@ -56,13 +204,15 @@ function enqueueForStudio(studioId, event) {
         q.push(event);
         if (q.length > 100)
             q.shift();
+        flushEventsToStudio(studioId);
     }
     else {
-        // Broadcast ke semua studio yang terdaftar
+        // Broadcast non-task (status, heartbeat) ke semua studio yang terdaftar
         for (const [sid, q] of studioEventQueues.entries()) {
             q.push(event);
             if (q.length > 100)
                 q.shift();
+            flushEventsToStudio(sid);
         }
     }
 }
@@ -99,26 +249,91 @@ function sendEvent(peer, kind, payload) {
  * Push status koneksi ke semua peer (apakah mcpConnected, jumlah peer aktif dll).
  */
 function broadcastStatus() {
+    const studioCount = getConnectedStudioCount();
     const statusEvent = {
         mcpConnected,
-        studioCount: studioEventQueues.size,
+        studioCount,
         serverVersion: SERVER_VERSION,
     };
     broadcastEvent('status', statusEvent);
+    (0, ws_gateway_1.broadcastWsEvent)('status', statusEvent);
 }
 /**
- * Push task ke semua Studio peer (broadcast ke semua Studio yang terbuka).
- * Hanya satu yang akan memprosesnya (first-come first-served via requestId).
+ * Push task ke Studio peer (dengan routing studioId/placeId).
+ * Mengembalikan true jika berhasil dikirim langsung ke poller aktif, false jika diantrekan (Bug F).
  */
 function broadcastTask(task) {
+    const totalBudget = task.remainingMs ?? 30000;
+    const elapsed = task.createdAt ? (Date.now() - task.createdAt) : 0;
+    const remainingMs = Math.max(1000, totalBudget - elapsed);
+    // Bug A & E: Stamp attempt counter dan channel pengiriman
+    const attempt = (task.attempt || 0) + 1;
+    task.attempt = attempt;
+    task.dispatchedAt = Date.now();
+    task.deliveredVia = 'stream';
     const taskEvent = {
+        kind: 'request',
         requestId: task.id,
+        taskId: task.id,
+        attempt,
         command: task.command,
         target: task.target,
         data: task.data ?? null,
-        remainingMs: 29000,
+        studioId: task.studioId,
+        placeId: task.placeId,
+        remainingMs,
     };
-    enqueueForStudio(null, { kind: 'request', ...taskEvent });
+    // 1. Coba kirim langsung ke poller aktif yang cocok (hanging GET)
+    let matchingSid = null;
+    if (task.studioId && activeStudioPollers.has(task.studioId)) {
+        matchingSid = task.studioId;
+    }
+    else if (task.placeId !== undefined && task.placeId !== null) {
+        for (const sid of activeStudioPollers.keys()) {
+            if (studioPlaces.get(sid) === task.placeId) {
+                matchingSid = sid;
+                break;
+            }
+        }
+    }
+    else if (!task.studioId && task.placeId === undefined && activeStudioPollers.size > 0) {
+        let bestSid = null;
+        let latestTime = -1;
+        for (const sid of activeStudioPollers.keys()) {
+            const seen = studioLastSeen.get(sid) ?? 0;
+            if (seen > latestTime) {
+                latestTime = seen;
+                bestSid = sid;
+            }
+        }
+        matchingSid = bestSid || activeStudioPollers.keys().next().value;
+    }
+    if (matchingSid && activeStudioPollers.has(matchingSid)) {
+        const poller = activeStudioPollers.get(matchingSid);
+        clearTimeout(poller.timer);
+        activeStudioPollers.delete(matchingSid);
+        studioLastSeen.set(matchingSid, Date.now());
+        const events = [
+            { kind: 'status', mcpConnected, studioCount: Math.max(studioEventQueues.size, 1), serverVersion: SERVER_VERSION },
+            taskEvent
+        ];
+        try {
+            poller.res.setHeader('Content-Type', 'text/plain');
+            poller.res.setHeader('Cache-Control', 'no-cache, no-store');
+            const body = events.map(ev => `data: ${JSON.stringify(ev)}`).join('\n');
+            poller.res.send(body);
+            return true;
+        }
+        catch {
+            // Jika pengiriman langsung gagal, masukkan ke antrean pending
+        }
+    }
+    // 2. Jika tidak ada poller yang sedang hanging (jeda antar-request), masukkan ke antrean
+    pendingStreamTasks.push(taskEvent);
+    if (pendingStreamTasks.length > 50) {
+        pendingStreamTasks.shift();
+    }
+    return false;
 }
 // ── Logging ───────────────────────────────────────────────────────────────────
 let logCounter = 0;
@@ -132,8 +347,10 @@ function addLog(io, type, message) {
     activityLogs.unshift(log);
     if (activityLogs.length > 200)
         activityLogs.pop();
-    io.emit('log', log);
-    io.emit('stats', { totalTasks, successCount, errorCount, sessionStart });
+    if (io.engine && io.engine.clientsCount > 0) {
+        io.emit('log', log);
+        io.emit('stats', { totalTasks, successCount, errorCount, sessionStart });
+    }
 }
 /**
  * Membunuh proses zombie yang masih menyandera port tertentu.
@@ -181,6 +398,57 @@ function startBridgeServer(port, isDaemon = false) {
     const app = (0, express_1.default)();
     const httpServer = (0, http_1.createServer)(app);
     const io = new socket_io_1.Server(httpServer, { cors: { origin: '*' } });
+    function handleTaskResponse(taskId, status, result, error) {
+        if (status === 'success') {
+            successCount++;
+            addLog(io, 'response', `Perintah selesai: ${String(result ?? '').substring(0, 120)}`);
+        }
+        else {
+            errorCount++;
+            addLog(io, 'error', `Gagal: ${error}`);
+        }
+        removePendingStreamTask(taskId);
+        (0, ws_gateway_1.cancelTaskDeadline)(taskId);
+        (0, task_queue_1.resolvePendingTask)(taskId, status, result, error);
+    }
+    // Pasang WebSocket Gateway untuk duplex communication instan (/ws)
+    (0, ws_gateway_1.attachWsGateway)(httpServer, {
+        onTaskResponse: (taskId, status, result, error) => {
+            handleTaskResponse(taskId, status, result, error);
+        },
+        onLog: (type, message) => {
+            addLog(io, type, message);
+        },
+        onStudioStatusChange: () => {
+            const connected = isStudioConnected();
+            const studioCount = getConnectedStudioCount();
+            io.emit('studio-status', { connected, studioCount });
+            broadcastStatus();
+            if (!connected && (0, task_queue_1.hasPendingTasks)()) {
+                checkPendingTasksOnStudioDisconnect();
+            }
+        },
+        getServerVersion: () => SERVER_VERSION,
+        isMcpConnected: () => mcpConnected,
+        onRedispatchTask: (task, failedStudioId) => {
+            // Coba re-dispatch ke peer WS lain jika ada yang cocok
+            const nextPeer = (0, ws_gateway_1.selectWsPeer)({
+                placeId: task.placeId,
+            });
+            if (nextPeer && nextPeer.studioId !== failedStudioId) {
+                const ok = (0, ws_gateway_1.sendTaskViaWs)(task, nextPeer.studioId);
+                if (ok)
+                    return true;
+            }
+            // Fallback: hanya ke long-polling jika ada poller yang sedang hanging aktif (Bug F)
+            if (activeStudioPollers.size > 0) {
+                const delivered = broadcastTask(task);
+                if (delivered)
+                    return true;
+            }
+            return false;
+        },
+    });
     app.use(express_1.default.json({ limit: '50mb' }));
     app.use(express_1.default.static(path_1.default.join(__dirname, '../public')));
     let dashboardOpened = false;
@@ -188,45 +456,66 @@ function startBridgeServer(port, isDaemon = false) {
     io.on('connection', (socket) => {
         socket.emit('init', {
             logs: activityLogs,
-            stats: { totalTasks, successCount, errorCount, sessionStart, studioConnected: studioEventQueues.size > 0, port },
+            stats: {
+                totalTasks,
+                successCount,
+                errorCount,
+                sessionStart,
+                studioConnected: isStudioConnected(),
+                studioCount: getConnectedStudioCount(),
+                wsStudios: (0, ws_gateway_1.getWsPeerCount)(),
+                port
+            },
         });
     });
     // ── /api/stats ─────────────────────────────────────────────────────────────
     app.get('/api/stats', (req, res) => {
-        const activeStudios = studioEventQueues.size;
+        const activeStudios = getConnectedStudioCount();
+        const wsStudios = (0, ws_gateway_1.getWsPeerCount)();
         res.json({
             totalTasks, successCount, errorCount, sessionStart,
-            studioConnected: activeStudios > 0,
+            studioConnected: isStudioConnected(),
             studioCount: activeStudios,
+            wsConnectedCount: wsStudios,
+            transport: wsStudios > 0 ? 'websocket' : (activeStudioPollers.size > 0 ? 'long-polling' : 'none'),
             mcpConnected,
             port,
+            connectedStudios: getConnectedStudios(),
         });
     });
     // ── /api/ping ─────────────────────────────────────────────────────────────
     app.get('/api/ping', (req, res) => {
         const uptime = Math.floor((Date.now() - new Date(sessionStart).getTime()) / 1000);
-        const activeStudios = studioEventQueues.size;
+        const activeStudios = getConnectedStudioCount();
+        const wsStudios = (0, ws_gateway_1.getWsPeerCount)();
         res.json({
             status: 'ok',
             version: SERVER_VERSION,
             uptimeSeconds: uptime,
             totalTasksProcessed: totalTasks,
-            activeStudios: activeStudios
+            activeStudios: activeStudios,
+            wsStudios: wsStudios,
+            dualMode: true,
         });
     });
-    // ── /api/stream (Snapshot endpoint untuk Roblox GetAsync) ───────────────
-    // Roblox HttpService:GetAsync() TIDAK bisa streaming — ia block sampai
-    // koneksi ditutup. Endpoint ini: daftarkan studio, kirim semua events
-    // yang tertunda (status + queued tasks), lalu TUTUP koneksi.
-    // Plugin mengulang GET ini setiap ~0.5 detik (pseudo-polling via snapshot).
+    // ── /api/stream (True Long-Polling endpoint untuk Roblox GetAsync) ─────
+    // Roblox HttpService:GetAsync() menahan koneksi sampai server merespons.
+    // Jika ada task yang menunggu: kirim seketika (<1ms).
+    // Jika tidak ada task: tahan koneksi (hanging GET) hingga task baru tiba
+    // atau timeout 15 detik (heartbeat) untuk menjaga koneksi tetap segar.
     app.get('/api/stream', (req, res) => {
         const studioId = req.query.studioId || `anon-${Date.now()}`;
+        const placeIdStr = req.query.placeId;
+        const placeId = placeIdStr !== undefined && placeIdStr !== '' ? parseInt(placeIdStr, 10) : undefined;
+        if (placeId !== undefined && !isNaN(placeId)) {
+            studioPlaces.set(studioId, placeId);
+        }
         studioLastSeen.set(studioId, Date.now());
         // Daftarkan studio jika belum ada
         if (!studioEventQueues.has(studioId)) {
             studioEventQueues.set(studioId, []);
-            io.emit('studio-status', { connected: true, studioCount: studioEventQueues.size, studioId });
-            addLog(io, 'system', `Studio terdaftar. (ID: ${studioId.substring(0, 8)}…, Total: ${studioEventQueues.size})`);
+            io.emit('studio-status', { connected: true, studioCount: Math.max(studioEventQueues.size, 1), studioId });
+            addLog(io, 'system', `Studio terdaftar. (ID: ${studioId.substring(0, 8)}…, Place: ${placeId ?? 'Local'}, Total: ${studioEventQueues.size})`);
             if (!isDaemon && !dashboardOpened) {
                 dashboardOpened = true;
                 const url = `http://localhost:${port}`;
@@ -237,26 +526,80 @@ function startBridgeServer(port, isDaemon = false) {
                 });
             }
         }
-        // Kumpulkan semua events yang belum dikirim ke studio ini
+        // Jika poller lama untuk studio ini masih aktif, selesaikan dulu
+        const oldPoller = activeStudioPollers.get(studioId);
+        if (oldPoller) {
+            clearTimeout(oldPoller.timer);
+            try {
+                oldPoller.res.end();
+            }
+            catch { }
+            activeStudioPollers.delete(studioId);
+        }
+        // 1. Prioritas Utama: Cek apakah ada task AI yang cocok sedang menunggu poller Studio ini (Bug #3 Routing)
+        const matchIdx = pendingStreamTasks.findIndex((t) => {
+            if (t.studioId && t.studioId !== studioId)
+                return false;
+            if (t.placeId !== undefined && t.placeId !== null && placeId !== undefined && t.placeId !== placeId)
+                return false;
+            return true;
+        });
+        if (matchIdx !== -1) {
+            const taskEvent = pendingStreamTasks.splice(matchIdx, 1)[0];
+            const events = [
+                { kind: 'status', mcpConnected, studioCount: Math.max(studioEventQueues.size, 1), serverVersion: SERVER_VERSION },
+                taskEvent
+            ];
+            res.setHeader('Content-Type', 'text/plain');
+            res.setHeader('Cache-Control', 'no-cache, no-store');
+            const body = events.map(ev => `data: ${JSON.stringify(ev)}`).join('\n');
+            return res.send(body);
+        }
+        // 2. Kumpulkan semua events non-task yang belum dikirim ke studio ini
         const queue = studioEventQueues.get(studioId) ?? [];
-        studioEventQueues.set(studioId, []); // kosongkan antrian
-        // Selalu sertakan status terkini
-        const events = [
-            { kind: 'status', mcpConnected, studioCount: studioEventQueues.size, serverVersion: SERVER_VERSION },
-        ];
-        // Tambahkan events tertunda (misalnya task requests)
-        for (const ev of queue) {
-            // Hindari duplikat status
-            if (ev.kind !== 'status')
-                events.push(ev);
+        if (queue.length > 0) {
+            studioEventQueues.set(studioId, []); // kosongkan antrian
+            const events = [
+                { kind: 'status', mcpConnected, studioCount: Math.max(studioEventQueues.size, 1), serverVersion: SERVER_VERSION },
+                ...queue.filter(ev => ev.kind !== 'status')
+            ];
+            res.setHeader('Content-Type', 'text/plain');
+            res.setHeader('Cache-Control', 'no-cache, no-store');
+            const body = events.map(ev => `data: ${JSON.stringify(ev)}`).join('\n');
+            return res.send(body);
         }
-        // Format sebagai teks SSE (setiap event = satu baris "data: ...\n\n")
-        res.setHeader('Content-Type', 'text/plain');
-        res.setHeader('Cache-Control', 'no-cache, no-store');
-        const body = events
-            .map(ev => `data: ${JSON.stringify(ev)}`)
-            .join('\n');
-        res.send(body);
+        // 3. Jika antrean kosong, TAHAN koneksi (Long-Polling) maksimal 15 detik
+        const timer = setTimeout(() => {
+            activeStudioPollers.delete(studioId);
+            try {
+                const events = [
+                    { kind: 'heartbeat', timestamp: Date.now() },
+                    { kind: 'status', mcpConnected, studioCount: Math.max(studioEventQueues.size, 1), serverVersion: SERVER_VERSION }
+                ];
+                res.setHeader('Content-Type', 'text/plain');
+                res.setHeader('Cache-Control', 'no-cache, no-store');
+                const body = events.map(ev => `data: ${JSON.stringify(ev)}`).join('\n');
+                res.send(body);
+            }
+            catch { }
+        }, 15000);
+        activeStudioPollers.set(studioId, { res, timer });
+        res.on('close', () => {
+            const current = activeStudioPollers.get(studioId);
+            if (current && current.res === res) {
+                clearTimeout(current.timer);
+                activeStudioPollers.delete(studioId);
+            }
+            if (!res.writableEnded) {
+                // Client menutup koneksi HTTP sebelum respons dikirim (Studio ditutup/crash)
+                studioLastSeen.delete(studioId);
+                studioEventQueues.delete(studioId);
+                broadcastStatus();
+                if ((0, task_queue_1.hasPendingTasks)()) {
+                    checkPendingTasksOnStudioDisconnect();
+                }
+            }
+        });
     });
     // ── /api/events (SSE persisten untuk browser/klien modern) ───────────────
     app.get('/api/events', (req, res) => {
@@ -295,94 +638,103 @@ function startBridgeServer(port, isDaemon = false) {
             }
             catch { /* ignore */ }
         }
-        req.on('close', cleanup);
-        req.on('error', cleanup);
+        res.on('close', cleanup);
+        res.on('error', cleanup);
     });
-    // ── /api/response/:taskId (Studio POSTs hasil eksekusi) ───────────────────
+    // ── /api/response/:taskId (Studio POSTs hasil eksekusi) (Bug H) ─────────
     app.post('/api/response/:taskId', (req, res) => {
-        const { taskId } = req.params;
+        const taskId = req.params.taskId || req.body?.taskId || req.body?.id;
         const { status, result, error } = req.body;
-        if (status === 'success') {
-            successCount++;
-            addLog(io, 'response', `Perintah selesai: ${String(result ?? '').substring(0, 120)}`);
-        }
-        else {
-            errorCount++;
-            addLog(io, 'error', `Gagal: ${error}`);
-        }
-        (0, task_queue_1.resolvePendingTask)(taskId, status, result, error);
+        handleTaskResponse(taskId, status, result, error);
         res.json({ ok: true });
     });
-    // ── /api/response (legacy — lama, tetap didukung) ────────────────────────
+    // ── /api/response (legacy & fallback) (Bug H) ───────────────────────────
     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)}`);
-        }
-        else {
-            errorCount++;
-            addLog(io, 'error', `Gagal: ${error}`);
-        }
-        (0, task_queue_1.resolvePendingTask)(id, status, result, error);
+        const taskId = req.body?.taskId || req.body?.id || req.query?.taskId;
+        const { status, result, error } = req.body;
+        handleTaskResponse(taskId, status, result, error);
         res.json({ ok: true });
     });
-    // ── Notifikasi task baru ke Dashboard ────────────────────────────────────
-    // Pengiriman task ke Studio dilakukan via /api/stream (snapshot polling).
-    // Di sini kita hanya log ke dashboard browser.
+    // ── Notifikasi task baru ke Dashboard & Dispatch ke Studio ────────────────
     task_queue_1.taskEmitter.on('new_task', (task) => {
         totalTasks++;
         addLog(io, 'task', `Task dikirim ke Studio: '${task.command}'${task.target ? ` → ${task.target}` : ''}`);
+        // Prioritas 1: Push via WebSocket instan duplex jika Studio aktif terhubung via WS
+        const sentWs = (0, ws_gateway_1.sendTaskViaWs)(task);
+        if (sentWs) {
+            task.deliveredVia = 'ws';
+            return; // Berhasil terkirim instan via WebSocket! Tidak perlu enqueue ke long-polling.
+        }
+        // Prioritas 2 (Fallback): Enqueue ke Long-Polling /api/stream
         broadcastTask(task);
     });
     // ── /api/tasks/enqueue (dari proses MCP eksternal / bridge forwarding) ────
     app.post('/api/tasks/enqueue', async (req, res) => {
-        const { command, target, data } = req.body;
-        // Fast-check: pastikan setidaknya 1 Studio aktif polling
-        if (studioEventQueues.size === 0) {
-            await new Promise(r => setTimeout(r, 2000));
-            if (studioEventQueues.size === 0) {
+        const { command, target, data, placeId, studioId, remainingMs } = req.body;
+        // Fast-check: pastikan Studio yang cocok aktif polling / websocket (Bug #3)
+        if (!isStudioConnected({ placeId, studioId })) {
+            for (let i = 0; i < 10; i++) {
+                await new Promise(r => setTimeout(r, 50));
+                if (isStudioConnected({ placeId, studioId }))
+                    break;
+            }
+            if (!isStudioConnected({ placeId, studioId })) {
                 return res.json({
                     status: 'error',
-                    error: 'Roblox Studio tidak terdeteksi aktif. Pastikan Roblox Studio dibuka, place telah dimuat, dan plugin nvstudio-mcp dalam status terhubung.'
+                    error: placeId !== undefined
+                        ? `Roblox Studio dengan Place ID ${placeId} tidak terdeteksi aktif.`
+                        : 'Roblox Studio tidak terdeteksi aktif. Pastikan Roblox Studio dibuka, place telah dimuat, dan plugin nvstudio-mcp dalam status terhubung.'
                 });
             }
         }
         try {
-            const result = await (0, task_queue_1.addTaskToQueue)(command, target, data);
+            const result = await (0, task_queue_1.addTaskToQueue)(command, target, data, { placeId, studioId, remainingMs });
             res.json({ status: 'success', result });
         }
         catch (err) {
-            res.json({ status: 'error', error: err.message });
+            res.json({ status: 'error', error: err?.message || String(err) });
         }
     });
     // ── /api/tasks (legacy long-poll — dipertahankan untuk backward-compat) ───
     // Studio lama yang belum update plugin masih bisa bekerja via polling.
+    // Menggunakan claimTask secara atomik untuk mencegah perebutan task (Bug D & E).
     const waitingPollers = [];
     task_queue_1.taskEmitter.on('new_task', (task) => {
+        if (task.deliveredVia)
+            return; // Abaikan jika task sudah terkirim via WS atau Stream
         if (waitingPollers.length > 0) {
+            const claimed = (0, task_queue_1.claimTask)(task.id, 'legacy');
+            if (!claimed)
+                return;
             const pollRes = waitingPollers.shift();
             const index = task_queue_1.taskQueue.findIndex(t => t.id === task.id);
             if (index !== -1)
                 task_queue_1.taskQueue.splice(index, 1);
+            removePendingStreamTask(task.id);
             for (const queue of studioEventQueues.values()) {
                 const qIndex = queue.findIndex((e) => e.requestId === task.id);
                 if (qIndex !== -1)
                     queue.splice(qIndex, 1);
             }
             addLog(io, 'task', `[Legacy] Mengirim perintah '${task.command}' ke Studio.`);
-            pollRes?.json(task);
+            pollRes?.json(claimed);
         }
     });
     app.get('/api/tasks', (req, res) => {
-        if (task_queue_1.taskQueue.length > 0) {
-            const task = task_queue_1.taskQueue.shift();
-            addLog(io, 'task', `[Legacy] Mengirim perintah tertunda '${task?.command}' ke Studio.`);
-            res.json(task);
-            return;
+        // Cari task pertama yang belum diklaim oleh transport mana pun
+        const unclaimedIdx = task_queue_1.taskQueue.findIndex(t => !t.deliveredVia);
+        if (unclaimedIdx !== -1) {
+            const candidate = task_queue_1.taskQueue[unclaimedIdx];
+            const claimed = (0, task_queue_1.claimTask)(candidate.id, 'legacy');
+            if (claimed) {
+                task_queue_1.taskQueue.splice(unclaimedIdx, 1);
+                removePendingStreamTask(claimed.id);
+                addLog(io, 'task', `[Legacy] Mengirim perintah tertunda '${claimed.command}' ke Studio.`);
+                return res.json(claimed);
+            }
         }
         waitingPollers.push(res);
-        req.on('close', () => {
+        res.on('close', () => {
             const index = waitingPollers.indexOf(res);
             if (index !== -1)
                 waitingPollers.splice(index, 1);
@@ -393,6 +745,7 @@ function startBridgeServer(port, isDaemon = false) {
         const server = httpServer.listen(port, () => {
             exports.isBridgeHosting = true;
             console.error(`[Bridge] SSE Bridge Server aktif di http://localhost:${port}`);
+            resolveBridgeReady(true);
         });
         server.on('error', async (err) => {
             if (err.code === 'EADDRINUSE') {
@@ -404,6 +757,7 @@ function startBridgeServer(port, isDaemon = false) {
                     if (pingRes.ok) {
                         exports.isBridgeHosting = false;
                         console.error(`[Bridge] Port ${port} sudah digunakan oleh NVStudio Bridge aktif. Menggunakan instance yang sudah berjalan.`);
+                        resolveBridgeReady(false);
                         return;
                     }
                 }
@@ -411,14 +765,16 @@ function startBridgeServer(port, isDaemon = false) {
                 if (retriesLeft > 0) {
                     console.error(`[Bridge] Port ${port} zombie. Mencoba membunuh...`);
                     killZombieOnPort(port);
-                    setTimeout(() => tryListen(retriesLeft - 1), 1500);
+                    setTimeout(() => tryListen(retriesLeft - 1), 500);
                 }
                 else {
                     console.error(`[Bridge] FATAL: Port ${port} tidak dapat dibuka.`);
+                    resolveBridgeReady(false);
                 }
             }
             else {
                 console.error(`[Bridge] FATAL: Gagal mendengarkan port ${port}:`, err.message);
+                resolveBridgeReady(false);
                 process.exit(1);
             }
         });