npm - @mindexec/cli - Versions diffs - 0.2.133 → 0.2.135 - Mend

@mindexec/cli 0.2.133 → 0.2.135

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/package.json +3 -2
package/scripts/remote-fast-mdm-browser-smoke.mjs +13 -17
package/scripts/remote-frame-ws-smoke.mjs +11 -9
package/scripts/remote-registry-follower-smoke.mjs +322 -0
package/server.js +693 -10
package/wwwroot/_content/MindExecution.Shared/js/mind-map-css3d-manager.js +50 -4
package/wwwroot/service-worker-assets.js +2 -2
package/wwwroot/service-worker.js +1 -1

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.133",
+  "version": "0.2.135",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",
@@ -21,7 +21,7 @@
   "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/auth-session-smoke.mjs && node --check scripts/remote-hub-smoke.mjs && node --check scripts/remote-hub-scale-smoke.mjs && node --check scripts/remote-fleet-render-smoke.mjs && node --check scripts/remote-http-smoke.mjs && node --check scripts/remote-frame-ws-smoke.mjs && node --check scripts/remote-agent-ws-smoke.mjs && node --check scripts/remote-agent-managed-smoke.mjs && node --check scripts/remote-agent-package-smoke.mjs && node --check scripts/remote-fast-live-rate-smoke.mjs && node --check scripts/remote-fast-mdm-browser-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/auth-session-smoke.mjs && node --check scripts/remote-hub-smoke.mjs && node --check scripts/remote-hub-scale-smoke.mjs && node --check scripts/remote-fleet-render-smoke.mjs && node --check scripts/remote-http-smoke.mjs && node --check scripts/remote-frame-ws-smoke.mjs && node --check scripts/remote-agent-ws-smoke.mjs && node --check scripts/remote-agent-managed-smoke.mjs && node --check scripts/remote-registry-follower-smoke.mjs && node --check scripts/remote-agent-package-smoke.mjs && node --check scripts/remote-fast-live-rate-smoke.mjs && node --check scripts/remote-fast-mdm-browser-smoke.mjs",
     "test:auth": "node scripts/auth-session-smoke.mjs",
     "test:remote": "node scripts/remote-hub-smoke.mjs",
     "test:remote:scale": "node scripts/remote-hub-scale-smoke.mjs",
@@ -30,6 +30,7 @@
     "test:remote:frame-ws": "node scripts/remote-frame-ws-smoke.mjs",
     "test:remote:agent-ws": "node scripts/remote-agent-ws-smoke.mjs",
     "test:remote:managed": "node scripts/remote-agent-managed-smoke.mjs",
+    "test:remote:registry": "node scripts/remote-registry-follower-smoke.mjs",
     "test:remote:package": "node scripts/remote-agent-package-smoke.mjs",
     "test:remote:live-rate": "node scripts/remote-fast-live-rate-smoke.mjs",
     "test:remote:mdm-browser": "node scripts/remote-fast-mdm-browser-smoke.mjs",

package/scripts/remote-fast-mdm-browser-smoke.mjs CHANGED Viewed

@@ -161,14 +161,14 @@ async function launchBrowser(chromium) {
     throw new Error(`Unable to launch a Chromium browser: ${lastError?.message || 'unknown error'}`);
 }
-async function paintRemoteFrameInBrowser(page, wsUrl, deviceId) {
+async function paintRemoteFrameInBrowser(page, wsUrl, deviceId, fps = REQUESTED_FPS) {
     await page.setContent(`
         <!doctype html>
         <meta charset="utf-8">
         <canvas id="screen" width="320" height="180"></canvas>
     `);
-    return await page.evaluate(async ({ wsUrl, deviceId }) => {
+    return await page.evaluate(async ({ wsUrl, deviceId, fps }) => {
         const canvas = document.getElementById('screen');
         const context = canvas.getContext('2d', { alpha: false, desynchronized: true }) || canvas.getContext('2d');
         if (!context) {
@@ -203,7 +203,15 @@ async function paintRemoteFrameInBrowser(page, wsUrl, deviceId) {
             const ws = new WebSocket(wsUrl);
             ws.binaryType = 'arraybuffer';
             ws.onopen = () => {
-                ws.send(JSON.stringify({ type: 'subscribe', deviceIds: [deviceId] }));
+                ws.send(JSON.stringify({
+                    type: 'subscribe',
+                    deviceIds: [deviceId],
+                    autoStartLive: true,
+                    fps,
+                    maxWidth: 960,
+                    maxHeight: 540,
+                    quality: 60
+                }));
             };
             ws.onerror = () => {
                 clearTimeout(timeout);
@@ -262,7 +270,7 @@ async function paintRemoteFrameInBrowser(page, wsUrl, deviceId) {
                 }
             };
         });
-    }, { wsUrl, deviceId });
+    }, { wsUrl, deviceId, fps });
 }
 async function main() {
@@ -320,23 +328,11 @@ async function main() {
                 && item.capabilities?.binaryFrames === true) || null;
         }, 15000, `RemoteFast device registration\n${hostBridge.details()}\n${clientBridge.details()}`);
-        const live = await fetchJson(`${hostBridge.baseUrl}/api/remote/devices/${encodeURIComponent(device.deviceId)}/live/start`, {
-            method: 'POST',
-            body: JSON.stringify({
-                fps: REQUESTED_FPS,
-                maxWidth: 960,
-                maxHeight: 540,
-                quality: 60
-            })
-        });
-        assert.equal(live.ok, true, JSON.stringify(live.payload));
-        assert.equal(live.payload?.ok, true, JSON.stringify(live.payload));
         const chromium = await loadPlaywrightChromium();
         browser = await launchBrowser(chromium);
         const page = await browser.newPage();
         const wsUrl = `${hostBridge.baseUrl.replace(/^http:/, 'ws:')}/api/remote/frames/ws?token=${encodeURIComponent(BRIDGE_TOKEN)}`;
-        const painted = await paintRemoteFrameInBrowser(page, wsUrl, device.deviceId);
+        const painted = await paintRemoteFrameInBrowser(page, wsUrl, device.deviceId, REQUESTED_FPS);
         assert.ok(painted.frameSeq > 0, JSON.stringify(painted));
         assert.equal(painted.fps, REQUESTED_FPS, JSON.stringify(painted));
         assert.ok(painted.width > 0 && painted.height > 0, JSON.stringify(painted));

package/scripts/remote-frame-ws-smoke.mjs CHANGED Viewed

@@ -151,7 +151,7 @@ async function main() {
         const seed = await fetchJson(`${bridge.baseUrl}/api/remote/synthetic/seed`, {
             method: 'POST',
-            body: JSON.stringify({ count: 4, connectedRatio: 1, liveRatio: 1 })
+            body: JSON.stringify({ count: 4, connectedRatio: 1, thumbnailRatio: 1, liveCount: 0 })
         });
         assert.equal(seed.ok, true);
@@ -165,20 +165,22 @@ async function main() {
             ws.once('open', resolve);
             ws.once('error', reject);
         });
-        ws.send(JSON.stringify({ type: 'subscribe', deviceIds: [device.deviceId] }));
+        ws.send(JSON.stringify({
+            type: 'subscribe',
+            deviceIds: [device.deviceId],
+            autoStartLive: true,
+            fps: 12,
+            maxWidth: 960,
+            maxHeight: 540,
+            quality: 60
+        }));
         const framePromise = waitForBinaryFrame(ws);
-        const live = await fetchJson(`${bridge.baseUrl}/api/remote/devices/${encodeURIComponent(device.deviceId)}/live/start`, {
-            method: 'POST',
-            body: JSON.stringify({ fps: 20 })
-        });
-        assert.equal(live.ok, true);
         const frame = await framePromise;
         assert.equal(frame.metadata.type, 'remote.frame.binary');
         assert.equal(frame.metadata.kind, 'live');
         assert.equal(frame.metadata.deviceId, device.deviceId);
-        assert.equal(frame.metadata.fps, 20);
+        assert.equal(frame.metadata.fps, 12);
         assert.ok(frame.metadata.frameSeq > 0, 'frameSeq should be positive');
         assert.equal(frame.metadata.mimeType, 'image/png');
         assert.ok(frame.payload.length > 0, 'payload should be non-empty');

package/scripts/remote-registry-follower-smoke.mjs ADDED Viewed

@@ -0,0 +1,322 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { createServer } from 'node:http';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const BRIDGE_TOKEN = 'remote-registry-follower-smoke-token';
+const PAIR_TOKEN = 'remote-registry-follower-pair-token';
+const USER_ID = '11111111-2222-4333-8444-555555555555';
+const SUPABASE_KEY = 'remote-registry-follower-key';
+const ACCESS_TOKEN = 'remote-registry-follower-access-token';
+const LOCAL_BRIDGE_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+function wait(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+async function findFreePort() {
+    return await new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.unref();
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            const port = typeof address === 'object' && address ? address.port : 0;
+            server.close(() => resolve(port));
+        });
+    });
+}
+async function fetchJson(url, options = {}) {
+    const response = await fetch(url, {
+        ...options,
+        headers: {
+            ...(options.body ? { 'Content-Type': 'application/json' } : {}),
+            'X-Bridge-Token': options.token || BRIDGE_TOKEN,
+            ...(options.headers || {})
+        }
+    });
+    let payload = null;
+    try {
+        payload = await response.json();
+    } catch {
+        // Empty responses are allowed in failure diagnostics.
+    }
+    return { ok: response.ok, status: response.status, payload };
+}
+async function waitFor(predicate, timeoutMs, label) {
+    const startedAt = Date.now();
+    let lastError = null;
+    while (Date.now() - startedAt < timeoutMs) {
+        try {
+            const value = await predicate();
+            if (value) {
+                return value;
+            }
+        } catch (error) {
+            lastError = error;
+        }
+        await wait(100);
+    }
+    throw new Error(`Timed out waiting for ${label}${lastError ? `: ${lastError.message}` : ''}.`);
+}
+function createRegistryTarget({ endpoint, endpointCandidates, leaseId, active = true }) {
+    return {
+        user_id: USER_ID,
+        active,
+        endpoint,
+        endpoint_candidates: endpointCandidates,
+        pair_token: PAIR_TOKEN,
+        lease_id: leaseId,
+        node_id: 'remote-registry-follower-node',
+        host_instance_id: `host-${leaseId}`,
+        expires_at: new Date(Date.now() + 60_000).toISOString()
+    };
+}
+function startFakeSupabase(getTarget) {
+    const requests = [];
+    const server = createServer((req, res) => {
+        const parsed = new URL(req.url || '/', 'http://127.0.0.1');
+        requests.push({
+            method: req.method,
+            pathname: parsed.pathname,
+            authorization: req.headers.authorization || '',
+            apikey: req.headers.apikey || ''
+        });
+        if (req.method === 'GET' && parsed.pathname === '/rest/v1/remote_host_targets') {
+            assert.equal(String(req.headers.apikey || ''), SUPABASE_KEY);
+            assert.equal(String(req.headers.authorization || ''), `Bearer ${ACCESS_TOKEN}`);
+            res.writeHead(200, {
+                'Content-Type': 'application/json',
+                'Cache-Control': 'no-store'
+            });
+            const target = getTarget();
+            res.end(JSON.stringify(target ? [target] : []));
+            return;
+        }
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'not-found' }));
+    });
+    return new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            const port = typeof address === 'object' && address ? address.port : 0;
+            resolve({
+                url: `http://127.0.0.1:${port}`,
+                requests,
+                stop: () => new Promise(done => server.close(done))
+            });
+        });
+    });
+}
+function spawnBridge({ bridgePort, remoteHubPort, workspacePath, authRoot, label, supabaseUrl = '', follower = false }) {
+    const child = spawn(process.execPath, ['server.js'], {
+        cwd: LOCAL_BRIDGE_DIR,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+        env: {
+            ...process.env,
+            BRIDGE_PORT: String(bridgePort),
+            BRIDGE_TOKEN,
+            BRIDGE_REQUIRE_TOKEN: '1',
+            MINDEXEC_REMOTE_HUB: '1',
+            REMOTE_HUB_HOST: '127.0.0.1',
+            REMOTE_HUB_PORT: String(remoteHubPort),
+            REMOTE_HUB_PAIR_TOKEN: PAIR_TOKEN,
+            WORKSPACE_PATH: workspacePath,
+            MINDEXEC_AUTH_DATA_ROOT: authRoot,
+            MINDEXEC_REMOTE_REGISTRY_FOLLOWER: follower ? '1' : '0',
+            MINDEXEC_REMOTE_REGISTRY_POLL_MS: '500',
+            MINDEXEC_REMOTE_REGISTRY_FAST_RETRY_MS: '250',
+            SUPABASE_URL: supabaseUrl,
+            SUPABASE_KEY,
+            NO_COLOR: '1'
+        }
+    });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', chunk => {
+        stdout += chunk.toString();
+    });
+    child.stderr.on('data', chunk => {
+        stderr += chunk.toString();
+    });
+    const exitPromise = new Promise(resolve => child.once('exit', resolve));
+    const details = () => `${label} stdout=${stdout}\n${label} stderr=${stderr}`;
+    const stop = async () => {
+        if (child.exitCode === null && !child.killed) {
+            child.kill('SIGTERM');
+            await Promise.race([exitPromise, wait(5000)]);
+            if (child.exitCode === null && !child.killed) {
+                child.kill('SIGKILL');
+            }
+        }
+    };
+    return {
+        baseUrl: `http://127.0.0.1:${bridgePort}`,
+        child,
+        details,
+        stop
+    };
+}
+async function waitForBridge(bridge) {
+    return await waitFor(async () => {
+        const result = await fetchJson(`${bridge.baseUrl}/api/status`);
+        return result.ok && result.payload?.status === 'ok' ? result.payload : null;
+    }, 30000, `bridge startup\n${bridge.details()}`);
+}
+async function writeSession(authRoot) {
+    await mkdir(authRoot, { recursive: true });
+    await writeFile(path.join(authRoot, 'supabase-session.json'), JSON.stringify({
+        access_token: ACCESS_TOKEN,
+        expires_at: Math.floor(Date.now() / 1000) + 3600,
+        user: {
+            id: USER_ID,
+            email: 'remote-registry-follower@example.test'
+        }
+    }), 'utf8');
+}
+async function waitForManagedAgent(bridge, managerEndpoint, label) {
+    return await waitFor(async () => {
+        const result = await fetchJson(`${bridge.baseUrl}/api/remote/agent/status`);
+        const agent = result.payload;
+        return agent?.running === true
+            && agent?.ready === true
+            && String(agent.manager || '') === managerEndpoint
+            ? agent
+            : null;
+    }, 20000, `${label} managed agent\n${bridge.details()}`);
+}
+async function waitForConnectedDevice(bridge, label) {
+    return await waitFor(async () => {
+        const result = await fetchJson(`${bridge.baseUrl}/api/remote/devices`);
+        return result.payload?.devices?.find(device => device.connected === true) || null;
+    }, 12000, `${label} connected device\n${bridge.details()}`);
+}
+async function main() {
+    const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'mindexec-remote-registry-smoke-'));
+    let fakeSupabase = null;
+    let hostA = null;
+    let hostB = null;
+    let client = null;
+    const hostABridgePort = await findFreePort();
+    const hostARemotePort = await findFreePort();
+    const hostBBridgePort = await findFreePort();
+    const hostBRemotePort = await findFreePort();
+    const clientBridgePort = await findFreePort();
+    const clientRemotePort = await findFreePort();
+    const stalePort = await findFreePort();
+    const hostAEndpoint = `127.0.0.1:${hostARemotePort}`;
+    const hostBEndpoint = `127.0.0.1:${hostBRemotePort}`;
+    const staleEndpoint = `127.0.0.1:${stalePort}`;
+    let currentTarget = createRegistryTarget({
+        endpoint: hostAEndpoint,
+        endpointCandidates: [staleEndpoint, hostAEndpoint],
+        leaseId: 'lease-a'
+    });
+    try {
+        fakeSupabase = await startFakeSupabase(() => currentTarget);
+        const hostAAuth = path.join(tempRoot, 'auth-host-a');
+        const hostBAuth = path.join(tempRoot, 'auth-host-b');
+        const clientAuth = path.join(tempRoot, 'auth-client');
+        await writeSession(clientAuth);
+        hostA = spawnBridge({
+            bridgePort: hostABridgePort,
+            remoteHubPort: hostARemotePort,
+            workspacePath: path.join(tempRoot, 'host-a'),
+            authRoot: hostAAuth,
+            label: 'host-a'
+        });
+        hostB = spawnBridge({
+            bridgePort: hostBBridgePort,
+            remoteHubPort: hostBRemotePort,
+            workspacePath: path.join(tempRoot, 'host-b'),
+            authRoot: hostBAuth,
+            label: 'host-b'
+        });
+        await waitForBridge(hostA);
+        await waitForBridge(hostB);
+        client = spawnBridge({
+            bridgePort: clientBridgePort,
+            remoteHubPort: clientRemotePort,
+            workspacePath: path.join(tempRoot, 'client'),
+            authRoot: clientAuth,
+            label: 'client',
+            supabaseUrl: fakeSupabase.url,
+            follower: true
+        });
+        await waitForBridge(client);
+        const firstAgent = await waitForManagedAgent(client, hostAEndpoint, 'host-a');
+        assert.equal(firstAgent.usingNpx, false, JSON.stringify(firstAgent));
+        assert.match(String(firstAgent.launcher || ''), /mindexec-remote-fast/i);
+        assert.equal(firstAgent.manager, hostAEndpoint);
+        assert.equal(firstAgent.managerCandidates?.[0], staleEndpoint, JSON.stringify(firstAgent.managerCandidates));
+        await waitForConnectedDevice(hostA, 'host-a');
+        currentTarget = createRegistryTarget({
+            endpoint: hostBEndpoint,
+            endpointCandidates: [hostBEndpoint],
+            leaseId: 'lease-b'
+        });
+        const secondAgent = await waitForManagedAgent(client, hostBEndpoint, 'host-b');
+        assert.equal(secondAgent.usingNpx, false, JSON.stringify(secondAgent));
+        assert.match(String(secondAgent.launcher || ''), /mindexec-remote-fast/i);
+        assert.equal(secondAgent.manager, hostBEndpoint);
+        assert.equal(secondAgent.leaseId, 'lease-b');
+        await waitForConnectedDevice(hostB, 'host-b');
+        currentTarget = {
+            ...currentTarget,
+            active: false,
+            expires_at: new Date(Date.now() - 1000).toISOString()
+        };
+        await waitFor(async () => {
+            const result = await fetchJson(`${client.baseUrl}/api/remote/agent/status`);
+            return result.payload?.running === false
+                && String(result.payload?.lastError || '') === 'registry-inactive'
+                ? result.payload
+                : null;
+        }, 15000, `registry inactive stop\n${client.details()}`);
+        assert.ok(fakeSupabase.requests.length >= 2, JSON.stringify(fakeSupabase.requests));
+        console.log('Remote registry follower smoke OK');
+    } finally {
+        if (client) await client.stop();
+        if (hostB) await hostB.stop();
+        if (hostA) await hostA.stop();
+        if (fakeSupabase) await fakeSupabase.stop();
+        await rm(tempRoot, { recursive: true, force: true });
+    }
+}
+await main();