mindexec-ai 0.2.385

package/scripts/auth-session-smoke.mjs

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, mkdir, rm, writeFile } 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 = 'auth-session-smoke-token';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const bridgeRoot = path.resolve(__dirname, '..');
+
+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' } : {}),
+            ...(options.token ? { 'X-Bridge-Token': options.token } : {}),
+            ...(options.headers || {})
+        }
+    });
+
+    let payload = null;
+    try {
+        payload = await response.json();
+    } catch {
+        // Ignore non-JSON responses.
+    }
+
+    return {
+        status: response.status,
+        ok: response.ok,
+        payload
+    };
+}
+
+function spawnBridge({ bridgePort, workspacePath, authDataRoot }) {
+    const child = spawn(process.execPath, ['server.js'], {
+        cwd: bridgeRoot,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+        env: {
+            ...process.env,
+            BRIDGE_PORT: String(bridgePort),
+            BRIDGE_TOKEN,
+            BRIDGE_REQUIRE_TOKEN: '1',
+            WORKSPACE_PATH: workspacePath,
+            MINDEXEC_AUTH_DATA_ROOT: authDataRoot,
+            MINDEXEC_REMOTE_HUB: '0',
+            MINDEXEC_REMOTE_REGISTRY_FOLLOWER: '0',
+            NO_COLOR: '1'
+        }
+    });
+
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', chunk => {
+        stdout += chunk.toString();
+    });
+    child.stderr.on('data', chunk => {
+        stderr += chunk.toString();
+    });
+
+    const details = () => `stdout=${stdout}\nstderr=${stderr}`;
+    const stop = async () => {
+        if (!child.killed) {
+            child.kill();
+        }
+        await Promise.race([
+            new Promise(resolve => child.once('exit', resolve)),
+            wait(3000)
+        ]);
+    };
+
+    return {
+        child,
+        details,
+        stop
+    };
+}
+
+async function waitForBridge(baseUrl, details) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < 30000) {
+        try {
+            const response = await fetchJson(`${baseUrl}/api/status`);
+            if (response.ok && response.payload?.status) {
+                return;
+            }
+        } catch {
+            // Bridge is still starting.
+        }
+        await wait(100);
+    }
+
+    throw new Error(`Timed out waiting for LocalBridge.\n${details()}`);
+}
+
+async function withBridge({ workspacePath, authDataRoot }, action) {
+    const bridgePort = await findFreePort();
+    const bridge = spawnBridge({ bridgePort, workspacePath, authDataRoot });
+    const baseUrl = `http://127.0.0.1:${bridgePort}`;
+    try {
+        await waitForBridge(baseUrl, bridge.details);
+        await action(baseUrl);
+    } finally {
+        await bridge.stop();
+    }
+}
+
+const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'mindexec-auth-session-smoke-'));
+try {
+    const authDataRoot = path.join(tempRoot, 'stable-auth');
+    const workspaceA = path.join(tempRoot, 'workspace-a');
+    const workspaceB = path.join(tempRoot, 'workspace-b');
+    await mkdir(workspaceA, { recursive: true });
+    await mkdir(workspaceB, { recursive: true });
+
+    const sessionPayload = JSON.stringify({
+        access_token: 'access-token-a',
+        refresh_token: 'refresh-token-a',
+        expires_at: Math.floor(Date.now() / 1000) + 600,
+        user: {
+            id: 'user-a',
+            email: 'auth-smoke@example.com'
+        }
+    });
+    let expectedStablePayload = sessionPayload;
+
+    function makeTimedSessionPayload(accessToken, refreshToken, expiresInSeconds) {
+        return JSON.stringify({
+            access_token: accessToken,
+            refresh_token: refreshToken,
+            expires_at: Math.floor(Date.now() / 1000) + expiresInSeconds,
+            user: {
+                id: 'user-a',
+                email: 'auth-smoke@example.com'
+            }
+        });
+    }
+
+    await withBridge({ workspacePath: workspaceA, authDataRoot }, async (baseUrl) => {
+        const unauthorized = await fetchJson(`${baseUrl}/api/auth/session`);
+        assert.equal(unauthorized.status, 401);
+
+        const missing = await fetchJson(`${baseUrl}/api/auth/session`, { token: BRIDGE_TOKEN });
+        assert.equal(missing.status, 404);
+
+        const invalid = await fetchJson(`${baseUrl}/api/auth/session`, {
+            method: 'POST',
+            token: BRIDGE_TOKEN,
+            body: JSON.stringify({ content: 'not-json' })
+        });
+        assert.equal(invalid.status, 400);
+
+        const saved = await fetchJson(`${baseUrl}/api/auth/session`, {
+            method: 'POST',
+            token: BRIDGE_TOKEN,
+            body: JSON.stringify({ content: sessionPayload })
+        });
+        assert.equal(saved.status, 200);
+        assert.equal(saved.payload?.success, true);
+
+        const loaded = await fetchJson(`${baseUrl}/api/auth/session`, { token: BRIDGE_TOKEN });
+        assert.equal(loaded.status, 200);
+        assert.equal(loaded.payload?.content, sessionPayload);
+        assert.equal(loaded.payload?.source, 'stable');
+
+        const newerPayload = makeTimedSessionPayload('access-token-newer', 'refresh-token-newer', 3600);
+        const newerSaved = await fetchJson(`${baseUrl}/api/auth/session`, {
+            method: 'POST',
+            token: BRIDGE_TOKEN,
+            body: JSON.stringify({ content: newerPayload })
+        });
+        assert.equal(newerSaved.status, 200);
+
+        const staleBrowserPayload = makeTimedSessionPayload('access-token-stale-browser', 'refresh-token-stale-browser', 120);
+        const staleSaved = await fetchJson(`${baseUrl}/api/auth/session`, {
+            method: 'POST',
+            token: BRIDGE_TOKEN,
+            body: JSON.stringify({ content: staleBrowserPayload })
+        });
+        assert.equal(staleSaved.status, 200);
+
+        const afterStale = await fetchJson(`${baseUrl}/api/auth/session`, { token: BRIDGE_TOKEN });
+        assert.equal(afterStale.status, 200);
+        assert.equal(JSON.parse(afterStale.payload?.content || '{}').access_token, 'access-token-newer');
+
+        const newestPayload = makeTimedSessionPayload('access-token-newest', 'refresh-token-newest', 7200);
+        const newestSaved = await fetchJson(`${baseUrl}/api/auth/session`, {
+            method: 'POST',
+            token: BRIDGE_TOKEN,
+            body: JSON.stringify({ content: newestPayload })
+        });
+        assert.equal(newestSaved.status, 200);
+        expectedStablePayload = newestPayload;
+    });
+
+    await withBridge({ workspacePath: workspaceB, authDataRoot }, async (baseUrl) => {
+        const loaded = await fetchJson(`${baseUrl}/api/auth/session`, { token: BRIDGE_TOKEN });
+        assert.equal(loaded.status, 200);
+        assert.equal(loaded.payload?.content, expectedStablePayload);
+        assert.equal(loaded.payload?.source, 'stable');
+
+        const deleted = await fetchJson(`${baseUrl}/api/auth/session`, {
+            method: 'DELETE',
+            token: BRIDGE_TOKEN
+        });
+        assert.equal(deleted.status, 200);
+        assert.equal(deleted.payload?.success, true);
+    });
+
+    const legacyPayload = JSON.stringify({
+        access_token: 'legacy-access-token',
+        refresh_token: 'legacy-refresh-token',
+        user: {
+            id: 'legacy-user',
+            email: 'legacy-auth-smoke@example.com'
+        }
+    });
+    const legacyPath = path.join(workspaceB, '.mindexec', 'auth', 'supabase-session.json');
+    await mkdir(path.dirname(legacyPath), { recursive: true });
+    await writeFile(legacyPath, legacyPayload, 'utf8');
+
+    await withBridge({ workspacePath: workspaceB, authDataRoot }, async (baseUrl) => {
+        const migrated = await fetchJson(`${baseUrl}/api/auth/session`, { token: BRIDGE_TOKEN });
+        assert.equal(migrated.status, 200);
+        assert.equal(migrated.payload?.content, legacyPayload);
+        assert.equal(migrated.payload?.source, 'legacy-workspace');
+        assert.equal(migrated.payload?.migrated, true);
+    });
+
+    await withBridge({ workspacePath: workspaceA, authDataRoot }, async (baseUrl) => {
+        const loaded = await fetchJson(`${baseUrl}/api/auth/session`, { token: BRIDGE_TOKEN });
+        assert.equal(loaded.status, 200);
+        assert.equal(loaded.payload?.content, legacyPayload);
+        assert.equal(loaded.payload?.source, 'stable');
+    });
+
+    console.log('Auth session persistence smoke OK');
+} finally {
+    await rm(tempRoot, { recursive: true, force: true });
+}

package/scripts/remote-agent-managed-smoke.mjs

@@ -0,0 +1,291 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, readFile, 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-agent-managed-smoke-token';
+const PAIR_TOKEN = 'remote-agent-managed-pair-token';
+const LEASE_ID = 'remote-agent-managed-smoke-lease';
+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 {
+        // Some failure responses may be empty.
+    }
+
+    return {
+        status: response.status,
+        ok: response.ok,
+        payload
+    };
+}
+
+async function waitFor(predicate, timeoutMs = 30000, label = 'condition') {
+    const startedAt = Date.now();
+    let lastError = null;
+    while (Date.now() - startedAt < timeoutMs) {
+        try {
+            const value = await predicate();
+            if (value) {
+                return value;
+            }
+        } catch (err) {
+            lastError = err;
+        }
+
+        await wait(100);
+    }
+
+    throw new Error(`Timed out waiting for ${label}${lastError ? `: ${lastError.message}` : ''}.`);
+}
+
+function spawnBridge({ bridgePort, remoteHubPort, workspacePath, 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',
+            REMOTE_HUB_HOST: '127.0.0.1',
+            REMOTE_HUB_PORT: String(remoteHubPort),
+            REMOTE_HUB_PAIR_TOKEN: PAIR_TOKEN,
+            WORKSPACE_PATH: workspacePath,
+            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 startHangingRemoteManager(port) {
+    const sockets = new Set();
+    const server = net.createServer(socket => {
+        sockets.add(socket);
+        socket.on('close', () => sockets.delete(socket));
+        socket.on('error', () => sockets.delete(socket));
+    });
+    server.unref();
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(port, '127.0.0.1', resolve);
+    });
+
+    return {
+        endpoint: `127.0.0.1:${port}`,
+        async stop() {
+            for (const socket of sockets) {
+                socket.destroy();
+            }
+            await new Promise(resolve => server.close(resolve));
+        }
+    };
+}
+
+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 connectManagedAgent(clientBridge, managerEndpoint, staleEndpoint) {
+    const result = await fetchJson(`${clientBridge.baseUrl}/api/remote/agent/connect`, {
+        method: 'POST',
+        body: JSON.stringify({
+            managerCandidates: [staleEndpoint, managerEndpoint],
+            pairToken: PAIR_TOKEN,
+            leaseId: LEASE_ID,
+            nodeId: 'remote-agent-managed-smoke-node',
+            engine: 'auto',
+            source: 'local-bridge-registry'
+        })
+    });
+
+    assert.equal(result.ok, true, JSON.stringify(result.payload));
+    assert.equal(result.payload?.ok, true, JSON.stringify(result.payload));
+    return result.payload.agent;
+}
+
+async function main() {
+    const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'mindexec-remote-managed-smoke-'));
+    const hostWorkspace = path.join(tempRoot, 'host');
+    const clientWorkspace = path.join(tempRoot, 'client');
+    const hostBridgePort = await findFreePort();
+    const hostRemotePort = await findFreePort();
+    const clientBridgePort = await findFreePort();
+    const clientRemotePort = await findFreePort();
+    const stalePort = await findFreePort();
+    const managerEndpoint = `127.0.0.1:${hostRemotePort}`;
+    let hangingManager = null;
+    const staleEndpoint = `127.0.0.1:${stalePort}`;
+
+    let hostBridge = null;
+    let clientBridge = null;
+    try {
+        hangingManager = await startHangingRemoteManager(stalePort);
+        hostBridge = spawnBridge({
+            bridgePort: hostBridgePort,
+            remoteHubPort: hostRemotePort,
+            workspacePath: hostWorkspace,
+            label: 'host'
+        });
+        await waitForBridge(hostBridge);
+
+        clientBridge = spawnBridge({
+            bridgePort: clientBridgePort,
+            remoteHubPort: clientRemotePort,
+            workspacePath: clientWorkspace,
+            label: 'client-1'
+        });
+        await waitForBridge(clientBridge);
+
+        const firstConnectStartedAt = Date.now();
+        const firstAgent = await connectManagedAgent(clientBridge, managerEndpoint, staleEndpoint);
+        const firstConnectMs = Date.now() - firstConnectStartedAt;
+        assert.equal(firstAgent.running, true, JSON.stringify(firstAgent));
+        assert.equal(firstAgent.ready, true, JSON.stringify(firstAgent));
+        assert.equal(firstAgent.usingNpx, false, JSON.stringify(firstAgent));
+        assert.match(String(firstAgent.launcher || ''), /mindexec-remote-fast/i);
+        assert.ok(
+            firstConnectMs < 4500,
+            `managed RemoteAgent must race slow endpoint candidates instead of waiting sequentially, got ${firstConnectMs}ms`);
+
+        const connectedDevice = await waitFor(async () => {
+            const result = await fetchJson(`${hostBridge.baseUrl}/api/remote/devices`);
+            return result.payload?.devices?.find(device => device.connected === true) || null;
+        }, 10000, `host device registration\n${hostBridge.details()}\n${clientBridge.details()}`);
+        assert.equal(connectedDevice.capabilities?.binaryFrames, true);
+
+        await clientBridge.stop();
+        clientBridge = null;
+
+        const cachePath = path.join(clientWorkspace, '.mindexec', 'cache', 'remote-agent-recent-managers.json');
+        const cache = JSON.parse(await readFile(cachePath, 'utf8'));
+        assert.equal(cache.version, 1);
+        assert.equal(cache.entries?.[0]?.endpoint, managerEndpoint, JSON.stringify(cache));
+
+        clientBridge = spawnBridge({
+            bridgePort: clientBridgePort,
+            remoteHubPort: clientRemotePort,
+            workspacePath: clientWorkspace,
+            label: 'client-2'
+        });
+        await waitForBridge(clientBridge);
+
+        const secondAgent = await connectManagedAgent(clientBridge, managerEndpoint, staleEndpoint);
+        assert.equal(secondAgent.running, true, JSON.stringify(secondAgent));
+        assert.equal(secondAgent.ready, true, JSON.stringify(secondAgent));
+        assert.equal(secondAgent.usingNpx, false, JSON.stringify(secondAgent));
+        assert.match(String(secondAgent.launcher || ''), /mindexec-remote-fast/i);
+        assert.equal(secondAgent.managerCandidates?.[0], managerEndpoint, JSON.stringify(secondAgent.managerCandidates));
+        assert.equal(secondAgent.managerCandidates?.[1], staleEndpoint, JSON.stringify(secondAgent.managerCandidates));
+
+        const staleReport = await fetchJson(`${clientBridge.baseUrl}/api/remote/agent/sync-report`, {
+            method: 'POST',
+            body: JSON.stringify({
+                ok: false,
+                attempted: true,
+                disconnected: true,
+                authenticated: true,
+                reason: 'agent-disconnected',
+                targetActive: true,
+                targetEndpoint: managerEndpoint,
+                targetEndpointCandidates: [managerEndpoint, staleEndpoint],
+                targetLeaseId: LEASE_ID,
+                targetNodeId: 'remote-agent-managed-smoke-node'
+            })
+        });
+        assert.equal(staleReport.ok, true, JSON.stringify(staleReport.payload));
+
+        const staleState = await fetchJson(`${clientBridge.baseUrl}/api/remote/agent/status`);
+        assert.equal(staleState.payload?.needsReconnect, true, JSON.stringify(staleState.payload));
+
+        const thirdAgent = await connectManagedAgent(clientBridge, managerEndpoint, staleEndpoint);
+        assert.equal(thirdAgent.running, true, JSON.stringify(thirdAgent));
+        assert.equal(thirdAgent.ready, true, JSON.stringify(thirdAgent));
+        assert.equal(thirdAgent.needsReconnect, false, JSON.stringify(thirdAgent));
+        assert.notEqual(thirdAgent.pid, secondAgent.pid, `stale registry-owned RemoteAgent should be restarted, second=${secondAgent.pid}, third=${thirdAgent.pid}`);
+
+        console.log('RemoteAgent managed supervisor smoke OK');
+    } finally {
+        if (hangingManager) {
+            await hangingManager.stop();
+        }
+        if (clientBridge) {
+            await clientBridge.stop();
+        }
+        if (hostBridge) {
+            await hostBridge.stop();
+        }
+        await rm(tempRoot, { recursive: true, force: true });
+    }
+}
+
+await main();

package/scripts/remote-agent-package-smoke.mjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+const REQUIRED_REMOTE_FAST_FILES = [
+    'remote-fast/win-x64/mindexec-remote-fast.exe',
+    'remote-fast/win-x64/mindexec-remote-fast.dll',
+    'remote-fast/win-x64/mindexec-remote-fast.runtimeconfig.json',
+    'remote-fast/osx-arm64/mindexec-remote-fast',
+    'remote-fast/osx-arm64/mindexec-remote-fast.dll',
+    'remote-fast/osx-arm64/mindexec-remote-fast.runtimeconfig.json',
+    'remote-fast/osx-x64/mindexec-remote-fast',
+    'remote-fast/osx-x64/mindexec-remote-fast.dll',
+    'remote-fast/osx-x64/mindexec-remote-fast.runtimeconfig.json'
+];
+
+function parsePackJson(stdout) {
+    const text = String(stdout || '').trim();
+    assert.ok(text, 'npm pack --dry-run should produce JSON output');
+    const payload = JSON.parse(text);
+    assert.ok(Array.isArray(payload) && payload.length > 0, 'npm pack dry-run JSON should contain one package entry');
+    return payload[0];
+}
+
+function resolveNpmPackCommand() {
+    const npmExecPath = String(process.env.npm_execpath || '').trim();
+    if (npmExecPath && /\.js$/i.test(npmExecPath)) {
+        return {
+            command: process.execPath,
+            argsPrefix: [npmExecPath]
+        };
+    }
+
+    return {
+        command: process.platform === 'win32' ? 'npm.cmd' : 'npm',
+        argsPrefix: []
+    };
+}
+
+async function main() {
+    const npm = resolveNpmPackCommand();
+    const { stdout } = await execFileAsync(npm.command, [...npm.argsPrefix, 'pack', '--dry-run', '--json'], {
+        windowsHide: true,
+        maxBuffer: 16 * 1024 * 1024
+    });
+    const pack = parsePackJson(stdout);
+    const files = new Set((pack.files || []).map(file => String(file.path || '').replace(/\\/g, '/')));
+
+    for (const required of REQUIRED_REMOTE_FAST_FILES) {
+        assert.ok(files.has(required), `packaged mindexec-ai is missing ${required}`);
+    }
+
+    const npxFallbackOnly = [...files].some(file => file.endsWith('server.js'))
+        && ![...files].some(file => file.startsWith('remote-fast/'));
+    assert.equal(npxFallbackOnly, false, 'packaged CLI must include bundled RemoteFast, not only npx fallback code');
+
+    console.log('RemoteAgent package smoke OK');
+}
+
+await main();