mindexec-ai 0.2.385

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

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, mkdir, rm } from 'node:fs/promises';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const BRIDGE_TOKEN = 'remote-hub-identity-smoke-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: {
+            'X-Bridge-Token': BRIDGE_TOKEN,
+            ...(options.headers || {})
+        }
+    });
+    let payload = null;
+    try {
+        payload = await response.json();
+    } catch {
+        // Ignore non-JSON diagnostics.
+    }
+    return { ok: response.ok, status: response.status, payload };
+}
+
+function spawnBridge({ bridgePort, remoteHubPort, workspacePath, authDataRoot, label }) {
+    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',
+            MINDEXEC_REMOTE_REGISTRY_FOLLOWER: '0',
+            REMOTE_HUB_HOST: '127.0.0.1',
+            REMOTE_HUB_PORT: String(remoteHubPort),
+            WORKSPACE_PATH: workspacePath,
+            MINDEXEC_AUTH_DATA_ROOT: authDataRoot,
+            REMOTE_HUB_PAIR_TOKEN: '',
+            MINDEXEC_REMOTE_PAIR_TOKEN: '',
+            MINDEXEC_BRIDGE_INSTANCE_ID: '',
+            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(3000)]);
+            if (child.exitCode === null && !child.killed) {
+                child.kill('SIGKILL');
+            }
+        }
+    };
+
+    return {
+        baseUrl: `http://127.0.0.1:${bridgePort}`,
+        details,
+        stop
+    };
+}
+
+async function waitForStatus(bridge) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < 30000) {
+        try {
+            const result = await fetchJson(`${bridge.baseUrl}/api/remote/status`);
+            if (result.ok && result.payload?.started === true) {
+                return result.payload;
+            }
+        } catch {
+            // Bridge still starting.
+        }
+        await wait(100);
+    }
+
+    throw new Error(`Timed out waiting for bridge status.\n${bridge.details()}`);
+}
+
+async function runOnce({ workspacePath, authDataRoot, label }) {
+    const bridgePort = await findFreePort();
+    const remoteHubPort = await findFreePort();
+    const bridge = spawnBridge({ bridgePort, remoteHubPort, workspacePath, authDataRoot, label });
+    try {
+        return await waitForStatus(bridge);
+    } finally {
+        await bridge.stop();
+    }
+}
+
+const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'mindexec-remote-hub-identity-smoke-'));
+try {
+    const workspacePath = path.join(tempRoot, 'workspace');
+    const authDataRoot = path.join(tempRoot, 'auth');
+    await mkdir(workspacePath, { recursive: true });
+    await mkdir(authDataRoot, { recursive: true });
+
+    const first = await runOnce({ workspacePath, authDataRoot, label: 'first' });
+    const second = await runOnce({ workspacePath, authDataRoot, label: 'second' });
+
+    assert.ok(first.pairToken, JSON.stringify(first));
+    assert.ok(first.hostInstanceId, JSON.stringify(first));
+    assert.equal(second.pairToken, first.pairToken);
+    assert.equal(second.hostInstanceId, first.hostInstanceId);
+    assert.match(first.hostInstanceId, /^bridge-[a-f0-9]{32}$/);
+
+    console.log('RemoteHub identity persistence smoke OK');
+} finally {
+    await rm(tempRoot, { recursive: true, force: true });
+}

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

@@ -0,0 +1,124 @@
+#!/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 || 500);
+
+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' in device.latestThumbnail), false);
+    assert.equal(devices.some(device => device.activeLiveStream?.active === true), true);
+
+    const devicesWithDataUrl = hub.listDevices({ includeDataUrl: true });
+    assert.equal(devicesWithDataUrl.some(device => device.latestThumbnail?.dataUrl), 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');
+    assert.equal('dataUrl' in hub.getDeviceThumbnail(thumbnailTarget.deviceId), false);
+    assert.ok(hub.getDeviceThumbnail(thumbnailTarget.deviceId, { includeDataUrl: true }).dataUrl);
+
+    const liveTarget = devices.find(device => device.connected && device.capabilities?.liveStream);
+    assert.ok(liveTarget);
+    const liveResult = hub.startLiveStream(liveTarget.deviceId, {
+        streamId: 'scale-live',
+        fps: 20,
+        maxWidth: 960,
+        maxHeight: 540,
+        quality: 60
+    });
+    assert.equal(liveResult.ok, true);
+    assert.equal(hub.getDeviceLiveFrame(liveTarget.deviceId).streamId, 'scale-live');
+    assert.equal(hub.getDeviceLiveFrame(liveTarget.deviceId).fps, 20);
+    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, 500);
+    assert.ok(connectedTargets.length >= 400);
+    const scaleBatch = hub.requestAgentTaskBatch(connectedTargets.map(device => device.deviceId), {
+        instruction: 'Synthetic scale task: report current status to the manager.',
+        title: 'Scale task batch'
+    });
+    assert.equal(scaleBatch.ok, true);
+    assert.equal(scaleBatch.total, connectedTargets.length);
+    assert.equal(scaleBatch.queued, connectedTargets.length);
+    assert.equal(scaleBatch.results.every(result => result.ok === true), true);
+    assert.equal(scaleBatch.batch?.completed, connectedTargets.length);
+    assert.equal(scaleBatch.batch?.failed, 0);
+    assert.equal(scaleBatch.batch?.status, 'completed');
+    const latestBatch = hub.getLatestTaskBatch();
+    assert.equal(latestBatch?.batchId, scaleBatch.batchId);
+    assert.equal(latestBatch?.completed, 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');
+    const updatedAiTarget = hub.listDevices().find(device => device.deviceId === aiTarget.deviceId);
+    assert.equal(updatedAiTarget?.latestTask?.approvalLevel, 'ai-assist');
+    assert.equal(updatedAiTarget?.latestTask?.resultModel, 'synthetic-ai');
+    assert.match(updatedAiTarget?.latestTask?.resultResponseId || '', /^synthetic-response-/);
+
+    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();
+}