@mindexec/cli 0.2.1 → 0.2.3

package/scripts/remote-hub-smoke.mjs

@@ -0,0 +1,117 @@
+#!/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: false
+        }
+    });
+    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);
+
+    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,56 @@ 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.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 +8408,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 +8422,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 +8470,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/css/mind-map-overrides.css

@@ -36,6 +36,17 @@
     contain-intrinsic-size: auto !important;
 }
 
+.css3d-resolution-wrapper.node-type-templatelauncher,
+.css3d-resolution-wrapper.node-type-templatelauncher > .map-node,
+.css3d-resolution-wrapper.node-type-templatelauncher > .map-node-template-card {
+    contain: layout style !important;
+    content-visibility: visible !important;
+    contain-intrinsic-size: auto !important;
+    isolation: isolate !important;
+    -webkit-backface-visibility: visible !important;
+    backface-visibility: visible !important;
+}
+
 .css3d-resolution-wrapper.node-type-image > .map-node,
 .css3d-resolution-wrapper.node-type-video > .map-node,
 .css3d-resolution-wrapper.node-type-embed > .map-node {

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

@@ -5,7 +5,7 @@
     const DEBUG = false;
     const FPS_DEBUG = false;
     const FRAME_PERF_DEBUG = false;
-    const MINDMAP_CORE_BUILD_ID = '20260609-midfar-idle-resident-wake-v204';
+    const MINDMAP_CORE_BUILD_ID = '20260610-template-board-ready-v205';
     const CanvasPhase = Object.freeze({
         Booting: 'booting',
         BoardFileLoading: 'board-file-loading',
@@ -170,6 +170,52 @@
     let moduleInstance = null;
     let pendingAuthToken = null;
     let pendingSettings = null;
+    let _lastCompletedBoardLoadId = null;
+    let _lastCompletedBoardLoadAt = 0;
+
+    function normalizeBoardIdValue(boardId) {
+        return String(boardId ?? '').trim().toLowerCase();
+    }
+
+    function invalidateCurrentBoardLoadCompletion(reason = 'unknown') {
+        _lastCompletedBoardLoadId = null;
+        _lastCompletedBoardLoadAt = 0;
+        emitMindCanvasTrace('board.load.pending', {
+            boardId: _currentBoardId,
+            reason
+        });
+    }
+
+    function isCurrentBoardLoadComplete() {
+        const activeBoardId = normalizeBoardIdValue(_currentBoardId);
+        return !!activeBoardId && activeBoardId === _lastCompletedBoardLoadId;
+    }
+
+    function markBoardLoadComplete(boardId, reason = 'unknown') {
+        const expectedBoardId = normalizeBoardIdValue(boardId);
+        const activeBoardId = normalizeBoardIdValue(_currentBoardId);
+        if (!expectedBoardId || expectedBoardId !== activeBoardId) {
+            emitMindCanvasTrace('board.staleMutationBlocked', {
+                mutation: 'markBoardLoadComplete',
+                expectedBoardId,
+                activeBoardId,
+                reason
+            });
+            return false;
+        }
+
+        _lastCompletedBoardLoadId = expectedBoardId;
+        _lastCompletedBoardLoadAt = typeof performance !== 'undefined' ? performance.now() : Date.now();
+        emitMindCanvasTrace('board.load.complete', {
+            boardId: _currentBoardId,
+            reason,
+            nodeCount: moduleInstance?.nodeObjectsById?.size || 0,
+            isLoading: moduleInstance?.isLoading === true,
+            phase: moduleInstance?.canvasPhase || null
+        });
+        return true;
+    }
+
     function isDocumentHidden() {
         return typeof document !== 'undefined' && document.visibilityState === 'hidden';
     }
@@ -1997,7 +2043,11 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
     let _currentBoardId = null;
 
     function setActiveBoardIdRuntime(boardId, reason = 'unknown') {
+        const previousBoardId = _currentBoardId;
         _currentBoardId = boardId || null;
+        if (normalizeBoardIdValue(previousBoardId) !== normalizeBoardIdValue(_currentBoardId)) {
+            invalidateCurrentBoardLoadCompletion(reason);
+        }
         window.MindCanvasBuildInfo?.setRuntime?.('activeBoardId', _currentBoardId);
         emitMindCanvasTrace('board.active', {
             boardId: _currentBoardId,
@@ -6222,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] ▲▲▲
@@ -7258,6 +7318,7 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
             if (boardId) {
                 setActiveBoardIdRuntime(boardId, 'resetBoard');
             }
+            invalidateCurrentBoardLoadCompletion('resetBoard');
             // ▲▲▲ [Fix] ▲▲▲
             const resetPhase = moduleInstance.canvasPhase === CanvasPhase.Booting
                 ? CanvasPhase.BoardFileLoading
@@ -7369,9 +7430,22 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
         // ▼▼▼ [Fix] Expose activeBoardId for async guard in addNode ▼▼▼
         get activeBoardId() { return _currentBoardId; },
         setActiveBoardId: (boardId) => { setActiveBoardIdRuntime(boardId, 'external-setActiveBoardId'); },
+        markBoardLoadCompleteForBoard: (boardId) => markBoardLoadComplete(boardId, 'csharp-board-load-complete'),
+        getActiveBoardRuntimeState: () => ({
+            activeBoardId: _currentBoardId,
+            activeBoardIdNormalized: normalizeBoardIdValue(_currentBoardId),
+            isLoading: moduleInstance?.isLoading === true,
+            canvasPhase: moduleInstance?.canvasPhase || null,
+            nodeCount: moduleInstance?.nodeObjectsById?.size || 0,
+            boardLoadComplete: isCurrentBoardLoadComplete(),
+            boardLoadCompletedAt: _lastCompletedBoardLoadAt || 0
+        }),
         getRuntimeDiagnostics: () => ({
             activeBoardId: _currentBoardId,
             canvasPhase: moduleInstance?.canvasPhase || null,
+            isLoading: moduleInstance?.isLoading === true,
+            boardLoadComplete: isCurrentBoardLoadComplete(),
+            nodeCount: moduleInstance?.nodeObjectsById?.size || 0,
             buildInfo: window.MindCanvasBuildInfo?.dump?.() || null,
             guardCounts: window.MindCanvasDevGuards?.getCounts?.() || {},
             trace: {
@@ -7968,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,