@mindexec/cli 0.2.58 → 0.2.60

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.58",
+  "version": "0.2.60",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",
@@ -46,7 +46,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@mindexec/remote": "^0.1.11",
+    "@mindexec/remote": "^0.1.13",
     "@openai/codex-sdk": "^0.137.0",
     "chokidar": "^3.6.0",
     "cors": "^2.8.5",

package/remote-hub.js

@@ -107,6 +107,29 @@ function normalizeApprovalLevel(value) {
     return level === 'ai-assist' ? 'ai-assist' : 'task-only';
 }
 
+function normalizeRemoteInputEvent(value = {}) {
+    const input = value && typeof value === 'object' ? value : {};
+    const type = safeString(input.type || input.Type, 48);
+    const normalizedX = Number(input.normalizedX ?? input.NormalizedX);
+    const normalizedY = Number(input.normalizedY ?? input.NormalizedY);
+    const deltaX = Number(input.deltaX ?? input.DeltaX);
+    const deltaY = Number(input.deltaY ?? input.DeltaY);
+    return {
+        type,
+        normalizedX: Number.isFinite(normalizedX) ? Math.max(0, Math.min(1, normalizedX)) : undefined,
+        normalizedY: Number.isFinite(normalizedY) ? Math.max(0, Math.min(1, normalizedY)) : undefined,
+        button: safeString(input.button || input.Button, 24),
+        deltaX: Number.isFinite(deltaX) ? Math.max(-4096, Math.min(4096, deltaX)) : 0,
+        deltaY: Number.isFinite(deltaY) ? Math.max(-4096, Math.min(4096, deltaY)) : 0,
+        key: safeString(input.key || input.Key, 80),
+        code: safeString(input.code || input.Code, 80),
+        text: safeText(input.text || input.Text, 256),
+        repeat: input.repeat === true || input.Repeat === true,
+        controlLeaseId: safeString(input.controlLeaseId || input.ControlLeaseId, 128),
+        issuedAt: safeString(input.issuedAt || input.IssuedAt, 80)
+    };
+}
+
 function readCapabilityFlag(capabilities, key) {
     const value = capabilities?.[key];
     if (typeof value === 'boolean') {
@@ -1722,6 +1745,34 @@ export function createRemoteHub(options = {}) {
         return { ok: true, commandId };
     }
 
+    function sendInputControl(deviceId, input = {}) {
+        const device = devices.get(String(deviceId || ''));
+        if (!device) {
+            return { ok: false, error: 'device-not-found' };
+        }
+
+        if (!device.connected) {
+            return { ok: false, error: 'device-not-connected' };
+        }
+
+        if (!readCapabilityFlag(device.capabilities, 'control')) {
+            return { ok: false, error: 'device-input-control-unavailable' };
+        }
+
+        const normalized = normalizeRemoteInputEvent(input);
+        if (!normalized.type) {
+            return { ok: false, error: 'missing-input-type' };
+        }
+
+        return sendCommand(deviceId, {
+            command: 'input.control',
+            payload: {
+                ...normalized,
+                issuedAt: normalized.issuedAt || new Date().toISOString()
+            }
+        });
+    }
+
     function requestAgentTask(deviceId, options = {}) {
         const device = devices.get(String(deviceId || ''));
         if (!device) {
@@ -2131,6 +2182,7 @@ export function createRemoteHub(options = {}) {
         listDeviceFrames,
         disconnectDevice,
         sendCommand,
+        sendInputControl,
         requestAgentTask,
         requestAgentTaskBatch,
         setHostTarget,

package/scripts/remote-http-smoke.mjs

@@ -270,6 +270,19 @@ async function runSyntheticEnabledSmoke() {
     assert.equal(devicesResult.payload?.devices?.length, SYNTHETIC_COUNT);
     assert.equal(devicesResult.payload.devices.some(device => device.connected === false), true);
 
+    const noControlTarget = devicesResult.payload.devices.find(device => device.connected);
+    assert.ok(noControlTarget);
+    const inputUnavailable = await fetchJson(`${baseUrl}/api/remote/devices/${encodeURIComponent(noControlTarget.deviceId)}/input`, {
+        method: 'POST',
+        token: BRIDGE_TOKEN,
+        body: JSON.stringify({
+            type: 'noop'
+        })
+    });
+    assert.equal(inputUnavailable.ok, true, JSON.stringify(inputUnavailable.payload));
+    assert.equal(inputUnavailable.payload?.ok, false);
+    assert.equal(inputUnavailable.payload?.error, 'device-input-control-unavailable');
+
     const connectedTargets = devicesResult.payload.devices
         .filter(device => device.connected && device.capabilities?.taskDispatch)
         .slice(0, 500)

package/scripts/remote-hub-smoke.mjs

@@ -73,7 +73,7 @@ try {
         capabilities: {
             status: true,
             thumbnail: false,
-            control: false,
+            control: true,
             liveStream: true,
             computerAgent: true,
             taskDispatch: true,
@@ -99,6 +99,24 @@ try {
     assert.equal(devices[0].connected, true);
     assert.equal(hub.getStatus().deviceCount, 1);
 
+    const inputCommand = hub.sendInputControl('smoke-device', {
+        type: 'noop'
+    });
+    assert.equal(inputCommand.ok, true);
+    writeJsonLine(socket, {
+        type: 'command.result',
+        commandId: inputCommand.commandId,
+        result: {
+            input: true,
+            handled: true
+        }
+    });
+    const inputDevice = await waitFor(() => {
+        const current = hub.listDevices();
+        return current[0]?.counters?.commandResultsReceived === 1 ? current[0] : null;
+    });
+    assert.equal(inputDevice.counters.commandsSent, 1);
+
     const thumbnailCommand = hub.requestThumbnail('smoke-device', {
         streamId: 'smoke-thumb',
         maxWidth: 320,

package/server.js

@@ -7398,6 +7398,10 @@ app.post('/api/remote/devices/:deviceId/ping', (req, res) => {
     }));
 });
 
+app.post('/api/remote/devices/:deviceId/input', (req, res) => {
+    res.json(remoteHub.sendInputControl(req.params.deviceId, req.body || {}));
+});
+
 app.post('/api/remote/devices/:deviceId/tasks', (req, res) => {
     res.json(remoteHub.requestAgentTask(req.params.deviceId, {
         instruction: req.body?.instruction,

package/wwwroot/_content/MindExecution.Shared/js/mind-map-css3d-manager.js

@@ -12863,6 +12863,7 @@
     const REMOTE_FLEET_HOST_LEASE_REFRESH_MS = 10000;
     const remoteFleetHostLeaseTimers = new Map();
     const remoteFleetLocalHostTargets = new Map();
+    let activeRemoteFleetControlPopup = null;
 
     function findRemoteFleetBodyByNodeId(nodeId) {
         const id = String(nodeId || '').trim();
@@ -13233,7 +13234,7 @@
         if (canvas.height !== nextHeight) {
             canvas.height = nextHeight;
         }
-        return { width: nextWidth, height: nextHeight };
+        return { width: nextWidth, height: nextHeight, cssWidth, cssHeight, dpr };
     }
 
     function getRemoteFleetBitmapSize(bitmap) {
@@ -13245,7 +13246,7 @@
         };
     }
 
-    function drawRemoteFleetFrameToCanvas(canvas, bitmap) {
+    function drawRemoteFleetFrameToCanvas(canvas, bitmap, fitMode = 'cover') {
         if (!canvas || !bitmap) {
             return false;
         }
@@ -13272,18 +13273,40 @@
         let sy = 0;
         let sw = source.width;
         let sh = source.height;
-        if (sourceAspect > targetAspect) {
-            sw = source.height * targetAspect;
-            sx = (source.width - sw) / 2;
-        } else if (sourceAspect < targetAspect) {
-            sh = source.width / targetAspect;
-            sy = (source.height - sh) / 2;
+        let dx = 0;
+        let dy = 0;
+        let dw = size.width;
+        let dh = size.height;
+        if (fitMode === 'contain') {
+            if (sourceAspect > targetAspect) {
+                dh = size.width / sourceAspect;
+                dy = (size.height - dh) / 2;
+            } else if (sourceAspect < targetAspect) {
+                dw = size.height * sourceAspect;
+                dx = (size.width - dw) / 2;
+            }
+        } else {
+            if (sourceAspect > targetAspect) {
+                sw = source.height * targetAspect;
+                sx = (source.width - sw) / 2;
+            } else if (sourceAspect < targetAspect) {
+                sh = source.width / targetAspect;
+                sy = (source.height - sh) / 2;
+            }
         }
 
         context.imageSmoothingEnabled = true;
         context.imageSmoothingQuality = 'medium';
+        context.fillStyle = '#020617';
         context.clearRect(0, 0, size.width, size.height);
-        context.drawImage(bitmap, sx, sy, sw, sh, 0, 0, size.width, size.height);
+        context.fillRect(0, 0, size.width, size.height);
+        context.drawImage(bitmap, sx, sy, sw, sh, dx, dy, dw, dh);
+        canvas._remoteFleetContentRect = {
+            left: dx / size.dpr,
+            top: dy / size.dpr,
+            width: dw / size.dpr,
+            height: dh / size.dpr
+        };
         return true;
     }
 
@@ -13696,6 +13719,503 @@
         bodyView._remoteFleetFrameLoopRaf = requestRemoteFleetFrameLoopFrame(loop);
     }
 
+    function getRemoteFleetControlPoint(event, canvas, allowClamp = false) {
+        if (!event || !canvas) {
+            return null;
+        }
+
+        const canvasRect = canvas.getBoundingClientRect?.();
+        if (!canvasRect || canvasRect.width <= 0 || canvasRect.height <= 0) {
+            return null;
+        }
+
+        const content = canvas._remoteFleetContentRect || {
+            left: 0,
+            top: 0,
+            width: canvasRect.width,
+            height: canvasRect.height
+        };
+        if (!content.width || !content.height) {
+            return null;
+        }
+
+        let x = event.clientX - canvasRect.left - content.left;
+        let y = event.clientY - canvasRect.top - content.top;
+        const outside = x < 0 || y < 0 || x > content.width || y > content.height;
+        if (outside && !allowClamp) {
+            return null;
+        }
+
+        x = Math.max(0, Math.min(content.width, x));
+        y = Math.max(0, Math.min(content.height, y));
+        return {
+            normalizedX: x / content.width,
+            normalizedY: y / content.height
+        };
+    }
+
+    function getRemoteFleetPointerButton(event) {
+        switch (Number(event?.button ?? 0)) {
+            case 1:
+                return 'middle';
+            case 2:
+                return 'right';
+            default:
+                return 'left';
+        }
+    }
+
+    function closeRemoteFleetControlPopup(reason = 'close') {
+        const session = activeRemoteFleetControlPopup;
+        if (!session) {
+            return;
+        }
+
+        activeRemoteFleetControlPopup = null;
+        session.active = false;
+        if (session.timer) {
+            clearTimeout(session.timer);
+            session.timer = null;
+        }
+        if (session.moveTimer) {
+            clearTimeout(session.moveTimer);
+            session.moveTimer = null;
+        }
+        session.overlay?.remove?.();
+        window.RuntimeTrace?.emit?.('remote.control.closed', {
+            nodeId: session.nodeId,
+            deviceId: session.deviceId,
+            reason
+        });
+
+        if (session.startedStream && !session.wasLiveActive) {
+            invokeDotNetAsync('StopRemoteFleetLiveStreamFromJs', session.nodeId, session.deviceId, session.streamId || '')
+                .catch(() => undefined);
+        }
+    }
+
+    async function paintRemoteFleetControlFrame(session, frame) {
+        if (!session?.active || !frame || !isRemoteFleetFrameSource(frame.frameUrl)) {
+            return false;
+        }
+
+        try {
+            const bitmap = await loadRemoteFleetFrameBitmap(frame);
+            if (!bitmap || !session.active) {
+                return false;
+            }
+
+            requestRemoteFleetFrameLoopFrame(() => {
+                if (!session.active || !document.body.contains(session.overlay)) {
+                    if (typeof bitmap.close === 'function') {
+                        bitmap.close();
+                    }
+                    return;
+                }
+
+                drawRemoteFleetFrameToCanvas(session.canvas, bitmap, 'contain');
+                session.canvas.style.display = 'block';
+                if (typeof bitmap.close === 'function') {
+                    bitmap.close();
+                }
+            });
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    function sendRemoteFleetControlInput(session, payload, throttleMove = false) {
+        if (!session?.active || !payload?.type) {
+            return;
+        }
+
+        const send = next => {
+            if (!session.active) {
+                return;
+            }
+            invokeDotNetAsync('SendRemoteFleetInputFromJs', session.nodeId, session.deviceId, {
+                ...next,
+                controlLeaseId: session.controlLeaseId,
+                issuedAt: new Date().toISOString()
+            }).catch(error => {
+                session.status.textContent = error?.message || 'Input failed';
+            });
+        };
+
+        if (!throttleMove) {
+            send(payload);
+            return;
+        }
+
+        const now = performance.now();
+        const elapsed = now - (session.lastMoveSentAt || 0);
+        if (elapsed >= 32) {
+            session.lastMoveSentAt = now;
+            send(payload);
+            return;
+        }
+
+        session.pendingMove = payload;
+        if (session.moveTimer) {
+            return;
+        }
+
+        session.moveTimer = setTimeout(() => {
+            session.moveTimer = null;
+            const next = session.pendingMove;
+            session.pendingMove = null;
+            if (next) {
+                session.lastMoveSentAt = performance.now();
+                send(next);
+            }
+        }, Math.max(1, 32 - elapsed));
+    }
+
+    function bindRemoteFleetControlInput(session) {
+        const { overlay, shell, stage, canvas } = session;
+        let pointerActive = false;
+
+        ['mousedown', 'mouseup', 'click', 'dblclick', 'keydown', 'keyup', 'wheel', 'contextmenu'].forEach(eventName => {
+            overlay.addEventListener(eventName, event => event.stopPropagation(), true);
+        });
+
+        stage.addEventListener('pointerdown', event => {
+            const point = getRemoteFleetControlPoint(event, canvas, false);
+            if (!point) {
+                return;
+            }
+
+            event.preventDefault();
+            event.stopPropagation();
+            pointerActive = true;
+            shell.focus({ preventScroll: true });
+            stage.setPointerCapture?.(event.pointerId);
+            sendRemoteFleetControlInput(session, {
+                type: 'pointerDown',
+                ...point,
+                button: getRemoteFleetPointerButton(event)
+            });
+        });
+
+        stage.addEventListener('pointermove', event => {
+            const point = getRemoteFleetControlPoint(event, canvas, pointerActive);
+            if (!point) {
+                return;
+            }
+
+            event.preventDefault();
+            event.stopPropagation();
+            sendRemoteFleetControlInput(session, {
+                type: 'pointerMove',
+                ...point,
+                button: getRemoteFleetPointerButton(event)
+            }, true);
+        });
+
+        stage.addEventListener('pointerup', event => {
+            const point = getRemoteFleetControlPoint(event, canvas, true);
+            event.preventDefault();
+            event.stopPropagation();
+            pointerActive = false;
+            stage.releasePointerCapture?.(event.pointerId);
+            if (!point) {
+                return;
+            }
+
+            sendRemoteFleetControlInput(session, {
+                type: 'pointerUp',
+                ...point,
+                button: getRemoteFleetPointerButton(event)
+            });
+        });
+
+        stage.addEventListener('pointercancel', event => {
+            pointerActive = false;
+            stage.releasePointerCapture?.(event.pointerId);
+        });
+
+        stage.addEventListener('wheel', event => {
+            const point = getRemoteFleetControlPoint(event, canvas, false);
+            if (!point) {
+                return;
+            }
+
+            event.preventDefault();
+            event.stopPropagation();
+            sendRemoteFleetControlInput(session, {
+                type: 'wheel',
+                ...point,
+                deltaX: event.deltaX,
+                deltaY: event.deltaY
+            });
+        }, { passive: false });
+
+        stage.addEventListener('contextmenu', event => {
+            event.preventDefault();
+            event.stopPropagation();
+        });
+
+        shell.addEventListener('keydown', event => {
+            if (event.target?.closest?.('[data-remote-fleet-control-close="true"]')) {
+                return;
+            }
+
+            event.preventDefault();
+            event.stopPropagation();
+            sendRemoteFleetControlInput(session, {
+                type: 'keyDown',
+                key: event.key,
+                code: event.code,
+                repeat: event.repeat === true
+            });
+        });
+
+        shell.addEventListener('keyup', event => {
+            if (event.target?.closest?.('[data-remote-fleet-control-close="true"]')) {
+                return;
+            }
+
+            event.preventDefault();
+            event.stopPropagation();
+            sendRemoteFleetControlInput(session, {
+                type: 'keyUp',
+                key: event.key,
+                code: event.code,
+                repeat: event.repeat === true
+            });
+        });
+    }
+
+    function openRemoteFleetControlPopup(bodyView, nodeModel, deviceId) {
+        const nodeId = String(nodeModel?.id ?? nodeModel?.Id ?? '').trim();
+        const targetId = String(deviceId || '').trim();
+        if (!bodyView || !nodeId || !targetId) {
+            return;
+        }
+
+        closeRemoteFleetControlPopup('replace');
+        const devices = parseRemoteFleetDevices(nodeModel);
+        const device = devices.find(item => getRemoteFleetDeviceId(item) === targetId) || null;
+        const name = device ? getRemoteFleetDeviceName(device) : targetId;
+        const wasLiveActive = device ? isRemoteFleetLiveActive(device) : false;
+
+        const overlay = document.createElement('div');
+        overlay.dataset.remoteFleetControlPopup = 'true';
+        overlay.style.cssText = `
+            position: fixed;
+            inset: 0;
+            z-index: 2147483000;
+            display: grid;
+            place-items: center;
+            padding: 24px;
+            background: rgba(15, 23, 42, 0.24);
+            pointer-events: auto;
+            box-sizing: border-box;
+        `;
+
+        const shell = document.createElement('section');
+        shell.tabIndex = 0;
+        shell.dataset.remoteFleetControlShell = 'true';
+        shell.style.cssText = `
+            width: min(96vw, 1280px);
+            height: min(90vh, 860px);
+            min-width: min(720px, calc(100vw - 28px));
+            min-height: min(420px, calc(100vh - 28px));
+            display: flex;
+            flex-direction: column;
+            overflow: hidden;
+            border-radius: 8px;
+            border: 1px solid rgba(148, 163, 184, 0.34);
+            background: #020617;
+            box-shadow: 0 24px 70px rgba(15, 23, 42, 0.35);
+            outline: none;
+            box-sizing: border-box;
+        `;
+
+        const header = document.createElement('header');
+        header.style.cssText = `
+            flex: 0 0 auto;
+            height: 42px;
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            gap: 12px;
+            padding: 0 10px 0 14px;
+            background: rgba(15, 23, 42, 0.96);
+            border-bottom: 1px solid rgba(148, 163, 184, 0.20);
+            box-sizing: border-box;
+        `;
+
+        const title = document.createElement('strong');
+        title.textContent = name;
+        title.title = `${name} (${targetId})`;
+        title.style.cssText = `
+            min-width: 0;
+            color: #f8fafc;
+            font-size: 13px;
+            font-weight: 950;
+            line-height: 1;
+            letter-spacing: 0;
+            overflow: hidden;
+            text-overflow: ellipsis;
+            white-space: nowrap;
+        `;
+
+        const right = document.createElement('div');
+        right.style.cssText = 'flex:0 0 auto;display:flex;align-items:center;gap:8px;min-width:0;';
+        const status = document.createElement('span');
+        status.dataset.remoteFleetControlStatus = 'true';
+        status.textContent = 'Connecting';
+        status.style.cssText = `
+            color: #cbd5e1;
+            font-size: 11px;
+            font-weight: 850;
+            letter-spacing: 0;
+            white-space: nowrap;
+        `;
+        const closeButton = document.createElement('button');
+        closeButton.type = 'button';
+        closeButton.dataset.remoteFleetControlClose = 'true';
+        closeButton.textContent = 'X';
+        closeButton.title = 'Close';
+        closeButton.style.cssText = `
+            width: 30px;
+            height: 30px;
+            display: inline-flex;
+            align-items: center;
+            justify-content: center;
+            border-radius: 7px;
+            border: 1px solid rgba(148, 163, 184, 0.34);
+            background: rgba(30, 41, 59, 0.96);
+            color: #f8fafc;
+            font-size: 13px;
+            font-weight: 950;
+            line-height: 1;
+            cursor: pointer;
+            pointer-events: auto;
+        `;
+
+        const stage = document.createElement('div');
+        stage.dataset.remoteFleetControlStage = 'true';
+        stage.style.cssText = `
+            position: relative;
+            flex: 1 1 auto;
+            min-height: 0;
+            overflow: hidden;
+            background: #020617;
+            cursor: crosshair;
+            touch-action: none;
+        `;
+
+        const canvas = document.createElement('canvas');
+        canvas.dataset.remoteFleetControlCanvas = 'true';
+        canvas.style.cssText = `
+            position: absolute;
+            inset: 0;
+            width: 100%;
+            height: 100%;
+            display: block;
+            background: #020617;
+        `;
+
+        right.appendChild(status);
+        right.appendChild(closeButton);
+        header.appendChild(title);
+        header.appendChild(right);
+        stage.appendChild(canvas);
+        shell.appendChild(header);
+        shell.appendChild(stage);
+        overlay.appendChild(shell);
+        document.body.appendChild(overlay);
+
+        const session = {
+            active: true,
+            nodeId,
+            deviceId: targetId,
+            overlay,
+            shell,
+            stage,
+            canvas,
+            status,
+            wasLiveActive,
+            startedStream: false,
+            streamId: '',
+            controlLeaseId: `control-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+            timer: null,
+            moveTimer: null,
+            pendingMove: null,
+            lastMoveSentAt: 0
+        };
+        activeRemoteFleetControlPopup = session;
+        bindRemoteFleetControlInput(session);
+
+        const refresh = async () => {
+            if (!session.active) {
+                return;
+            }
+
+            try {
+                const result = await invokeDotNetAsync('GetRemoteFleetFrameFromJs', nodeId, targetId, 'live');
+                const frame = normalizeRemoteFleetFramePayload(result?.frame || result?.Frame, 'live');
+                if (frame) {
+                    frame.deviceId = frame.deviceId || targetId;
+                    await paintRemoteFleetControlFrame(session, frame);
+                    applyRemoteFleetFramePatches(bodyView, [frame]);
+                    status.textContent = 'Control';
+                } else if (result?.error || result?.Error) {
+                    status.textContent = result.error || result.Error;
+                }
+            } catch (error) {
+                status.textContent = error?.message || 'Frame failed';
+            } finally {
+                if (session.active) {
+                    session.timer = setTimeout(refresh, REMOTE_FLEET_LIVE_FRAME_REFRESH_MS);
+                }
+            }
+        };
+
+        closeButton.addEventListener('click', event => {
+            event.preventDefault();
+            event.stopPropagation();
+            closeRemoteFleetControlPopup('button');
+        });
+        overlay.addEventListener('pointerdown', event => {
+            if (event.target === overlay) {
+                event.preventDefault();
+                event.stopPropagation();
+                shell.focus({ preventScroll: true });
+            }
+        });
+
+        shell.focus({ preventScroll: true });
+        window.RuntimeTrace?.emit?.('remote.control.opened', {
+            nodeId,
+            deviceId: targetId
+        });
+
+        invokeDotNetAsync('StartRemoteFleetLiveStreamFromJs', nodeId, targetId)
+            .then(async result => {
+                if (!session.active) {
+                    return;
+                }
+
+                await syncRemoteFleetNodeStateFromResult(result);
+                session.startedStream = result?.success === true || result?.Success === true;
+                session.streamId = String(result?.streamId || result?.StreamId || '');
+                status.textContent = session.startedStream ? 'Control' : (result?.error || result?.Error || 'View');
+                refresh();
+            })
+            .catch(error => {
+                if (!session.active) {
+                    return;
+                }
+
+                status.textContent = error?.message || 'Start failed';
+                refresh();
+            });
+    }
+
     function isRemoteFleetLiveActive(device) {
         return getRemoteFleetDeviceField(device, 'liveStreamActive', 'LiveStreamActive', false) === true;
     }
@@ -15155,7 +15675,15 @@
                 : 'Offline';
 
             panel.dataset.deviceId = deviceId;
-            panel.appendChild(createDevicePreview(device, 'detail'));
+            const detailPreview = createDevicePreview(device, 'detail');
+            detailPreview.style.cursor = 'pointer';
+            detailPreview.addEventListener('dblclick', event => {
+                event.preventDefault();
+                event.stopPropagation();
+                bodyView.dataset.remoteFleetSelectedDeviceId = deviceId;
+                openRemoteFleetControlPopup(bodyView, nodeModel, deviceId);
+            });
+            panel.appendChild(detailPreview);
 
             const header = document.createElement('div');
             header.style.cssText = 'display:flex;align-items:flex-start;justify-content:space-between;gap:8px;min-width:0;';
@@ -15712,6 +16240,14 @@
             ['mousedown', 'mouseup', 'dblclick'].forEach(eventName => {
                 card.addEventListener(eventName, event => event.stopPropagation());
             });
+            card.addEventListener('dblclick', event => {
+                event.preventDefault();
+                event.stopPropagation();
+                const deviceId = String(card.dataset.deviceId || '').trim();
+                if (!deviceId) return;
+                bodyView.dataset.remoteFleetSelectedDeviceId = deviceId;
+                openRemoteFleetControlPopup(bodyView, nodeModel, deviceId);
+            });
             const selectCard = event => {
                 event.preventDefault();
                 event.stopPropagation();
@@ -20057,6 +20593,8 @@
         renderRemoteFleetMonitorForTest: renderRemoteFleetMonitor,
         renderRemoteFleetDeviceForTest: renderRemoteFleetDevice,
         applyRemoteFleetFramePatchesForTest: applyRemoteFleetFramePatches,
+        openRemoteFleetControlPopupForTest: openRemoteFleetControlPopup,
+        closeRemoteFleetControlPopupForTest: closeRemoteFleetControlPopup,
         renderBusinessAutomationEdges: renderBusinessAutomationEdges,
         scheduleBusinessAutomationEdgeRender: scheduleBusinessAutomationEdgeRender,
         syncBusinessAutomationSelectionContext: syncBusinessAutomationSelectionContext,

package/wwwroot/_framework/blazor.boot.json

@@ -1,7 +1,7 @@
 {
   "mainAssemblyName": "MindExecution.Web",
   "resources": {
-    "hash": "sha256-GGI2WWoqeuPkRYhJN5PE3420fp6QkcG1SsPGtrx1RZI=",
+    "hash": "sha256-l0rUZQzwxawYMB769NYWezdvZX6nmiykgEkj3JAhG6I=",
     "fingerprinting": {
       "Google.Protobuf.9h59ukbel7.dll": "Google.Protobuf.dll",
       "Markdig.d1j7v41cl1.dll": "Markdig.dll",
@@ -123,16 +123,16 @@
       "System.brmz7yk5qh.dll": "System.dll",
       "netstandard.yvr3prsx0x.dll": "netstandard.dll",
       "System.Private.CoreLib.56o0tq2bfs.dll": "System.Private.CoreLib.dll",
-      "MindExecution.Core.fu1rl67yt3.dll": "MindExecution.Core.dll",
-      "MindExecution.Kernel.cqcbagjpqb.dll": "MindExecution.Kernel.dll",
-      "MindExecution.Plugins.Admin.tsn0j478un.dll": "MindExecution.Plugins.Admin.dll",
-      "MindExecution.Plugins.Business.xg74dmn0vz.dll": "MindExecution.Plugins.Business.dll",
-      "MindExecution.Plugins.Concept.xyf0dtv4lr.dll": "MindExecution.Plugins.Concept.dll",
-      "MindExecution.Plugins.Directory.9i4bd043ia.dll": "MindExecution.Plugins.Directory.dll",
-      "MindExecution.Plugins.PlanMaster.6awpgrbi0w.dll": "MindExecution.Plugins.PlanMaster.dll",
-      "MindExecution.Plugins.YouTube.phonjrgb40.dll": "MindExecution.Plugins.YouTube.dll",
-      "MindExecution.Shared.wv4gm07egs.dll": "MindExecution.Shared.dll",
-      "MindExecution.Web.2qteyfmk41.dll": "MindExecution.Web.dll",
+      "MindExecution.Core.csfu1xtj3l.dll": "MindExecution.Core.dll",
+      "MindExecution.Kernel.mdo1lzjvvp.dll": "MindExecution.Kernel.dll",
+      "MindExecution.Plugins.Admin.5fctwf65dx.dll": "MindExecution.Plugins.Admin.dll",
+      "MindExecution.Plugins.Business.nwivpk9djf.dll": "MindExecution.Plugins.Business.dll",
+      "MindExecution.Plugins.Concept.308c7mlarq.dll": "MindExecution.Plugins.Concept.dll",
+      "MindExecution.Plugins.Directory.jnzcrwl049.dll": "MindExecution.Plugins.Directory.dll",
+      "MindExecution.Plugins.PlanMaster.aehonaq3ui.dll": "MindExecution.Plugins.PlanMaster.dll",
+      "MindExecution.Plugins.YouTube.kfaju22v9d.dll": "MindExecution.Plugins.YouTube.dll",
+      "MindExecution.Shared.f6pcmyacv7.dll": "MindExecution.Shared.dll",
+      "MindExecution.Web.md0zip1dt5.dll": "MindExecution.Web.dll",
       "dotnet.js": "dotnet.js",
       "dotnet.native.qc8g39g30v.js": "dotnet.native.js",
       "dotnet.native.boem75ye5i.wasm": "dotnet.native.wasm",
@@ -278,18 +278,18 @@
       "System.Xml.XDocument.sn51jas17n.dll": "sha256-GNI2kFgFmPTwzuzwUn8gxK+AzGLUWRJFdg9JzIbrybQ=",
       "System.brmz7yk5qh.dll": "sha256-CfM2miyj1KHApFmqMdLYWio3S/jrdON2pW9Xr2nTwlo=",
       "netstandard.yvr3prsx0x.dll": "sha256-EksNn8Luo4bOWqJ6X7dIe9qG9oOqwOVzjH2xYyMNi+E=",
-      "MindExecution.Core.fu1rl67yt3.dll": "sha256-6cDbehKdjX71zeL9Ro5GNupn7wqRYfb7yLW2w3Wp05g=",
-      "MindExecution.Kernel.cqcbagjpqb.dll": "sha256-zPB0tmwi/UKdJ//g0xMH1Y02ahDX5ii6ZKdB3yiQQz4=",
-      "MindExecution.Plugins.Concept.xyf0dtv4lr.dll": "sha256-2QH/z68+Z450gJslGXuS1WTwg25aACi2dNm/JuuzJOw=",
-      "MindExecution.Plugins.PlanMaster.6awpgrbi0w.dll": "sha256-rvthfQoAH80iU4oCiDMz24nfVrIz+Frr2fPA5gleTnc=",
-      "MindExecution.Shared.wv4gm07egs.dll": "sha256-RL1/G48EzGToUbnfJMZshn8OM5e4esqQ0smEFP3jTXM=",
-      "MindExecution.Web.2qteyfmk41.dll": "sha256-+uuhv+W15wEynEtGoL9sxAYpLoZjLc2Nsi2BfIOI27A="
+      "MindExecution.Core.csfu1xtj3l.dll": "sha256-lP9GUQU4xFLsUU4IOwpUjt09mQO5M/bgLAAS8UnjLMs=",
+      "MindExecution.Kernel.mdo1lzjvvp.dll": "sha256-Vj21M+Th5MKfLG5Hvg6/uwlDDdwAJwzeIxfWsK9gYhM=",
+      "MindExecution.Plugins.Concept.308c7mlarq.dll": "sha256-ff0bbOHIEgPR3PxOrzh40D/UKFrSpfy82lAsDBVqm3A=",
+      "MindExecution.Plugins.PlanMaster.aehonaq3ui.dll": "sha256-Eq3h56Eo+hYMUyXzKrw99DBsuKUnubRt3AsEAPpbiqw=",
+      "MindExecution.Shared.f6pcmyacv7.dll": "sha256-d0jjV+LnnDo2ZKgByZD+UzDZXUVwHBeKi1Jl18yVarw=",
+      "MindExecution.Web.md0zip1dt5.dll": "sha256-qpKJIKiOZc48Iu2mkzaYuED5LUl8Gf9wL9diDRwie+Y="
     },
     "lazyAssembly": {
-      "MindExecution.Plugins.Admin.tsn0j478un.dll": "sha256-g5Q4Ihy2PJKx6EFB6k78dIszLgK4hZ3Xintjvso/zmw=",
-      "MindExecution.Plugins.Business.xg74dmn0vz.dll": "sha256-0bP/QgMyXSk9IlQVun63rnWvkwqqZmJcRe90QoPC6jw=",
-      "MindExecution.Plugins.Directory.9i4bd043ia.dll": "sha256-b+fpVz2RkQC8uL4dIvN6wMWWefoII84Jyfe85EU/URk=",
-      "MindExecution.Plugins.YouTube.phonjrgb40.dll": "sha256-vdpI8ahzIz5TjeFL3+1pcu+Urei4cJuw6I/y5E1u78Y="
+      "MindExecution.Plugins.Admin.5fctwf65dx.dll": "sha256-37+Egd35menNv18hEZ64qjiu0x1r+wFOuO5zDiOGfug=",
+      "MindExecution.Plugins.Business.nwivpk9djf.dll": "sha256-iTV0NyCB7fnU+l8brClBd+KYnBDw628yHCwoRrQdTWE=",
+      "MindExecution.Plugins.Directory.jnzcrwl049.dll": "sha256-fwo2q8bt+WNuVUMnJCOcfLAy151cjLZCQa0Z+iKdsRs=",
+      "MindExecution.Plugins.YouTube.kfaju22v9d.dll": "sha256-cD63GnjmbdTK8M07roYgXEn4sq3PcyDFgZRJmJg0E2w="
     }
   },
   "cacheBootResources": true,

package/wwwroot/index.html

@@ -7,8 +7,8 @@
     <title>MindExec | Run your ideas as AI task graphs</title>
     <meta name="description" content="MindExec is an AI execution canvas for solo builders, researchers, developers, and creators. Start with free browser tools, then move serious work into saved MindCanvas projects." />
     <base href="/" />
-    <link rel="stylesheet" href="_content/MindExecution.Shared/css/app.css?v=20260614-remote-registry-blocked-v518" />
-    <link rel="stylesheet" href="_content/MindExecution.Shared/css/mind-map-overrides.css?v=20260614-remote-registry-blocked-v518" />
+    <link rel="stylesheet" href="_content/MindExecution.Shared/css/app.css?v=20260614-remote-control-popup-v520" />
+    <link rel="stylesheet" href="_content/MindExecution.Shared/css/mind-map-overrides.css?v=20260614-remote-control-popup-v520" />
     <!-- ?쇄뼹??Font Awesome (local) ?쇄뼹??-->
     <link rel="stylesheet" href="_content/MindExecution.Shared/lib/font-awesome/css/all.min.css" />
     <!-- ?꿎뼯??-->
@@ -558,7 +558,7 @@
             }
 
             const base = '_content/MindExecution.Shared/js/';
-        const scriptVersion = '20260614-remote-registry-blocked-v518';
+        const scriptVersion = '20260614-remote-control-popup-v520';
             const scriptUrl = (script) => `${base}${script}?v=${scriptVersion}`;
             console.log(`[Script Loader] Shared JS version: ${scriptVersion}`);
             const criticalScripts = [

package/wwwroot/service-worker-assets.js

@@ -1,5 +1,5 @@
 self.assetsManifest = {
-    "version":  "QgHVmmuE",
+    "version":  "q4nQljvv",
     "assets":  [
                    {
                        "hash":  "sha256-+CSYMcqLNTsq3VnH11jgYyOCCdxvHzL74CBmo4sCmMU=",
@@ -86,7 +86,7 @@
                        "url":  "_content/MindExecution.Shared/js/mind-map-core.js.backup"
                    },
                    {
-                       "hash":  "sha256-fMca6CVHvUnN7d36WBYPbi2+pTk0jktEGOeU4MtiS6I=",
+                       "hash":  "sha256-Hpm8C+QVeeNTm2sl5AYRvBSgYwhltotJq8mBTm06u5s=",
                        "url":  "_content/MindExecution.Shared/js/mind-map-css3d-manager.js"
                    },
                    {
@@ -410,44 +410,44 @@
                        "url":  "_framework/MimeMapping.og9ys58ylm.dll"
                    },
                    {
-                       "hash":  "sha256-6cDbehKdjX71zeL9Ro5GNupn7wqRYfb7yLW2w3Wp05g=",
-                       "url":  "_framework/MindExecution.Core.fu1rl67yt3.dll"
+                       "hash":  "sha256-lP9GUQU4xFLsUU4IOwpUjt09mQO5M/bgLAAS8UnjLMs=",
+                       "url":  "_framework/MindExecution.Core.csfu1xtj3l.dll"
                    },
                    {
-                       "hash":  "sha256-zPB0tmwi/UKdJ//g0xMH1Y02ahDX5ii6ZKdB3yiQQz4=",
-                       "url":  "_framework/MindExecution.Kernel.cqcbagjpqb.dll"
+                       "hash":  "sha256-Vj21M+Th5MKfLG5Hvg6/uwlDDdwAJwzeIxfWsK9gYhM=",
+                       "url":  "_framework/MindExecution.Kernel.mdo1lzjvvp.dll"
                    },
                    {
-                       "hash":  "sha256-g5Q4Ihy2PJKx6EFB6k78dIszLgK4hZ3Xintjvso/zmw=",
-                       "url":  "_framework/MindExecution.Plugins.Admin.tsn0j478un.dll"
+                       "hash":  "sha256-37+Egd35menNv18hEZ64qjiu0x1r+wFOuO5zDiOGfug=",
+                       "url":  "_framework/MindExecution.Plugins.Admin.5fctwf65dx.dll"
                    },
                    {
-                       "hash":  "sha256-0bP/QgMyXSk9IlQVun63rnWvkwqqZmJcRe90QoPC6jw=",
-                       "url":  "_framework/MindExecution.Plugins.Business.xg74dmn0vz.dll"
+                       "hash":  "sha256-iTV0NyCB7fnU+l8brClBd+KYnBDw628yHCwoRrQdTWE=",
+                       "url":  "_framework/MindExecution.Plugins.Business.nwivpk9djf.dll"
                    },
                    {
-                       "hash":  "sha256-2QH/z68+Z450gJslGXuS1WTwg25aACi2dNm/JuuzJOw=",
-                       "url":  "_framework/MindExecution.Plugins.Concept.xyf0dtv4lr.dll"
+                       "hash":  "sha256-ff0bbOHIEgPR3PxOrzh40D/UKFrSpfy82lAsDBVqm3A=",
+                       "url":  "_framework/MindExecution.Plugins.Concept.308c7mlarq.dll"
                    },
                    {
-                       "hash":  "sha256-b+fpVz2RkQC8uL4dIvN6wMWWefoII84Jyfe85EU/URk=",
-                       "url":  "_framework/MindExecution.Plugins.Directory.9i4bd043ia.dll"
+                       "hash":  "sha256-fwo2q8bt+WNuVUMnJCOcfLAy151cjLZCQa0Z+iKdsRs=",
+                       "url":  "_framework/MindExecution.Plugins.Directory.jnzcrwl049.dll"
                    },
                    {
-                       "hash":  "sha256-rvthfQoAH80iU4oCiDMz24nfVrIz+Frr2fPA5gleTnc=",
-                       "url":  "_framework/MindExecution.Plugins.PlanMaster.6awpgrbi0w.dll"
+                       "hash":  "sha256-Eq3h56Eo+hYMUyXzKrw99DBsuKUnubRt3AsEAPpbiqw=",
+                       "url":  "_framework/MindExecution.Plugins.PlanMaster.aehonaq3ui.dll"
                    },
                    {
-                       "hash":  "sha256-vdpI8ahzIz5TjeFL3+1pcu+Urei4cJuw6I/y5E1u78Y=",
-                       "url":  "_framework/MindExecution.Plugins.YouTube.phonjrgb40.dll"
+                       "hash":  "sha256-cD63GnjmbdTK8M07roYgXEn4sq3PcyDFgZRJmJg0E2w=",
+                       "url":  "_framework/MindExecution.Plugins.YouTube.kfaju22v9d.dll"
                    },
                    {
-                       "hash":  "sha256-RL1/G48EzGToUbnfJMZshn8OM5e4esqQ0smEFP3jTXM=",
-                       "url":  "_framework/MindExecution.Shared.wv4gm07egs.dll"
+                       "hash":  "sha256-d0jjV+LnnDo2ZKgByZD+UzDZXUVwHBeKi1Jl18yVarw=",
+                       "url":  "_framework/MindExecution.Shared.f6pcmyacv7.dll"
                    },
                    {
-                       "hash":  "sha256-+uuhv+W15wEynEtGoL9sxAYpLoZjLc2Nsi2BfIOI27A=",
-                       "url":  "_framework/MindExecution.Web.2qteyfmk41.dll"
+                       "hash":  "sha256-qpKJIKiOZc48Iu2mkzaYuED5LUl8Gf9wL9diDRwie+Y=",
+                       "url":  "_framework/MindExecution.Web.md0zip1dt5.dll"
                    },
                    {
                        "hash":  "sha256-IsZJ91/OW+fHzNqIgEc7Y072ns8z9dGritiSyvR9Wgc=",
@@ -770,7 +770,7 @@
                        "url":  "_framework/Websocket.Client.vapounvmnl.dll"
                    },
                    {
-                       "hash":  "sha256-ZaW4vC90Zm3dpEK9VB9owbWEJBm8a4veU8BM6Noiw6k=",
+                       "hash":  "sha256-CDOU2IS0GIaVy4XgMH6a58a/snr2MNiRrkgC6bDYh2c=",
                        "url":  "_framework/blazor.boot.json"
                    },
                    {
@@ -834,7 +834,7 @@
                        "url":  "image-manifest.json"
                    },
                    {
-                       "hash":  "sha256-rpCaVooQL1nYxs2JIxk6ihbPz4jeJBu3uKs7hNTRQVo=",
+                       "hash":  "sha256-YLUJP8pDrnICpJVJMu74xySAXab4MDvWn40Ox6fsNbg=",
                        "url":  "index.html"
                    },
                    {

package/wwwroot/service-worker.js

@@ -1,4 +1,4 @@
-/* Manifest version: QgHVmmuE */
+/* Manifest version: q4nQljvv */
 // Hosted deployments should prefer the network over stale offline caches.
 // This service worker immediately clears old Blazor offline caches and unregisters itself.