@mindexec/cli 0.2.476 → 0.2.478

package/scripts/auth-session-smoke.mjs

@@ -1,262 +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 });
-}
+#!/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 });
+}