@mindexec/cli 0.2.10 → 0.2.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",
@@ -20,8 +20,10 @@
   "scripts": {
     "start": "node launch-bridge.cjs",
     "dev": "node launch-bridge.cjs --watch",
-    "test:syntax": "node --check server.js && node --check remote-hub.js && node --check codex-runtime.js && node --check launch-bridge.cjs && node --check port-guard.cjs && node --check scripts/setup-tree-sitter-grammars.mjs && node --check scripts/remote-hub-smoke.mjs",
+    "test:syntax": "node --check server.js && node --check remote-hub.js && node --check codex-runtime.js && node --check launch-bridge.cjs && node --check port-guard.cjs && node --check scripts/setup-tree-sitter-grammars.mjs && node --check scripts/remote-hub-smoke.mjs && node --check scripts/remote-hub-scale-smoke.mjs && node --check scripts/remote-fleet-render-smoke.mjs",
     "test:remote": "node scripts/remote-hub-smoke.mjs",
+    "test:remote:scale": "node scripts/remote-hub-scale-smoke.mjs",
+    "test:remote:render": "node scripts/remote-fleet-render-smoke.mjs",
     "pack:dry": "npm pack --dry-run",
     "setup:grammars": "node scripts/setup-tree-sitter-grammars.mjs",
     "postinstall": "npm run setup:grammars"

package/remote-hub.js

@@ -12,6 +12,8 @@ const MAX_AGENT_TASK_CHARS = 4000;
 const MAX_AGENT_TASK_RESULT_CHARS = 3000;
 const RECENT_TASK_LIMIT = 12;
 const REMOTE_PROTOCOL_VERSION = 1;
+const MAX_SYNTHETIC_DEVICES = 1000;
+const SYNTHETIC_FRAME_DATA_URL = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAABCAYAAAD0In+KAAAADElEQVR42mP8z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC';
 
 function isEnabledValue(value, fallback = true) {
     if (value === undefined || value === null || value === '') {
@@ -62,6 +64,25 @@ function readCapabilityFlag(capabilities, key) {
     return /^(1|true|yes|on)$/i.test(String(value || '').trim());
 }
 
+function createDeviceCounters(overrides = {}) {
+    return {
+        messagesReceived: 0,
+        statusReceived: 0,
+        commandsSent: 0,
+        commandResultsReceived: 0,
+        thumbnailFramesReceived: 0,
+        thumbnailFramesDropped: 0,
+        liveFramesReceived: 0,
+        liveFramesDropped: 0,
+        liveStreamsStarted: 0,
+        liveStreamsStopped: 0,
+        tasksQueued: 0,
+        taskResultsReceived: 0,
+        taskResultsFailed: 0,
+        ...overrides
+    };
+}
+
 function normalizeDeviceId(value) {
     const id = safeString(value, 128).replace(/[^a-zA-Z0-9_.:-]/g, '-');
     return id || crypto.randomUUID();
@@ -122,6 +143,7 @@ function serializeDevice(device) {
         latestLiveFrame: device.latestLiveFrame ? { ...device.latestLiveFrame } : null,
         activeLiveStream: device.activeLiveStream ? { ...device.activeLiveStream } : null,
         latestTask: device.latestTask ? { ...device.latestTask } : null,
+        synthetic: device.synthetic === true,
         recentTasks: Array.isArray(device.recentTasks)
             ? device.recentTasks.map(task => ({ ...task }))
             : [],
@@ -207,6 +229,77 @@ export function createRemoteHub(options = {}) {
         });
     }
 
+    function makeSyntheticFrame(device, streamId, mode = 'thumbnail', options = {}) {
+        const now = new Date().toISOString();
+        const frameSeq = Number(device?.counters?.thumbnailFramesReceived || 0)
+            + Number(device?.counters?.liveFramesReceived || 0)
+            + 1;
+        return {
+            streamId: safeString(streamId, 128) || `${mode}-${Date.now()}`,
+            frameSeq,
+            commandId: safeString(options.commandId, 128),
+            width: clampNumber(options.width, 2, 2560, mode === 'remote-fast' ? 960 : 360),
+            height: clampNumber(options.height, 1, 1440, mode === 'remote-fast' ? 540 : 220),
+            mimeType: 'image/png',
+            format: 'image/png',
+            mode,
+            fps: clampNumber(options.fps, 1, 24, mode === 'remote-fast' ? 12 : 1),
+            capturedAt: now,
+            receivedAt: now,
+            byteLength: 68,
+            dataUrl: SYNTHETIC_FRAME_DATA_URL
+        };
+    }
+
+    function applySyntheticThumbnail(device, command) {
+        if (!device) {
+            return null;
+        }
+
+        const payload = command?.payload || {};
+        const frame = makeSyntheticFrame(device, payload.streamId || 'synthetic-thumb', 'thumbnail', {
+            commandId: command?.commandId,
+            width: payload.maxWidth || 360,
+            height: payload.maxHeight || 220
+        });
+        delete frame.mode;
+        delete frame.fps;
+        device.latestThumbnail = frame;
+        device.lastSeenAt = frame.receivedAt;
+        device.counters.thumbnailFramesReceived += 1;
+        emitRemoteEvent('RemoteFrameReceived', device, {
+            streamId: frame.streamId,
+            frameSeq: frame.frameSeq,
+            synthetic: true
+        });
+        return frame;
+    }
+
+    function applySyntheticLiveFrame(device, streamId, options = {}) {
+        if (!device?.activeLiveStream?.active) {
+            return null;
+        }
+
+        const frame = makeSyntheticFrame(device, streamId || device.activeLiveStream.streamId, 'remote-fast', {
+            commandId: options.commandId || device.activeLiveStream.commandId,
+            width: options.maxWidth || 960,
+            height: options.maxHeight || 540,
+            fps: options.fps || device.activeLiveStream.fps
+        });
+        device.latestLiveFrame = frame;
+        device.activeLiveStream.lastFrameAt = frame.receivedAt;
+        device.activeLiveStream.lastFrameSeq = frame.frameSeq;
+        device.activeLiveStream.framesReceived = (device.activeLiveStream.framesReceived || 0) + 1;
+        device.lastSeenAt = frame.receivedAt;
+        device.counters.liveFramesReceived += 1;
+        emitRemoteEvent('RemoteFrameReceived', device, {
+            streamId: frame.streamId,
+            frameSeq: frame.frameSeq,
+            synthetic: true
+        });
+        return frame;
+    }
+
     function closeExistingDeviceSocket(deviceId, nextSessionId) {
         const existing = devices.get(deviceId);
         if (!existing?.socket || existing.socket.destroyed) {
@@ -222,6 +315,186 @@ export function createRemoteHub(options = {}) {
         existing.socket.destroy();
     }
 
+    function clearSyntheticFleet() {
+        let removed = 0;
+        for (const [deviceId, device] of devices.entries()) {
+            if (device.synthetic === true) {
+                devices.delete(deviceId);
+                removed += 1;
+            }
+        }
+
+        return { ok: true, removed, total: devices.size };
+    }
+
+    function seedSyntheticFleet(options = {}) {
+        const count = clampNumber(options.count, 1, MAX_SYNTHETIC_DEVICES, 250);
+        const connectedRatio = Math.max(0, Math.min(1, Number(options.connectedRatio ?? 0.88)));
+        const thumbnailRatio = Math.max(0, Math.min(1, Number(options.thumbnailRatio ?? 0.7)));
+        const aiAssistRatio = Math.max(0, Math.min(1, Number(options.aiAssistRatio ?? 0.35)));
+        const liveCount = clampNumber(options.liveCount, 0, Math.min(count, 24), Math.min(6, count));
+        const replace = options.replace !== false;
+        const now = new Date();
+        const platforms = ['win32', 'linux', 'darwin'];
+
+        if (replace) {
+            clearSyntheticFleet();
+        }
+
+        let connected = 0;
+        let aiAssist = 0;
+        let live = 0;
+        for (let index = 0; index < count; index += 1) {
+            const ordinal = index + 1;
+            const deviceId = `synthetic-${String(ordinal).padStart(4, '0')}`;
+            const isConnected = index / count < connectedRatio;
+            const hasThumbnail = index / count < thumbnailRatio;
+            const hasAiAssist = index / count < aiAssistRatio;
+            const isLive = isConnected && index < liveCount;
+            const seenAt = new Date(now.getTime() - index * 1350).toISOString();
+            const connectedAt = new Date(now.getTime() - (index + 8) * 60000).toISOString();
+            const platform = platforms[index % platforms.length];
+            const usedMemRatio = Number((0.18 + (index % 71) / 100).toFixed(2));
+            const load1 = Number(((index % 19) / 3).toFixed(2));
+            const taskStatus = index % 17 === 0
+                ? 'failed'
+                : index % 5 === 0
+                    ? 'completed'
+                    : index % 7 === 0
+                        ? 'queued'
+                        : '';
+            const latestTask = taskStatus
+                ? {
+                    taskId: `synthetic-task-${ordinal}`,
+                    commandId: `synthetic-command-${ordinal}`,
+                    title: taskStatus === 'failed' ? 'Synthetic issue check' : 'Synthetic status task',
+                    instructionPreview: 'Synthetic fleet scale validation task.',
+                    status: taskStatus,
+                    approvalLevel: hasAiAssist ? 'ai-assist' : 'task-only',
+                    requestedAt: seenAt,
+                    sentAt: seenAt,
+                    updatedAt: seenAt,
+                    completedAt: taskStatus === 'completed' || taskStatus === 'failed' ? seenAt : '',
+                    error: taskStatus === 'failed' ? 'Synthetic task failure sample.' : '',
+                    resultKind: 'synthetic-agent-task',
+                    resultSummary: taskStatus === 'failed'
+                        ? 'Synthetic task reported a sample issue.'
+                        : 'Synthetic task completed for scale validation.'
+                }
+                : null;
+            const device = {
+                socket: null,
+                synthetic: true,
+                deviceId,
+                sessionId: `synthetic-session-${ordinal}`,
+                deviceName: `Synthetic PC ${String(ordinal).padStart(4, '0')}`,
+                hostname: `synthetic-host-${String(ordinal).padStart(4, '0')}`,
+                platform,
+                arch: index % 4 === 0 ? 'arm64' : 'x64',
+                pid: 0,
+                agentVersion: 'synthetic-scale',
+                capabilities: {
+                    status: true,
+                    thumbnail: hasThumbnail,
+                    control: false,
+                    liveStream: true,
+                    computerAgent: true,
+                    taskDispatch: true,
+                    aiAssist: hasAiAssist,
+                    aiModel: hasAiAssist ? 'synthetic-ai' : '',
+                    aiProvider: hasAiAssist ? 'synthetic' : ''
+                },
+                connected: isConnected,
+                connectedAt: isConnected ? connectedAt : '',
+                disconnectedAt: isConnected ? '' : seenAt,
+                lastSeenAt: seenAt,
+                lastStatusAt: seenAt,
+                lastDisconnectReason: isConnected ? '' : 'synthetic-offline',
+                remoteAddress: 'synthetic.local',
+                remotePort: 0,
+                status: {
+                    platform,
+                    release: platform === 'win32' ? 'Windows 11' : platform === 'darwin' ? 'macOS' : 'Linux',
+                    uptimeSec: (ordinal * 791) % 1209600,
+                    usedMemRatio,
+                    loadavg: [load1, Math.max(0, load1 - 0.2), Math.max(0, load1 - 0.4)]
+                },
+                latestThumbnail: null,
+                latestLiveFrame: null,
+                activeLiveStream: null,
+                latestTask,
+                recentTasks: latestTask ? [latestTask] : [],
+                pendingTaskCommands: new Map(),
+                counters: createDeviceCounters({
+                    messagesReceived: 1,
+                    statusReceived: 1,
+                    tasksQueued: latestTask ? 1 : 0,
+                    taskResultsReceived: latestTask && ['completed', 'failed'].includes(latestTask.status) ? 1 : 0,
+                    taskResultsFailed: latestTask?.status === 'failed' ? 1 : 0
+                })
+            };
+
+            if (hasThumbnail) {
+                const frame = makeSyntheticFrame(device, `synthetic-thumb-${ordinal}`, 'thumbnail', {
+                    width: 360,
+                    height: 220
+                });
+                delete frame.mode;
+                delete frame.fps;
+                frame.receivedAt = seenAt;
+                frame.capturedAt = seenAt;
+                device.latestThumbnail = frame;
+                device.counters.thumbnailFramesReceived = 1;
+            }
+
+            if (isLive) {
+                device.activeLiveStream = {
+                    streamId: `synthetic-live-${ordinal}`,
+                    commandId: `synthetic-live-command-${ordinal}`,
+                    active: true,
+                    mode: 'remote-fast',
+                    fps: 12,
+                    startedAt: seenAt,
+                    stoppedAt: '',
+                    stopReason: '',
+                    lastFrameAt: '',
+                    lastFrameSeq: 0,
+                    framesReceived: 0
+                };
+                applySyntheticLiveFrame(device, device.activeLiveStream.streamId, {
+                    commandId: device.activeLiveStream.commandId,
+                    fps: 12
+                });
+                live += 1;
+            }
+
+            if (isConnected) {
+                connected += 1;
+            }
+            if (hasAiAssist) {
+                aiAssist += 1;
+            }
+            devices.set(deviceId, device);
+        }
+
+        emitRemoteEvent('RemoteSyntheticFleetSeeded', null, {
+            count,
+            connected,
+            aiAssist,
+            live
+        });
+        return {
+            ok: true,
+            synthetic: true,
+            seeded: count,
+            connected,
+            aiAssist,
+            live,
+            total: devices.size,
+            max: MAX_SYNTHETIC_DEVICES
+        };
+    }
+
     function attachDevice(socket, hello) {
         const now = new Date().toISOString();
         const sessionId = crypto.randomUUID();
@@ -257,21 +530,8 @@ export function createRemoteHub(options = {}) {
             latestTask: null,
             recentTasks: [],
             pendingTaskCommands: new Map(),
-            counters: {
-                messagesReceived: 1,
-                statusReceived: 0,
-                commandsSent: 0,
-                commandResultsReceived: 0,
-                thumbnailFramesReceived: 0,
-                thumbnailFramesDropped: 0,
-                liveFramesReceived: 0,
-                liveFramesDropped: 0,
-                liveStreamsStarted: 0,
-                liveStreamsStopped: 0,
-                tasksQueued: 0,
-                taskResultsReceived: 0,
-                taskResultsFailed: 0
-            }
+            synthetic: false,
+            counters: createDeviceCounters({ messagesReceived: 1 })
         };
 
         devices.set(deviceId, device);
@@ -685,6 +945,19 @@ export function createRemoteHub(options = {}) {
 
     function disconnectDevice(deviceId, reason = 'manager-disconnect') {
         const device = devices.get(String(deviceId || ''));
+        if (device?.synthetic === true) {
+            device.connected = false;
+            device.disconnectedAt = new Date().toISOString();
+            device.lastDisconnectReason = reason;
+            if (device.activeLiveStream) {
+                device.activeLiveStream.active = false;
+                device.activeLiveStream.stoppedAt = device.disconnectedAt;
+                device.activeLiveStream.stopReason = reason;
+            }
+            emitRemoteEvent('RemoteDeviceDisconnected', device, { reason, synthetic: true });
+            return true;
+        }
+
         if (!device?.socket || device.socket.destroyed) {
             return false;
         }
@@ -696,6 +969,29 @@ export function createRemoteHub(options = {}) {
 
     function sendCommand(deviceId, command) {
         const device = devices.get(String(deviceId || ''));
+        if (device?.synthetic === true && device.connected) {
+            const commandId = safeString(command?.commandId, 128) || crypto.randomUUID();
+            device.counters.commandsSent += 1;
+            device.lastSeenAt = new Date().toISOString();
+            if (command?.command === 'thumbnail.capture') {
+                applySyntheticThumbnail(device, {
+                    commandId,
+                    payload: command?.payload || {}
+                });
+            }
+            emitRemoteEvent('RemoteCommandQueued', device, {
+                commandId,
+                command: safeString(command?.command || 'ping', 80),
+                synthetic: true
+            });
+            emitRemoteEvent('RemoteCommandResult', device, {
+                commandId,
+                result: { ok: true, synthetic: true },
+                error: ''
+            });
+            return { ok: true, commandId, synthetic: true };
+        }
+
         if (!device?.socket || device.socket.destroyed || !device.connected) {
             return { ok: false, error: 'device-not-connected' };
         }
@@ -720,6 +1016,65 @@ export function createRemoteHub(options = {}) {
 
     function requestAgentTask(deviceId, options = {}) {
         const device = devices.get(String(deviceId || ''));
+        if (device?.synthetic === true && device.connected) {
+            const instruction = safeText(options.instruction, MAX_AGENT_TASK_CHARS);
+            if (!instruction) {
+                return { ok: false, error: 'missing-instruction' };
+            }
+
+            const now = new Date().toISOString();
+            const approvalLevel = normalizeApprovalLevel(options.approvalLevel);
+            if (approvalLevel === 'ai-assist' && !readCapabilityFlag(device.capabilities, 'aiAssist')) {
+                return { ok: false, error: 'device-ai-assist-unavailable' };
+            }
+
+            const commandId = safeString(options.commandId, 128) || crypto.randomUUID();
+            const taskId = safeString(options.taskId, 128) || crypto.randomUUID();
+            const title = safeString(options.title, 120)
+                || safeString(instruction.split(/\r?\n/)[0], 120)
+                || 'Remote task';
+            const task = {
+                taskId,
+                commandId,
+                title,
+                instructionPreview: safeText(instruction, 320),
+                status: 'completed',
+                approvalLevel,
+                requestedAt: now,
+                sentAt: now,
+                updatedAt: now,
+                completedAt: now,
+                error: '',
+                resultKind: approvalLevel === 'ai-assist' ? 'synthetic-ai-assist' : 'synthetic-agent-task',
+                resultSummary: approvalLevel === 'ai-assist'
+                    ? `Synthetic AI assist completed for ${device.deviceName}.`
+                    : `Synthetic task accepted by ${device.deviceName}.`
+            };
+
+            device.counters.commandsSent += 1;
+            device.counters.commandResultsReceived += 1;
+            device.counters.tasksQueued += 1;
+            device.counters.taskResultsReceived += 1;
+            device.lastSeenAt = now;
+            rememberDeviceTask(device, task);
+            device.pendingTaskCommands.delete(commandId);
+            emitRemoteEvent('RemoteTaskQueued', device, {
+                commandId,
+                taskId,
+                title,
+                approvalLevel,
+                synthetic: true
+            });
+            emitRemoteEvent('RemoteTaskResult', device, {
+                commandId,
+                taskId,
+                status: task.status,
+                error: '',
+                synthetic: true
+            });
+            return { ok: true, commandId, taskId, approvalLevel, synthetic: true };
+        }
+
         if (!device?.socket || device.socket.destroyed || !device.connected) {
             return { ok: false, error: 'device-not-connected' };
         }
@@ -803,6 +1158,45 @@ export function createRemoteHub(options = {}) {
 
     function startLiveStream(deviceId, options = {}) {
         const device = devices.get(String(deviceId || ''));
+        if (device?.synthetic === true && device.connected) {
+            if (!readCapabilityFlag(device.capabilities, 'liveStream')) {
+                return { ok: false, error: 'device-live-stream-unavailable' };
+            }
+
+            const now = new Date().toISOString();
+            const streamId = safeString(options.streamId, 128) || `live-${Date.now()}`;
+            const fps = clampNumber(options.fps, 1, 24, 12);
+            const commandId = safeString(options.commandId, 128) || crypto.randomUUID();
+            device.counters.commandsSent += 1;
+            device.activeLiveStream = {
+                streamId,
+                commandId,
+                active: true,
+                mode: 'remote-fast',
+                fps,
+                startedAt: now,
+                stoppedAt: '',
+                stopReason: '',
+                lastFrameAt: '',
+                lastFrameSeq: 0,
+                framesReceived: 0
+            };
+            device.counters.liveStreamsStarted += 1;
+            applySyntheticLiveFrame(device, streamId, {
+                commandId,
+                maxWidth: options.maxWidth,
+                maxHeight: options.maxHeight,
+                fps
+            });
+            emitRemoteEvent('RemoteLiveStreamStarted', device, {
+                streamId,
+                commandId,
+                fps,
+                synthetic: true
+            });
+            return { ok: true, commandId, streamId, fps, synthetic: true };
+        }
+
         if (!device?.socket || device.socket.destroyed || !device.connected) {
             return { ok: false, error: 'device-not-connected' };
         }
@@ -857,6 +1251,24 @@ export function createRemoteHub(options = {}) {
 
     function stopLiveStream(deviceId, options = {}) {
         const device = devices.get(String(deviceId || ''));
+        if (device?.synthetic === true && device.connected) {
+            const streamId = safeString(options.streamId, 128) || device.activeLiveStream?.streamId || '';
+            const commandId = safeString(options.commandId, 128) || crypto.randomUUID();
+            device.counters.commandsSent += 1;
+            if (device.activeLiveStream && (!streamId || device.activeLiveStream.streamId === streamId)) {
+                device.activeLiveStream.active = false;
+                device.activeLiveStream.stoppedAt = new Date().toISOString();
+                device.activeLiveStream.stopReason = 'manager-request';
+            }
+            device.counters.liveStreamsStopped += 1;
+            emitRemoteEvent('RemoteLiveStreamStopped', device, {
+                streamId,
+                commandId,
+                synthetic: true
+            });
+            return { ok: true, commandId, streamId, synthetic: true };
+        }
+
         if (!device?.socket || device.socket.destroyed || !device.connected) {
             return { ok: false, error: 'device-not-connected' };
         }
@@ -913,6 +1325,8 @@ export function createRemoteHub(options = {}) {
         stopLiveStream,
         getDeviceLiveFrame,
         getDeviceThumbnail,
+        seedSyntheticFleet,
+        clearSyntheticFleet,
         getPairToken: () => pairToken
     };
 }

package/scripts/remote-fleet-render-smoke.mjs

@@ -0,0 +1,579 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+import { createRemoteHub } from '../remote-hub.js';
+
+const SYNTHETIC_COUNT = Number(process.env.REMOTE_FLEET_RENDER_SMOKE_COUNT || 250);
+
+function dataAttributeToDatasetKey(name) {
+    return String(name || '').replace(/^data-/, '').replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+}
+
+class MiniStyle {
+    constructor() {
+        this._cssText = '';
+    }
+
+    get cssText() {
+        return this._cssText;
+    }
+
+    set cssText(value) {
+        this._cssText = String(value || '');
+        const displayMatch = /(?:^|;)\s*display\s*:\s*([^;]+)/i.exec(this._cssText);
+        if (displayMatch) {
+            this.display = displayMatch[1].trim();
+        }
+    }
+
+    setProperty(name, value) {
+        this[String(name)] = String(value);
+    }
+}
+
+class MiniClassList {
+    constructor(owner) {
+        this.owner = owner;
+        this.tokens = new Set();
+    }
+
+    add(...tokens) {
+        tokens.forEach(token => {
+            const value = String(token || '').trim();
+            if (value) {
+                this.tokens.add(value);
+            }
+        });
+        this.sync();
+    }
+
+    remove(...tokens) {
+        tokens.forEach(token => this.tokens.delete(String(token || '').trim()));
+        this.sync();
+    }
+
+    contains(token) {
+        return this.tokens.has(String(token || '').trim());
+    }
+
+    toggle(token, force) {
+        const value = String(token || '').trim();
+        if (!value) return false;
+        const shouldAdd = force === undefined ? !this.tokens.has(value) : !!force;
+        if (shouldAdd) {
+            this.tokens.add(value);
+        } else {
+            this.tokens.delete(value);
+        }
+        this.sync();
+        return shouldAdd;
+    }
+
+    sync() {
+        this.owner.className = [...this.tokens].join(' ');
+    }
+}
+
+class MiniElement {
+    constructor(tagName, ownerDocument) {
+        this.tagName = String(tagName || '').toUpperCase();
+        this.nodeName = this.tagName;
+        this.ownerDocument = ownerDocument;
+        this.parentElement = null;
+        this.children = [];
+        this.attributes = {};
+        this.dataset = {};
+        this.style = new MiniStyle();
+        this.classList = new MiniClassList(this);
+        this.className = '';
+        this._textContent = '';
+        this._listeners = new Map();
+        this.value = '';
+        this.checked = false;
+        this.disabled = false;
+    }
+
+    get textContent() {
+        return `${this._textContent}${this.children.map(child => child.textContent).join('')}`;
+    }
+
+    set textContent(value) {
+        this.children.forEach(child => {
+            child.parentElement = null;
+        });
+        this.children = [];
+        this._textContent = String(value ?? '');
+    }
+
+    get innerHTML() {
+        return '';
+    }
+
+    set innerHTML(_value) {
+        this.children.forEach(child => {
+            child.parentElement = null;
+        });
+        this.children = [];
+        this._textContent = '';
+    }
+
+    appendChild(child) {
+        if (!child) return child;
+        if (child.parentElement) {
+            child.parentElement.children = child.parentElement.children.filter(item => item !== child);
+        }
+        child.parentElement = this;
+        this.children.push(child);
+        return child;
+    }
+
+    remove() {
+        if (!this.parentElement) return;
+        this.parentElement.children = this.parentElement.children.filter(child => child !== this);
+        this.parentElement = null;
+    }
+
+    setAttribute(name, value) {
+        const key = String(name || '');
+        const text = String(value ?? '');
+        this.attributes[key] = text;
+        if (key === 'id') {
+            this.id = text;
+        } else if (key === 'class') {
+            this.className = text;
+            this.classList.tokens = new Set(text.split(/\s+/).filter(Boolean));
+        } else if (key.startsWith('data-')) {
+            this.dataset[dataAttributeToDatasetKey(key)] = text;
+        } else if (key === 'aria-label') {
+            this.ariaLabel = text;
+        }
+    }
+
+    getAttribute(name) {
+        const key = String(name || '');
+        if (key.startsWith('data-')) {
+            return this.dataset[dataAttributeToDatasetKey(key)];
+        }
+        return this.attributes[key];
+    }
+
+    addEventListener(type, listener) {
+        const key = String(type || '');
+        if (!this._listeners.has(key)) {
+            this._listeners.set(key, []);
+        }
+        this._listeners.get(key).push(listener);
+    }
+
+    dispatchEvent(event) {
+        const payload = typeof event === 'string' ? { type: event } : { ...(event || {}) };
+        payload.type = payload.type || 'event';
+        payload.target = payload.target || this;
+        payload.currentTarget = this;
+        payload.preventDefault = payload.preventDefault || (() => {});
+        payload.stopPropagation = payload.stopPropagation || (() => {});
+        for (const listener of this._listeners.get(payload.type) || []) {
+            listener(payload);
+        }
+        return true;
+    }
+
+    querySelector(selector) {
+        return this.querySelectorAll(selector)[0] || null;
+    }
+
+    querySelectorAll(selector) {
+        const matches = [];
+        const visit = element => {
+            for (const child of element.children) {
+                if (matchesSelector(child, selector)) {
+                    matches.push(child);
+                }
+                visit(child);
+            }
+        };
+        visit(this);
+        return matches;
+    }
+
+    closest(selector) {
+        let current = this;
+        while (current) {
+            if (matchesSelector(current, selector)) {
+                return current;
+            }
+            current = current.parentElement;
+        }
+        return null;
+    }
+
+    contains(node) {
+        let current = node;
+        while (current) {
+            if (current === this) return true;
+            current = current.parentElement;
+        }
+        return false;
+    }
+}
+
+class MiniDocument {
+    constructor() {
+        this.body = new MiniElement('body', this);
+        this.head = new MiniElement('head', this);
+    }
+
+    createElement(tagName) {
+        return new MiniElement(tagName, this);
+    }
+
+    getElementById(id) {
+        const target = String(id || '');
+        return [this.head, this.body]
+            .flatMap(root => root.querySelectorAll('*'))
+            .find(element => element.id === target) || null;
+    }
+
+    querySelector(selector) {
+        return this.body.querySelector(selector) || this.head.querySelector(selector);
+    }
+
+    querySelectorAll(selector) {
+        return [
+            ...this.head.querySelectorAll(selector),
+            ...this.body.querySelectorAll(selector)
+        ];
+    }
+}
+
+function matchesSelector(element, selector) {
+    const text = String(selector || '').trim();
+    if (!text || !element) return false;
+    if (text === '*') return true;
+
+    const tagMatch = /^[a-zA-Z][\w-]*/.exec(text);
+    if (tagMatch && element.tagName.toLowerCase() !== tagMatch[0].toLowerCase()) {
+        return false;
+    }
+
+    for (const classMatch of text.matchAll(/\.([\w-]+)/g)) {
+        if (!element.classList.contains(classMatch[1])) {
+            return false;
+        }
+    }
+
+    for (const attrMatch of text.matchAll(/\[([^\]=]+)(?:="([^"]*)")?\]/g)) {
+        const attrName = attrMatch[1];
+        const expected = attrMatch[2];
+        const actual = attrName.startsWith('data-')
+            ? element.dataset[dataAttributeToDatasetKey(attrName)]
+            : element.getAttribute(attrName);
+        if (actual === undefined || actual === null) {
+            return false;
+        }
+        if (expected !== undefined && String(actual) !== expected) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+function readStatusNumber(status, key) {
+    const value = status?.[key];
+    return Number.isFinite(Number(value)) ? Number(value) : null;
+}
+
+function readLoad1(status) {
+    const value = status?.loadavg;
+    return Array.isArray(value) && Number.isFinite(Number(value[0])) ? Number(value[0]) : null;
+}
+
+function projectDevice(device) {
+    const status = device.status || {};
+    const capabilities = device.capabilities || {};
+    const thumbnail = device.latestThumbnail || {};
+    const liveFrame = device.latestLiveFrame || {};
+    const liveStream = device.activeLiveStream || {};
+    const latestTask = device.latestTask || {};
+    const platform = String(status.platform || device.platform || 'unknown');
+
+    return {
+        DeviceId: String(device.deviceId || ''),
+        SessionId: String(device.sessionId || ''),
+        Name: String(device.deviceName || device.hostname || device.deviceId || 'device'),
+        Hostname: String(device.hostname || ''),
+        Platform: platform,
+        Release: String(status.release || ''),
+        Arch: String(device.arch || ''),
+        AgentVersion: String(device.agentVersion || ''),
+        Connected: device.connected === true,
+        ConnectedAt: String(device.connectedAt || ''),
+        DisconnectedAt: String(device.disconnectedAt || ''),
+        LastSeenAt: String(device.lastSeenAt || ''),
+        LastStatusAt: String(device.lastStatusAt || ''),
+        LastDisconnectReason: String(device.lastDisconnectReason || ''),
+        RemoteAddress: String(device.remoteAddress || ''),
+        RemotePort: Number(device.remotePort || 0),
+        UptimeSec: readStatusNumber(status, 'uptimeSec'),
+        UsedMemRatio: readStatusNumber(status, 'usedMemRatio'),
+        Load1: readLoad1(status),
+        StatusEnabled: capabilities.status === true,
+        ThumbnailEnabled: capabilities.thumbnail === true,
+        LiveStreamEnabled: capabilities.liveStream === true,
+        ControlEnabled: capabilities.control === true,
+        ComputerAgentEnabled: capabilities.computerAgent === true || capabilities.taskDispatch === true,
+        AiAssistEnabled: capabilities.aiAssist === true,
+        AiModel: String(capabilities.aiModel || ''),
+        AiProvider: String(capabilities.aiProvider || ''),
+        ThumbnailStreamId: String(thumbnail.streamId || ''),
+        ThumbnailFrameSeq: Number(thumbnail.frameSeq || 0),
+        ThumbnailWidth: Number(thumbnail.width || 0),
+        ThumbnailHeight: Number(thumbnail.height || 0),
+        ThumbnailMimeType: String(thumbnail.mimeType || thumbnail.format || ''),
+        ThumbnailCapturedAt: String(thumbnail.capturedAt || ''),
+        ThumbnailReceivedAt: String(thumbnail.receivedAt || ''),
+        ThumbnailDataUrl: String(thumbnail.dataUrl || ''),
+        LiveStreamActive: liveStream.active === true,
+        LiveStreamId: String(liveStream.streamId || ''),
+        LiveStreamMode: String(liveStream.mode || ''),
+        LiveStreamFps: Number(liveStream.fps || 0),
+        LiveStreamStartedAt: String(liveStream.startedAt || ''),
+        LiveStreamStoppedAt: String(liveStream.stoppedAt || ''),
+        LiveStreamLastFrameAt: String(liveStream.lastFrameAt || ''),
+        LiveStreamFrameSeq: Number(liveStream.lastFrameSeq || 0),
+        LiveFrameStreamId: String(liveFrame.streamId || ''),
+        LiveFrameSeq: Number(liveFrame.frameSeq || 0),
+        LiveFrameWidth: Number(liveFrame.width || 0),
+        LiveFrameHeight: Number(liveFrame.height || 0),
+        LiveFrameMimeType: String(liveFrame.mimeType || liveFrame.format || ''),
+        LiveFrameCapturedAt: String(liveFrame.capturedAt || ''),
+        LiveFrameReceivedAt: String(liveFrame.receivedAt || ''),
+        LiveFrameDataUrl: String(liveFrame.dataUrl || ''),
+        LatestTaskId: String(latestTask.taskId || ''),
+        LatestTaskCommandId: String(latestTask.commandId || ''),
+        LatestTaskTitle: String(latestTask.title || ''),
+        LatestTaskInstructionPreview: String(latestTask.instructionPreview || ''),
+        LatestTaskStatus: String(latestTask.status || ''),
+        LatestTaskApprovalLevel: String(latestTask.approvalLevel || ''),
+        LatestTaskUpdatedAt: String(latestTask.updatedAt || latestTask.completedAt || latestTask.sentAt || ''),
+        LatestTaskError: String(latestTask.error || ''),
+        LatestTaskResultSummary: String(latestTask.resultSummary || '')
+    };
+}
+
+async function loadCss3DManager() {
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const managerPath = path.resolve(__dirname, '../../MindExecution.Shared/wwwroot/js/mind-map-css3d-manager.js');
+    const source = await fs.readFile(managerPath, 'utf8');
+    const document = new MiniDocument();
+    const context = {
+        console,
+        document,
+        navigator: {
+            clipboard: {
+                writeText: async () => {}
+            }
+        },
+        setInterval: () => 0,
+        clearInterval: () => {},
+        setTimeout,
+        clearTimeout,
+        Date,
+        Math,
+        Number,
+        String,
+        Boolean,
+        Array,
+        Object,
+        JSON,
+        RegExp,
+        Map,
+        Set,
+        WeakMap,
+        THREE: createThreeStub(),
+        URL,
+        Promise
+    };
+    context.window = context;
+    context.self = context;
+
+    vm.runInNewContext(source, context, { filename: managerPath });
+    return { manager: context.window.MindMapCss3DManager, document };
+}
+
+function buildMonitorNode(devices, hubStatus) {
+    const connected = devices.filter(device => device.Connected).length;
+    const endpoint = hubStatus.agentEndpoint || '127.0.0.1:5197';
+    const pairToken = hubStatus.pairToken || 'render-smoke-token';
+    return {
+        id: 'remote-fleet-render-smoke',
+        contentType: 'memo',
+        metadata: {
+            SemanticType: 'RemoteFleetMonitor',
+            RemoteFleetSchemaVersion: 'remote-fleet@1',
+            RemoteFleetViewMode: 'all-devices',
+            RemoteFleetLastRefreshAtUtc: new Date().toISOString(),
+            RemoteFleetHubStatus: 'online',
+            RemoteFleetHubEndpoint: endpoint,
+            RemoteFleetAgentPackage: '@mindexec/remote',
+            RemoteFleetPairTokenPreview: '<pair-token>',
+            RemoteFleetConnectCommand: `npx @mindexec/remote connect --manager ${endpoint} --pair ${pairToken}`,
+            RemoteFleetDeviceCount: String(devices.length),
+            RemoteFleetConnectedDeviceCount: String(connected),
+            RemoteFleetCanvasPagination: 'none',
+            RemoteFleetDevicesJson: JSON.stringify(devices),
+            RemoteFleetLastError: ''
+        }
+    };
+}
+
+function buildDeviceNode(device, hubStatus) {
+    const endpoint = hubStatus.agentEndpoint || '127.0.0.1:5197';
+    return {
+        id: 'remote-device-render-smoke',
+        contentType: 'memo',
+        metadata: {
+            SemanticType: 'RemoteFleetDevice',
+            RemoteFleetSchemaVersion: 'remote-device@1',
+            RemoteFleetViewMode: 'pinned-device',
+            RemoteFleetLastRefreshAtUtc: new Date().toISOString(),
+            RemoteFleetHubStatus: 'online',
+            RemoteFleetHubEndpoint: endpoint,
+            RemoteFleetAgentPackage: '@mindexec/remote',
+            RemoteFleetPinnedDeviceId: device.DeviceId,
+            RemoteFleetPinnedDeviceJson: JSON.stringify(device),
+            RemoteFleetLastError: ''
+        }
+    };
+}
+
+function createThreeStub() {
+    class Vector3 {
+        constructor(x = 0, y = 0, z = 0) {
+            this.x = x;
+            this.y = y;
+            this.z = z;
+        }
+
+        set(x = 0, y = 0, z = 0) {
+            this.x = x;
+            this.y = y;
+            this.z = z;
+            return this;
+        }
+    }
+
+    class Matrix4 {
+        multiplyMatrices() { return this; }
+    }
+
+    class Frustum {
+        setFromProjectionMatrix() { return this; }
+        intersectsBox() { return true; }
+    }
+
+    class Quaternion {}
+
+    class Box3 {
+        setFromCenterAndSize() { return this; }
+    }
+
+    return { Box3, Frustum, Matrix4, Quaternion, Vector3 };
+}
+
+const hub = createRemoteHub({
+    env: {
+        MINDEXEC_REMOTE_HUB: '1',
+        REMOTE_HUB_HOST: '127.0.0.1',
+        REMOTE_HUB_PORT: '0',
+        REMOTE_HUB_PAIR_TOKEN: 'render-smoke-token'
+    }
+});
+
+try {
+    await hub.start();
+    const seeded = hub.seedSyntheticFleet({
+        count: SYNTHETIC_COUNT,
+        connectedRatio: 0.84,
+        thumbnailRatio: 0.72,
+        aiAssistRatio: 0.42,
+        liveCount: 0
+    });
+    assert.equal(seeded.ok, true);
+    assert.equal(seeded.seeded, SYNTHETIC_COUNT);
+
+    const rawDevices = hub.listDevices();
+    const devices = rawDevices.map(projectDevice);
+    const connectedCount = devices.filter(device => device.Connected).length;
+    const offlineCount = devices.length - connectedCount;
+    const aiCount = devices.filter(device => device.Connected && device.AiAssistEnabled).length;
+    const focusedDevice = devices.find(device => device.Connected);
+    assert.ok(focusedDevice);
+
+    const { manager, document } = await loadCss3DManager();
+    assert.equal(typeof manager?.renderRemoteFleetMonitorForTest, 'function');
+    assert.equal(typeof manager?.renderRemoteFleetDeviceForTest, 'function');
+
+    const bodyView = document.createElement('div');
+    bodyView.dataset.remoteFleetAutoMonitor = 'false';
+    bodyView.dataset.remoteFleetFocusDeviceId = focusedDevice.DeviceId;
+    document.body.appendChild(bodyView);
+
+    manager.renderRemoteFleetMonitorForTest(bodyView, buildMonitorNode(devices, hub.getStatus({ includeSecrets: true })));
+
+    let cards = bodyView.querySelectorAll('article[data-device-id]');
+    assert.equal(cards.length, SYNTHETIC_COUNT);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-match-count="true"]')?.textContent, `${SYNTHETIC_COUNT}/${SYNTHETIC_COUNT}`);
+    assert.equal(bodyView.querySelectorAll('[data-remote-fleet-action="pin-device"]').length, SYNTHETIC_COUNT);
+    assert.equal(bodyView.querySelectorAll('[data-remote-fleet-action="task-device"]').length, connectedCount);
+    assert.equal(bodyView.querySelectorAll('[data-remote-fleet-action="thumbnail-device"]').length, devices.filter(device => device.Connected && device.ThumbnailEnabled).length);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-live-panel="true"]')?.dataset.deviceId, focusedDevice.DeviceId);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-action="task-visible"]')?.disabled, false);
+    assert.ok(bodyView.textContent.includes('all devices, no paging'));
+    assert.ok(bodyView.querySelector('code')?.textContent.includes('npx @mindexec/remote connect'));
+
+    const searchInput = bodyView.querySelector('[data-remote-fleet-search="true"]');
+    searchInput.value = 'synthetic pc 0001';
+    searchInput.dispatchEvent({ type: 'input' });
+    cards = bodyView.querySelectorAll('article[data-device-id]');
+    assert.equal(cards.filter(card => card.style.display !== 'none').length, 1);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-match-count="true"]')?.textContent, `1/${SYNTHETIC_COUNT}`);
+
+    const selects = bodyView.querySelectorAll('select');
+    assert.equal(selects.length, 4);
+    const [filterSelect, , groupSelect] = selects;
+    searchInput.value = '';
+    searchInput.dispatchEvent({ type: 'input' });
+    filterSelect.value = 'offline';
+    filterSelect.dispatchEvent({ type: 'change' });
+    assert.equal(bodyView.querySelector('[data-remote-fleet-match-count="true"]')?.textContent, `${offlineCount}/${SYNTHETIC_COUNT}`);
+
+    filterSelect.value = 'ai';
+    filterSelect.dispatchEvent({ type: 'change' });
+    assert.equal(bodyView.querySelector('[data-remote-fleet-match-count="true"]')?.textContent, `${aiCount}/${SYNTHETIC_COUNT}`);
+
+    filterSelect.value = 'all';
+    filterSelect.dispatchEvent({ type: 'change' });
+    groupSelect.value = 'status';
+    groupSelect.dispatchEvent({ type: 'change' });
+    assert.equal(bodyView.dataset.remoteFleetGroup, 'status');
+    assert.ok(bodyView.querySelectorAll('[data-remote-fleet-group-header="true"]').length >= 2);
+    assert.equal(bodyView.querySelectorAll('article[data-device-id]').length, SYNTHETIC_COUNT);
+
+    const deviceBody = document.createElement('div');
+    document.body.appendChild(deviceBody);
+    manager.renderRemoteFleetDeviceForTest(deviceBody, buildDeviceNode(focusedDevice, hub.getStatus()));
+    assert.ok(deviceBody.textContent.includes(focusedDevice.Name));
+    assert.ok(deviceBody.querySelector('[data-remote-fleet-action="refresh-device"]'));
+    assert.ok(deviceBody.querySelector('[data-remote-fleet-action="task-device"]'));
+    assert.ok(deviceBody.textContent.includes(focusedDevice.DeviceId));
+
+    console.log(`RemoteFleet render smoke OK (${SYNTHETIC_COUNT} synthetic devices, ${connectedCount} connected, ${aiCount} AI-ready)`);
+} finally {
+    await hub.close();
+}

package/scripts/remote-hub-scale-smoke.mjs

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+
+import assert from 'assert/strict';
+import { createRemoteHub } from '../remote-hub.js';
+
+const SYNTHETIC_COUNT = Number(process.env.REMOTE_HUB_SCALE_SMOKE_COUNT || 250);
+
+const hub = createRemoteHub({
+    env: {
+        MINDEXEC_REMOTE_HUB: '1',
+        REMOTE_HUB_HOST: '127.0.0.1',
+        REMOTE_HUB_PORT: '0',
+        REMOTE_HUB_PAIR_TOKEN: 'scale-smoke-token'
+    }
+});
+
+try {
+    await hub.start();
+
+    const seeded = hub.seedSyntheticFleet({
+        count: SYNTHETIC_COUNT,
+        connectedRatio: 0.84,
+        thumbnailRatio: 0.72,
+        aiAssistRatio: 0.42,
+        liveCount: 8
+    });
+    assert.equal(seeded.ok, true);
+    assert.equal(seeded.seeded, SYNTHETIC_COUNT);
+
+    const status = hub.getStatus();
+    assert.equal(status.started, true);
+    assert.equal(status.canvasPagination, 'none');
+    assert.equal(status.deviceCount, SYNTHETIC_COUNT);
+    assert.equal(status.connectedDeviceCount, seeded.connected);
+
+    const devices = hub.listDevices();
+    assert.equal(devices.length, SYNTHETIC_COUNT);
+    assert.equal(devices.filter(device => device.synthetic === true).length, SYNTHETIC_COUNT);
+    assert.equal(devices.some(device => device.connected === false), true);
+    assert.equal(devices.some(device => device.latestThumbnail?.dataUrl), true);
+    assert.equal(devices.some(device => device.activeLiveStream?.active === true), true);
+
+    const deviceListPayload = {
+        total: devices.length,
+        pagination: 'none',
+        canvasDeviceListMode: 'all-devices',
+        devices
+    };
+    assert.ok(JSON.stringify(deviceListPayload).length < 8 * 1024 * 1024);
+
+    const thumbnailTarget = devices.find(device => device.connected && device.capabilities?.thumbnail);
+    assert.ok(thumbnailTarget);
+    const thumbnailResult = hub.requestThumbnail(thumbnailTarget.deviceId, {
+        streamId: 'scale-thumb',
+        maxWidth: 360,
+        maxHeight: 220,
+        quality: 50
+    });
+    assert.equal(thumbnailResult.ok, true);
+    assert.equal(hub.getDeviceThumbnail(thumbnailTarget.deviceId).streamId, 'scale-thumb');
+
+    const liveTarget = devices.find(device => device.connected && device.capabilities?.liveStream);
+    assert.ok(liveTarget);
+    const liveResult = hub.startLiveStream(liveTarget.deviceId, {
+        streamId: 'scale-live',
+        fps: 12,
+        maxWidth: 960,
+        maxHeight: 540,
+        quality: 60
+    });
+    assert.equal(liveResult.ok, true);
+    assert.equal(hub.getDeviceLiveFrame(liveTarget.deviceId).streamId, 'scale-live');
+    const stopResult = hub.stopLiveStream(liveTarget.deviceId, { streamId: 'scale-live' });
+    assert.equal(stopResult.ok, true);
+
+    const connectedTargets = hub.listDevices()
+        .filter(device => device.connected && device.capabilities?.taskDispatch)
+        .slice(0, 200);
+    assert.ok(connectedTargets.length >= 100);
+    const taskResults = connectedTargets.map(device =>
+        hub.requestAgentTask(device.deviceId, {
+            instruction: 'Synthetic scale task: report current status to the manager.',
+            title: 'Scale task'
+        }));
+    assert.equal(taskResults.every(result => result.ok === true), true);
+    assert.equal(taskResults.length, connectedTargets.length);
+
+    const aiTarget = hub.listDevices().find(device =>
+        device.connected && device.capabilities?.taskDispatch && device.capabilities?.aiAssist);
+    assert.ok(aiTarget);
+    const aiResult = hub.requestAgentTask(aiTarget.deviceId, {
+        instruction: 'Synthetic AI assist: summarize fleet condition.',
+        title: 'Scale AI task',
+        approvalLevel: 'ai-assist'
+    });
+    assert.equal(aiResult.ok, true);
+    assert.equal(aiResult.approvalLevel, 'ai-assist');
+    assert.equal(hub.listDevices().find(device => device.deviceId === aiTarget.deviceId)
+        ?.latestTask?.approvalLevel, 'ai-assist');
+
+    const cleared = hub.clearSyntheticFleet();
+    assert.equal(cleared.ok, true);
+    assert.equal(cleared.removed, SYNTHETIC_COUNT);
+    assert.equal(hub.listDevices().length, 0);
+
+    console.log(`RemoteHub scale smoke OK (${SYNTHETIC_COUNT} synthetic devices)`);
+} finally {
+    await hub.close();
+}

package/server.js

@@ -6973,6 +6973,38 @@ app.get('/api/remote/devices', (req, res) => {
     });
 });
 
+function isSyntheticRemoteFleetEnabled() {
+    return /^(1|true|yes|on)$/i.test(String(
+        process.env.MINDEXEC_REMOTE_SYNTHETIC_FLEET
+        || process.env.REMOTE_HUB_SYNTHETIC_FLEET
+        || ''));
+}
+
+app.post('/api/remote/synthetic/seed', (req, res) => {
+    if (!isSyntheticRemoteFleetEnabled()) {
+        res.status(403).json({ ok: false, error: 'synthetic-fleet-disabled' });
+        return;
+    }
+
+    res.json(remoteHub.seedSyntheticFleet({
+        count: req.body?.count,
+        connectedRatio: req.body?.connectedRatio,
+        thumbnailRatio: req.body?.thumbnailRatio,
+        aiAssistRatio: req.body?.aiAssistRatio,
+        liveCount: req.body?.liveCount,
+        replace: req.body?.replace
+    }));
+});
+
+app.delete('/api/remote/synthetic', (req, res) => {
+    if (!isSyntheticRemoteFleetEnabled()) {
+        res.status(403).json({ ok: false, error: 'synthetic-fleet-disabled' });
+        return;
+    }
+
+    res.json(remoteHub.clearSyntheticFleet());
+});
+
 app.post('/api/remote/devices/:deviceId/disconnect', (req, res) => {
     const disconnected = remoteHub.disconnectDevice(req.params.deviceId, 'manager-request');
     res.json({ ok: disconnected });

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

@@ -18079,6 +18079,8 @@
         syncVideoNodeVisibilityPlayback: syncVideoNodeVisibilityPlayback,
         syncEditingOverlay: syncEditingOverlay,
         syncTextOverlays: syncTextOverlays,
+        renderRemoteFleetMonitorForTest: renderRemoteFleetMonitor,
+        renderRemoteFleetDeviceForTest: renderRemoteFleetDevice,
         renderBusinessAutomationEdges: renderBusinessAutomationEdges,
         scheduleBusinessAutomationEdgeRender: scheduleBusinessAutomationEdgeRender,
         hideBusinessAutomationFloatingTooltipForNode: hideBusinessAutomationFloatingTooltipForNode,

package/wwwroot/index.html

@@ -558,7 +558,7 @@
             }
 
             const base = '_content/MindExecution.Shared/js/';
-            const scriptVersion = '20260612-remote-device-pin-v470';
+            const scriptVersion = '20260612-remote-fleet-render-smoke-v471';
             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":  "x1hfM46o",
+    "version":  "SWs2Qkml",
     "assets":  [
                    {
                        "hash":  "sha256-+CSYMcqLNTsq3VnH11jgYyOCCdxvHzL74CBmo4sCmMU=",
@@ -86,7 +86,7 @@
                        "url":  "_content/MindExecution.Shared/js/mind-map-core.js.backup"
                    },
                    {
-                       "hash":  "sha256-LSO5/TRH4+1bNtJc7X09UZHrFfaIF1SkX012PLDVndg=",
+                       "hash":  "sha256-L+uOxULau2wsk0zuWPFd4Ifi5xJUKJ8RAu1JP3JfsL4=",
                        "url":  "_content/MindExecution.Shared/js/mind-map-css3d-manager.js"
                    },
                    {
@@ -834,7 +834,7 @@
                        "url":  "image-manifest.json"
                    },
                    {
-                       "hash":  "sha256-JxMVTLs/BdFFsgJ34YMkq3lh37rBZLnvhbj3f+MxRYo=",
+                       "hash":  "sha256-KfejnUckOnF3WGDdio4k0wnUNz1fpsWmWkKBCXX9mXE=",
                        "url":  "index.html"
                    },
                    {

package/wwwroot/service-worker.js

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