@mindexec/cli 0.2.2 → 0.2.4

package/scripts/remote-hub-smoke.mjs

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+
+import net from 'net';
+import assert from 'assert/strict';
+import { createRemoteHub } from '../remote-hub.js';
+
+function writeJsonLine(socket, payload) {
+    socket.write(`${JSON.stringify(payload)}\n`);
+}
+
+function wait(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function waitFor(predicate, timeoutMs = 3000) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        const value = predicate();
+        if (value) {
+            return value;
+        }
+        await wait(25);
+    }
+
+    throw new Error('Timed out waiting for RemoteHub smoke condition.');
+}
+
+const hub = createRemoteHub({
+    env: {
+        MINDEXEC_REMOTE_HUB: '1',
+        REMOTE_HUB_HOST: '127.0.0.1',
+        REMOTE_HUB_PORT: '0',
+        REMOTE_HUB_PAIR_TOKEN: 'smoke-token'
+    }
+});
+
+try {
+    await hub.start();
+    const status = hub.getStatus({ includeSecrets: true });
+    assert.equal(status.started, true);
+    assert.equal(status.canvasPagination, 'none');
+
+    const socket = net.createConnection({ host: '127.0.0.1', port: status.port });
+    socket.setEncoding('utf8');
+    await new Promise((resolve, reject) => {
+        socket.once('connect', resolve);
+        socket.once('error', reject);
+    });
+
+    writeJsonLine(socket, {
+        type: 'hello',
+        pairToken: 'smoke-token',
+        deviceId: 'smoke-device',
+        deviceName: 'Smoke Device',
+        hostname: 'smoke-host',
+        platform: process.platform,
+        arch: process.arch,
+        pid: process.pid,
+        agentVersion: '0.0.0-smoke',
+        capabilities: {
+            status: true,
+            thumbnail: false,
+            control: false,
+            computerAgent: true,
+            taskDispatch: true
+        }
+    });
+    writeJsonLine(socket, {
+        type: 'status',
+        status: {
+            uptimeSec: 1,
+            totalMem: 2,
+            freeMem: 1
+        }
+    });
+
+    const devices = await waitFor(() => {
+        const current = hub.listDevices();
+        return current.length === 1 && current[0].status?.uptimeSec === 1 ? current : null;
+    });
+
+    assert.equal(devices[0].deviceId, 'smoke-device');
+    assert.equal(devices[0].connected, true);
+    assert.equal(hub.getStatus().deviceCount, 1);
+
+    const thumbnailCommand = hub.requestThumbnail('smoke-device', {
+        streamId: 'smoke-thumb',
+        maxWidth: 320,
+        maxHeight: 180,
+        quality: 50
+    });
+    assert.equal(thumbnailCommand.ok, true);
+
+    writeJsonLine(socket, {
+        type: 'thumbnail.frame',
+        commandId: thumbnailCommand.commandId,
+        streamId: 'smoke-thumb',
+        frameSeq: 1,
+        width: 2,
+        height: 1,
+        mimeType: 'image/png',
+        capturedAt: new Date().toISOString(),
+        data: 'iVBORw0KGgoAAAANSUhEUgAAAAIAAAABCAYAAAD0In+KAAAADElEQVR42mP8z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC'
+    });
+
+    const thumbnailDevice = await waitFor(() => {
+        const current = hub.listDevices();
+        return current[0]?.latestThumbnail?.frameSeq === 1 ? current[0] : null;
+    });
+    assert.equal(thumbnailDevice.latestThumbnail.streamId, 'smoke-thumb');
+    assert.equal(thumbnailDevice.counters.thumbnailFramesReceived, 1);
+
+    const taskCommand = hub.requestAgentTask('smoke-device', {
+        instruction: 'Summarize current desktop status for the manager.',
+        title: 'Smoke task'
+    });
+    assert.equal(taskCommand.ok, true);
+    writeJsonLine(socket, {
+        type: 'command.result',
+        commandId: taskCommand.commandId,
+        result: {
+            kind: 'agent.task',
+            taskId: taskCommand.taskId,
+            status: 'completed',
+            summary: 'Smoke task accepted.',
+            completedAt: new Date().toISOString()
+        }
+    });
+
+    const taskDevice = await waitFor(() => {
+        const current = hub.listDevices();
+        return current[0]?.latestTask?.taskId === taskCommand.taskId
+            && current[0]?.latestTask?.status === 'completed'
+            ? current[0]
+            : null;
+    });
+    assert.equal(taskDevice.latestTask.resultSummary, 'Smoke task accepted.');
+    assert.equal(taskDevice.counters.tasksQueued, 1);
+    assert.equal(taskDevice.counters.taskResultsReceived, 1);
+
+    socket.destroy();
+    await waitFor(() => hub.listDevices()[0]?.connected === false);
+    console.log('RemoteHub smoke OK');
+} finally {
+    await hub.close();
+}

package/server.js

@@ -22,6 +22,7 @@ import chokidar from 'chokidar';
 import Parser from 'web-tree-sitter';
 import { fileURLToPath } from 'url';
 import { createCodexRuntime } from './codex-runtime.js';
+import { createRemoteHub } from './remote-hub.js';
 import portGuard from './port-guard.cjs';
 
 const execAsync = promisify(exec);
@@ -1746,11 +1747,13 @@ const PROTECTED_BRIDGE_ROUTES = [
     { method: 'GET', prefix: '/api/codex/' },
     { method: 'POST', prefix: '/api/codex/' },
     { method: 'GET', prefix: '/api/shell/' },
-    { method: 'POST', prefix: '/api/shell/' },
-    { method: 'POST', prefix: '/project/' },
-    { method: 'POST', exact: '/agent/connect' },
-    { method: 'POST', exact: '/api/tool/trace' }
-];
+    { method: 'POST', prefix: '/api/shell/' },
+    { method: 'GET', prefix: '/api/remote/' },
+    { method: 'POST', prefix: '/api/remote/' },
+    { method: 'POST', prefix: '/project/' },
+    { method: 'POST', exact: '/agent/connect' },
+    { method: 'POST', exact: '/api/tool/trace' }
+];
 
 function getBridgeTokenFromRequest(req) {
     const headerToken = String(req.get(bridgeTokenHeader) || '').trim();
@@ -2438,11 +2441,11 @@ function pushChangeFeedItem(item) {
     }
 }
 
-function emitBridgeEvent(type, payload) {
-    if (wsClients.size === 0) return;
-    const message = JSON.stringify({
-        type,
-        timestamp: new Date().toISOString(),
+function emitBridgeEvent(type, payload) {
+    if (wsClients.size === 0) return;
+    const message = JSON.stringify({
+        type,
+        timestamp: new Date().toISOString(),
         payload
     });
     for (const client of wsClients) {
@@ -2452,11 +2455,18 @@ function emitBridgeEvent(type, payload) {
             } catch {
                 // Ignore one-off client send errors
             }
-        }
-    }
-}
-
-function trimShellOutput(value, maxLength) {
+        }
+    }
+}
+
+const remoteHub = createRemoteHub({
+    logEvent,
+    logWarn,
+    logError,
+    emitEvent: emitBridgeEvent
+});
+
+function trimShellOutput(value, maxLength) {
     const text = String(value || '');
     if (text.length <= maxLength) {
         return text;
@@ -6906,10 +6916,11 @@ app.get('/api/status', async (req, res) => {
         workspace: workspacePath,
         wsToken,
         wsPath: '/events',
-        bridgeToken,
-        bridgeTokenHeader,
-        bridgeAuthRequired,
-        shellJobsPath: '/api/shell/jobs',
+        bridgeToken,
+        bridgeTokenHeader,
+        bridgeAuthRequired,
+        remoteHub: remoteHub.getStatus({ includeSecrets: false }),
+        shellJobsPath: '/api/shell/jobs',
         companyCore: {
             baseUrl: companyCoreBaseUrl,
             proxyPath: '/api/company-core',
@@ -6946,6 +6957,92 @@ app.get('/api/status', async (req, res) => {
     });
 });
 
+app.get('/api/remote/status', (req, res) => {
+    res.setHeader('Cache-Control', 'no-store');
+    res.json(remoteHub.getStatus({ includeSecrets: true }));
+});
+
+app.get('/api/remote/devices', (req, res) => {
+    res.setHeader('Cache-Control', 'no-store');
+    const devices = remoteHub.listDevices();
+    res.json({
+        total: devices.length,
+        pagination: 'none',
+        canvasDeviceListMode: 'all-devices',
+        devices
+    });
+});
+
+app.post('/api/remote/devices/:deviceId/disconnect', (req, res) => {
+    const disconnected = remoteHub.disconnectDevice(req.params.deviceId, 'manager-request');
+    res.json({ ok: disconnected });
+});
+
+app.post('/api/remote/devices/:deviceId/ping', (req, res) => {
+    res.json(remoteHub.sendCommand(req.params.deviceId, {
+        command: 'ping',
+        payload: {
+            requestedAt: new Date().toISOString()
+        }
+    }));
+});
+
+app.post('/api/remote/devices/:deviceId/tasks', (req, res) => {
+    res.json(remoteHub.requestAgentTask(req.params.deviceId, {
+        instruction: req.body?.instruction,
+        title: req.body?.title,
+        taskId: req.body?.taskId,
+        commandId: req.body?.commandId
+    }));
+});
+
+app.post('/api/remote/tasks', (req, res) => {
+    const requestedDeviceIds = Array.isArray(req.body?.deviceIds)
+        ? req.body.deviceIds.map(value => String(value || '').trim()).filter(Boolean)
+        : [];
+    const allConnected = req.body?.allConnected !== false;
+    const devices = remoteHub.listDevices();
+    const targetIds = requestedDeviceIds.length > 0
+        ? requestedDeviceIds
+        : (allConnected ? devices.filter(device => device.connected).map(device => device.deviceId) : []);
+    const uniqueTargetIds = [...new Set(targetIds)].slice(0, 500);
+    const results = uniqueTargetIds.map(deviceId => ({
+        deviceId,
+        ...remoteHub.requestAgentTask(deviceId, {
+            instruction: req.body?.instruction,
+            title: req.body?.title
+        })
+    }));
+    const queued = results.filter(result => result.ok === true).length;
+    res.json({
+        ok: queued > 0,
+        total: uniqueTargetIds.length,
+        queued,
+        results,
+        error: queued > 0 ? undefined : (uniqueTargetIds.length === 0 ? 'no-target-devices' : 'no-task-queued')
+    });
+});
+
+app.get('/api/remote/devices/:deviceId/thumbnail', (req, res) => {
+    res.setHeader('Cache-Control', 'no-store');
+    const thumbnail = remoteHub.getDeviceThumbnail(req.params.deviceId);
+    if (!thumbnail) {
+        res.status(404).json({ ok: false, error: 'thumbnail-not-available' });
+        return;
+    }
+
+    res.json({ ok: true, thumbnail });
+});
+
+app.post('/api/remote/devices/:deviceId/thumbnail/request', (req, res) => {
+    res.json(remoteHub.requestThumbnail(req.params.deviceId, {
+        maxWidth: req.body?.maxWidth,
+        maxHeight: req.body?.maxHeight,
+        quality: req.body?.quality,
+        streamId: req.body?.streamId
+    }));
+});
+
 app.get('/api/codex/capabilities', async (req, res) => {
     try {
         res.json(await getCodexRuntime().getCapabilities());
@@ -8347,6 +8444,12 @@ async function startBridgeServer() {
         process.exit(1);
     });
 
+    try {
+        await remoteHub.start();
+    } catch (remoteHubError) {
+        logError('remote', 'failed to start RemoteHub.', remoteHubError);
+    }
+
     httpServer.listen(PORT, '127.0.0.1', async () => {
         try {
             await ensureWorkspaceDataLayout();
@@ -8355,11 +8458,18 @@ async function startBridgeServer() {
         }
 
         const startupCodexRuntime = getCurrentCodexRuntime();
+        const remoteHubStatus = remoteHub.getStatus({ includeSecrets: true });
         logSection('MindExec Local Bridge', [
             formatKeyValue('port', tone(PORT, 'accent')),
             formatKeyValue('workspace', tone(normalizePathForClient(workspacePath), 'path')),
             formatKeyValue('status', tone('ready', 'success')),
             formatKeyValue('exec', tone(formatCodexRuntime(startupCodexRuntime), 'accent')),
+            formatKeyValue('remote', remoteHubStatus.started
+                ? tone(`tcp://${remoteHubStatus.host}:${remoteHubStatus.port}`, 'accent')
+                : tone(remoteHubStatus.enabled ? 'failed' : 'disabled', 'warn')),
+            formatKeyValue('pair', remoteHubStatus.started
+                ? tone(remoteHubStatus.pairTokenPreview, 'warn')
+                : tone('-', 'muted')),
             tone('--------', 'muted'),
             WEB_APP_ROOT
                 ? `${tone('app', 'muted')}      ${tone(getLocalAppUrl(), 'path')}`
@@ -8396,15 +8506,21 @@ async function shutdownBridge(signal) {
         }
     }
 
-    try {
-        wss.close();
-    } catch {
-        // Ignore if already closed
-    }
-
-    await new Promise((resolve) => {
-        try {
-            httpServer.close(() => resolve());
+    try {
+        wss.close();
+    } catch {
+        // Ignore if already closed
+    }
+
+    try {
+        await remoteHub.close();
+    } catch {
+        // Ignore RemoteHub close errors during shutdown
+    }
+
+    await new Promise((resolve) => {
+        try {
+            httpServer.close(() => resolve());
         } catch {
             resolve();
         }

package/wwwroot/_content/MindExecution.Shared/js/mind-map-core.js

@@ -6272,6 +6272,16 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
             if (!ready || !moduleInstance) return;
             await MindMapNodes.addNode(moduleInstance, m);
         },
+        addRemoteFleetMonitor: async () => {
+            const ready = await waitForMindMapReady();
+            if (!ready || !moduleInstance?.dotNetHelper) {
+                return { success: false, error: 'mind-map-not-ready' };
+            }
+
+            const x = Number(moduleInstance.cursorPosition?.x ?? moduleInstance.camera?.position?.x ?? 0);
+            const y = Number(moduleInstance.cursorPosition?.y ?? moduleInstance.camera?.position?.y ?? 0);
+            return await moduleInstance.dotNetHelper.invokeMethodAsync('AddRemoteFleetMonitorNodeFromJs', x, y);
+        },
         // ▼▼▼ [Perf] Expose nodeObjectsById for will-change optimization ▼▼▼
         getNodeObjectsById: () => moduleInstance?.nodeObjectsById || null,
         // ▲▲▲ [Perf] ▲▲▲
@@ -8032,6 +8042,7 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
 
     // Backward-compatible alias: MindCanvas is the new page/internal name, but the underlying surface is the same.
     window.mindCanvas = window.mindMap;
+    window.addRemoteFleetMonitorNode = () => window.mindMap?.addRemoteFleetMonitor?.();
     window.MindMapCoreBuildInfo = {
         build: MINDMAP_CORE_BUILD_ID,
         hasMovingUpdateDue: true,