@mindexec/cli 0.2.10 → 0.2.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.10",
+  "version": "0.2.11",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",
@@ -20,8 +20,9 @@
   "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",
     "test:remote": "node scripts/remote-hub-smoke.mjs",
+    "test:remote:scale": "node scripts/remote-hub-scale-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-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 });