@mindexec/cli 0.2.477 → 0.2.478

package/scripts/board-render-ownership-smoke.mjs

@@ -1,85 +1,85 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import vm from 'node:vm';
-import { fileURLToPath } from 'node:url';
-
-const scriptDir = path.dirname(fileURLToPath(import.meta.url));
-const sourcePath = path.resolve(
-    scriptDir,
-    '..',
-    '..',
-    'MindExecution.Shared',
-    'wwwroot',
-    'js',
-    'mind-map-board-render-ownership.js');
-const source = fs.readFileSync(sourcePath, 'utf8');
-const traces = [];
-const window = {
-    MindCanvasTrace: { emit: (type, data) => traces.push({ type, data }) },
-    MindCanvasBuildInfo: { registerPart: () => { } }
-};
-
-vm.runInNewContext(source, { window, Map, Object, Number, String, Math });
-
-const makeMesh = (count = 8) => ({
-    visible: true,
-    geometry: {
-        instanceCount: count,
-        drawRange: { start: 0, count: count },
-        setDrawRange(start, nextCount) {
-            this.drawRange = { start, count: nextCount };
-        }
-    }
-});
-const renderer = {
-    resetCalls: 0,
-    resetState() { this.resetCalls++; },
-    pendingNodes: new Map([['stale-node', {}]]),
-    instancedHaloMesh: makeMesh(),
-    instancedMesh: makeMesh(),
-    instancedLineMesh: makeMesh(),
-    instancedBorderLineMesh: makeMesh(),
-    instancedConsoleMesh: makeMesh(),
-    instancedImageMesh: makeMesh(),
-    requestResidentPatch(reason) { this.patchReason = reason; }
-};
-const module = { _forceUpdateFrames: 0 };
-
-assert.equal(window.MindMapBoardRenderOwnership.retireResidentBoard(renderer, module, {
-    fromBoardId: 'BOARD-B',
-    toBoardId: 'BOARD-A'
-}), true);
-assert.equal(renderer.resetCalls, 1);
-assert.equal(renderer.pendingNodes.size, 0);
-assert.equal(renderer._activeBoardRenderId, 'board-a');
-assert.equal(renderer._residentBuilt, false);
-assert.equal(renderer._residentBuildPhase, 'board-switch');
-for (const mesh of [
-    renderer.instancedHaloMesh,
-    renderer.instancedMesh,
-    renderer.instancedLineMesh,
-    renderer.instancedBorderLineMesh,
-    renderer.instancedConsoleMesh,
-    renderer.instancedImageMesh
-]) {
-    assert.equal(mesh.visible, false);
-    assert.equal(mesh.geometry.instanceCount, 0);
-}
-assert.equal(renderer.instancedBorderLineMesh.geometry.drawRange.count, 0);
-assert.equal(traces.at(-1)?.type, 'board.resident.retired');
-
-const lineDataCache = new Map([['node-a', [1, 2, 3]]]);
-assert.equal(window.MindMapBoardRenderOwnership.prepareCachedBoard(renderer, module, {
-    boardId: 'BOARD-A',
-    lineDataCache
-}), true);
-assert.equal(renderer.lineDataCache, lineDataCache);
-assert.equal(renderer.patchReason, 'board-reload');
-
-console.log(JSON.stringify({
-    ok: true,
-    retiredResidentCount: 0,
-    activeBoardRenderId: renderer._activeBoardRenderId,
-    patchReason: renderer.patchReason
-}));
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const sourcePath = path.resolve(
+    scriptDir,
+    '..',
+    '..',
+    'MindExecution.Shared',
+    'wwwroot',
+    'js',
+    'mind-map-board-render-ownership.js');
+const source = fs.readFileSync(sourcePath, 'utf8');
+const traces = [];
+const window = {
+    MindCanvasTrace: { emit: (type, data) => traces.push({ type, data }) },
+    MindCanvasBuildInfo: { registerPart: () => { } }
+};
+
+vm.runInNewContext(source, { window, Map, Object, Number, String, Math });
+
+const makeMesh = (count = 8) => ({
+    visible: true,
+    geometry: {
+        instanceCount: count,
+        drawRange: { start: 0, count: count },
+        setDrawRange(start, nextCount) {
+            this.drawRange = { start, count: nextCount };
+        }
+    }
+});
+const renderer = {
+    resetCalls: 0,
+    resetState() { this.resetCalls++; },
+    pendingNodes: new Map([['stale-node', {}]]),
+    instancedHaloMesh: makeMesh(),
+    instancedMesh: makeMesh(),
+    instancedLineMesh: makeMesh(),
+    instancedBorderLineMesh: makeMesh(),
+    instancedConsoleMesh: makeMesh(),
+    instancedImageMesh: makeMesh(),
+    requestResidentPatch(reason) { this.patchReason = reason; }
+};
+const module = { _forceUpdateFrames: 0 };
+
+assert.equal(window.MindMapBoardRenderOwnership.retireResidentBoard(renderer, module, {
+    fromBoardId: 'BOARD-B',
+    toBoardId: 'BOARD-A'
+}), true);
+assert.equal(renderer.resetCalls, 1);
+assert.equal(renderer.pendingNodes.size, 0);
+assert.equal(renderer._activeBoardRenderId, 'board-a');
+assert.equal(renderer._residentBuilt, false);
+assert.equal(renderer._residentBuildPhase, 'board-switch');
+for (const mesh of [
+    renderer.instancedHaloMesh,
+    renderer.instancedMesh,
+    renderer.instancedLineMesh,
+    renderer.instancedBorderLineMesh,
+    renderer.instancedConsoleMesh,
+    renderer.instancedImageMesh
+]) {
+    assert.equal(mesh.visible, false);
+    assert.equal(mesh.geometry.instanceCount, 0);
+}
+assert.equal(renderer.instancedBorderLineMesh.geometry.drawRange.count, 0);
+assert.equal(traces.at(-1)?.type, 'board.resident.retired');
+
+const lineDataCache = new Map([['node-a', [1, 2, 3]]]);
+assert.equal(window.MindMapBoardRenderOwnership.prepareCachedBoard(renderer, module, {
+    boardId: 'BOARD-A',
+    lineDataCache
+}), true);
+assert.equal(renderer.lineDataCache, lineDataCache);
+assert.equal(renderer.patchReason, 'board-reload');
+
+console.log(JSON.stringify({
+    ok: true,
+    retiredResidentCount: 0,
+    activeBoardRenderId: renderer._activeBoardRenderId,
+    patchReason: renderer.patchReason
+}));

package/scripts/codex-model-catalog-smoke.mjs

@@ -1,150 +1,150 @@
-import assert from 'node:assert/strict';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import {
-    buildExternalCodexCatalogEnv,
-    createCodexModelCatalog
-} from '../codex-model-catalog.js';
-
-function catalogJson(models) {
-    return JSON.stringify({ models });
-}
-
-function listed(slug, priority, displayName = slug) {
-    return {
-        slug,
-        display_name: displayName,
-        visibility: 'list',
-        priority,
-        supported_in_api: true,
-        supported_reasoning_levels: [{ effort: 'medium' }, { effort: 'high' }]
-    };
-}
-
-async function testExternalPathWinsAndForceRefreshBypassesCache() {
-    const packageBin = path.join('C:', 'tmp', 'package', 'node_modules', '.bin');
-    const globalBin = path.join('C:', 'tools', 'codex');
-    const env = { PATH: [packageBin, globalBin].join(path.delimiter) };
-    const externalEnv = buildExternalCodexCatalogEnv(env);
-    assert.equal(externalEnv.PATH.includes('node_modules'), false);
-    assert.equal(externalEnv.PATH.includes(globalBin), true);
-
-    let calls = 0;
-    const execute = async (command, options) => {
-        calls += 1;
-        assert.equal(command, 'codex debug models');
-        assert.equal(String(options.env.PATH).includes('node_modules'), false);
-        const current = calls === 1 ? 'gpt-current-a' : 'gpt-current-b';
-        return {
-            stdout: catalogJson([
-                listed('hidden-model', 0),
-                listed(current, 1, current.toUpperCase()),
-                { ...listed('not-listed', 2), visibility: 'hide' }
-            ]),
-            stderr: ''
-        };
-    };
-    const catalog = createCodexModelCatalog({ execute, env, packageRoot: process.cwd() });
-
-    const first = await catalog.getCatalog();
-    const cached = await catalog.getCatalog();
-    assert.equal(calls, 1);
-    assert.strictEqual(cached, first);
-    assert.deepEqual(first.models.map(model => model.id), ['hidden-model', 'gpt-current-a']);
-    assert.equal(first.commandSource, 'external');
-    assert.equal(first.stale, false);
-
-    const refreshed = await catalog.getCatalog({ forceRefresh: true });
-    assert.equal(calls, 2);
-    assert.deepEqual(refreshed.models.map(model => model.id), ['hidden-model', 'gpt-current-b']);
-}
-
-async function testConcurrentRefreshIsSingleFlight() {
-    let calls = 0;
-    let release;
-    const gate = new Promise(resolve => {
-        release = resolve;
-    });
-    const catalog = createCodexModelCatalog({
-        execute: async () => {
-            calls += 1;
-            await gate;
-            return { stdout: catalogJson([listed('gpt-concurrent', 1)]), stderr: '' };
-        }
-    });
-
-    const first = catalog.getCatalog({ forceRefresh: true });
-    const second = catalog.getCatalog({ forceRefresh: true });
-    await Promise.resolve();
-    assert.equal(calls, 1);
-    release();
-    const [firstResult, secondResult] = await Promise.all([first, second]);
-    assert.strictEqual(firstResult, secondResult);
-    assert.equal(calls, 1);
-}
-
-async function testPackageFallbackNormalizesNewerConfigPreference() {
-    const commands = [];
-    const catalog = createCodexModelCatalog({
-        execute: async command => {
-            commands.push(command);
-            if (commands.length === 1) {
-                throw new Error('external Codex CLI unavailable');
-            }
-
-            return { stdout: catalogJson([listed('gpt-package-fallback', 1)]), stderr: '' };
-        }
-    });
-
-    const result = await catalog.getCatalog({ forceRefresh: true });
-    assert.equal(commands.length, 2);
-    assert.match(commands[1], /model_reasoning_effort=high/);
-    assert.equal(result.commandSource, 'package-local');
-    assert.deepEqual(result.models.map(model => model.id), ['gpt-package-fallback']);
-}
-
-async function testFailedRefreshPreservesLastVerifiedCatalog() {
-    let shouldFail = false;
-    const catalog = createCodexModelCatalog({
-        execute: async () => {
-            if (shouldFail) {
-                throw new Error('temporary catalog failure');
-            }
-
-            return { stdout: catalogJson([listed('gpt-last-known-good', 1)]), stderr: '' };
-        }
-    });
-
-    const verified = await catalog.getCatalog({ forceRefresh: true });
-    shouldFail = true;
-    const stale = await catalog.getCatalog({ forceRefresh: true });
-    assert.deepEqual(stale.models, verified.models);
-    assert.equal(stale.updatedAt, verified.updatedAt);
-    assert.equal(stale.stale, true);
-    assert.match(stale.error, /external:.*temporary catalog failure/);
-    assert.match(stale.error, /package-local:.*temporary catalog failure/);
-}
-
-async function runDeterministicSmoke() {
-    await testExternalPathWinsAndForceRefreshBypassesCache();
-    await testConcurrentRefreshIsSingleFlight();
-    await testPackageFallbackNormalizesNewerConfigPreference();
-    await testFailedRefreshPreservesLastVerifiedCatalog();
-    console.log('[codex-model-catalog-smoke] deterministic catalog contracts passed');
-}
-
-async function runLiveSmoke() {
-    const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
-    const catalog = createCodexModelCatalog({ packageRoot: path.resolve(scriptDirectory, '..') });
-    const result = await catalog.getCatalog({ forceRefresh: true });
-    assert.ok(result.models.length > 0, result.error || 'expected a non-empty live Codex catalog');
-    assert.equal(result.commandSource, 'external');
-    assert.equal(result.stale, false);
-    console.log(`[codex-model-catalog-smoke] live ${result.source} (${result.commandSource}): ${result.models.map(model => model.id).join(', ')}`);
-}
-
-if (process.argv.includes('--live')) {
-    await runLiveSmoke();
-} else {
-    await runDeterministicSmoke();
-}
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+    buildExternalCodexCatalogEnv,
+    createCodexModelCatalog
+} from '../codex-model-catalog.js';
+
+function catalogJson(models) {
+    return JSON.stringify({ models });
+}
+
+function listed(slug, priority, displayName = slug) {
+    return {
+        slug,
+        display_name: displayName,
+        visibility: 'list',
+        priority,
+        supported_in_api: true,
+        supported_reasoning_levels: [{ effort: 'medium' }, { effort: 'high' }]
+    };
+}
+
+async function testExternalPathWinsAndForceRefreshBypassesCache() {
+    const packageBin = path.join('C:', 'tmp', 'package', 'node_modules', '.bin');
+    const globalBin = path.join('C:', 'tools', 'codex');
+    const env = { PATH: [packageBin, globalBin].join(path.delimiter) };
+    const externalEnv = buildExternalCodexCatalogEnv(env);
+    assert.equal(externalEnv.PATH.includes('node_modules'), false);
+    assert.equal(externalEnv.PATH.includes(globalBin), true);
+
+    let calls = 0;
+    const execute = async (command, options) => {
+        calls += 1;
+        assert.equal(command, 'codex debug models');
+        assert.equal(String(options.env.PATH).includes('node_modules'), false);
+        const current = calls === 1 ? 'gpt-current-a' : 'gpt-current-b';
+        return {
+            stdout: catalogJson([
+                listed('hidden-model', 0),
+                listed(current, 1, current.toUpperCase()),
+                { ...listed('not-listed', 2), visibility: 'hide' }
+            ]),
+            stderr: ''
+        };
+    };
+    const catalog = createCodexModelCatalog({ execute, env, packageRoot: process.cwd() });
+
+    const first = await catalog.getCatalog();
+    const cached = await catalog.getCatalog();
+    assert.equal(calls, 1);
+    assert.strictEqual(cached, first);
+    assert.deepEqual(first.models.map(model => model.id), ['hidden-model', 'gpt-current-a']);
+    assert.equal(first.commandSource, 'external');
+    assert.equal(first.stale, false);
+
+    const refreshed = await catalog.getCatalog({ forceRefresh: true });
+    assert.equal(calls, 2);
+    assert.deepEqual(refreshed.models.map(model => model.id), ['hidden-model', 'gpt-current-b']);
+}
+
+async function testConcurrentRefreshIsSingleFlight() {
+    let calls = 0;
+    let release;
+    const gate = new Promise(resolve => {
+        release = resolve;
+    });
+    const catalog = createCodexModelCatalog({
+        execute: async () => {
+            calls += 1;
+            await gate;
+            return { stdout: catalogJson([listed('gpt-concurrent', 1)]), stderr: '' };
+        }
+    });
+
+    const first = catalog.getCatalog({ forceRefresh: true });
+    const second = catalog.getCatalog({ forceRefresh: true });
+    await Promise.resolve();
+    assert.equal(calls, 1);
+    release();
+    const [firstResult, secondResult] = await Promise.all([first, second]);
+    assert.strictEqual(firstResult, secondResult);
+    assert.equal(calls, 1);
+}
+
+async function testPackageFallbackNormalizesNewerConfigPreference() {
+    const commands = [];
+    const catalog = createCodexModelCatalog({
+        execute: async command => {
+            commands.push(command);
+            if (commands.length === 1) {
+                throw new Error('external Codex CLI unavailable');
+            }
+
+            return { stdout: catalogJson([listed('gpt-package-fallback', 1)]), stderr: '' };
+        }
+    });
+
+    const result = await catalog.getCatalog({ forceRefresh: true });
+    assert.equal(commands.length, 2);
+    assert.match(commands[1], /model_reasoning_effort=high/);
+    assert.equal(result.commandSource, 'package-local');
+    assert.deepEqual(result.models.map(model => model.id), ['gpt-package-fallback']);
+}
+
+async function testFailedRefreshPreservesLastVerifiedCatalog() {
+    let shouldFail = false;
+    const catalog = createCodexModelCatalog({
+        execute: async () => {
+            if (shouldFail) {
+                throw new Error('temporary catalog failure');
+            }
+
+            return { stdout: catalogJson([listed('gpt-last-known-good', 1)]), stderr: '' };
+        }
+    });
+
+    const verified = await catalog.getCatalog({ forceRefresh: true });
+    shouldFail = true;
+    const stale = await catalog.getCatalog({ forceRefresh: true });
+    assert.deepEqual(stale.models, verified.models);
+    assert.equal(stale.updatedAt, verified.updatedAt);
+    assert.equal(stale.stale, true);
+    assert.match(stale.error, /external:.*temporary catalog failure/);
+    assert.match(stale.error, /package-local:.*temporary catalog failure/);
+}
+
+async function runDeterministicSmoke() {
+    await testExternalPathWinsAndForceRefreshBypassesCache();
+    await testConcurrentRefreshIsSingleFlight();
+    await testPackageFallbackNormalizesNewerConfigPreference();
+    await testFailedRefreshPreservesLastVerifiedCatalog();
+    console.log('[codex-model-catalog-smoke] deterministic catalog contracts passed');
+}
+
+async function runLiveSmoke() {
+    const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
+    const catalog = createCodexModelCatalog({ packageRoot: path.resolve(scriptDirectory, '..') });
+    const result = await catalog.getCatalog({ forceRefresh: true });
+    assert.ok(result.models.length > 0, result.error || 'expected a non-empty live Codex catalog');
+    assert.equal(result.commandSource, 'external');
+    assert.equal(result.stale, false);
+    console.log(`[codex-model-catalog-smoke] live ${result.source} (${result.commandSource}): ${result.models.map(model => model.id).join(', ')}`);
+}
+
+if (process.argv.includes('--live')) {
+    await runLiveSmoke();
+} else {
+    await runDeterministicSmoke();
+}

package/scripts/codex-runtime-home-smoke.mjs

@@ -1,58 +1,58 @@
-import assert from 'node:assert/strict';
-import { promises as fs } from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import {
-    buildCodexChildEnv,
-    ensureCodexRuntimeHome,
-    resolveCodexRuntimeHome
-} from '../codex-runtime.js';
-
-const previousCodexHome = process.env.CODEX_HOME;
-const previousMindExecCodexHome = process.env.MINDEXEC_CODEX_HOME;
-const sharedHome = await fs.mkdtemp(path.join(os.tmpdir(), 'mindexec-codex-shared-home-'));
-const isolatedHome = await fs.mkdtemp(path.join(os.tmpdir(), 'mindexec-codex-isolated-home-'));
-
-try {
-    process.env.CODEX_HOME = sharedHome;
-    delete process.env.MINDEXEC_CODEX_HOME;
-
-    assert.equal(resolveCodexRuntimeHome(), path.resolve(sharedHome));
-    assert.equal(await ensureCodexRuntimeHome(), path.resolve(sharedHome));
-    assert.equal(await fs.stat(path.join(sharedHome, 'sessions')).then(() => true), true);
-    assert.equal(await fs.stat(path.join(sharedHome, 'generated_images')).then(() => true), true);
-    assert.equal(await fs.stat(path.join(sharedHome, 'config.toml')).then(() => true).catch(() => false), false);
-
-    const sharedEnv = buildCodexChildEnv();
-    assert.equal(sharedEnv.CODEX_HOME, path.resolve(sharedHome));
-    assert.equal(sharedEnv.MINDEXEC_CODEX_ISOLATED_HOME, undefined);
-
-    process.env.MINDEXEC_CODEX_HOME = isolatedHome;
-    assert.equal(resolveCodexRuntimeHome(), path.resolve(isolatedHome));
-    assert.equal(await ensureCodexRuntimeHome(), path.resolve(isolatedHome));
-    const isolatedConfig = await fs.readFile(path.join(isolatedHome, 'config.toml'), 'utf8');
-    assert.match(isolatedConfig, /Generated by MindExec LocalBridge for isolated AI node runs/);
-
-    const isolatedEnv = buildCodexChildEnv();
-    assert.equal(isolatedEnv.CODEX_HOME, path.resolve(isolatedHome));
-    assert.equal(isolatedEnv.MINDEXEC_CODEX_ISOLATED_HOME, '1');
-
-    console.log(JSON.stringify({
-        ok: true,
-        sharedCodexLoginHome: true,
-        explicitIsolationOnly: true
-    }));
-} finally {
-    if (previousCodexHome === undefined) {
-        delete process.env.CODEX_HOME;
-    } else {
-        process.env.CODEX_HOME = previousCodexHome;
-    }
-    if (previousMindExecCodexHome === undefined) {
-        delete process.env.MINDEXEC_CODEX_HOME;
-    } else {
-        process.env.MINDEXEC_CODEX_HOME = previousMindExecCodexHome;
-    }
-    await fs.rm(sharedHome, { recursive: true, force: true });
-    await fs.rm(isolatedHome, { recursive: true, force: true });
-}
+import assert from 'node:assert/strict';
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {
+    buildCodexChildEnv,
+    ensureCodexRuntimeHome,
+    resolveCodexRuntimeHome
+} from '../codex-runtime.js';
+
+const previousCodexHome = process.env.CODEX_HOME;
+const previousMindExecCodexHome = process.env.MINDEXEC_CODEX_HOME;
+const sharedHome = await fs.mkdtemp(path.join(os.tmpdir(), 'mindexec-codex-shared-home-'));
+const isolatedHome = await fs.mkdtemp(path.join(os.tmpdir(), 'mindexec-codex-isolated-home-'));
+
+try {
+    process.env.CODEX_HOME = sharedHome;
+    delete process.env.MINDEXEC_CODEX_HOME;
+
+    assert.equal(resolveCodexRuntimeHome(), path.resolve(sharedHome));
+    assert.equal(await ensureCodexRuntimeHome(), path.resolve(sharedHome));
+    assert.equal(await fs.stat(path.join(sharedHome, 'sessions')).then(() => true), true);
+    assert.equal(await fs.stat(path.join(sharedHome, 'generated_images')).then(() => true), true);
+    assert.equal(await fs.stat(path.join(sharedHome, 'config.toml')).then(() => true).catch(() => false), false);
+
+    const sharedEnv = buildCodexChildEnv();
+    assert.equal(sharedEnv.CODEX_HOME, path.resolve(sharedHome));
+    assert.equal(sharedEnv.MINDEXEC_CODEX_ISOLATED_HOME, undefined);
+
+    process.env.MINDEXEC_CODEX_HOME = isolatedHome;
+    assert.equal(resolveCodexRuntimeHome(), path.resolve(isolatedHome));
+    assert.equal(await ensureCodexRuntimeHome(), path.resolve(isolatedHome));
+    const isolatedConfig = await fs.readFile(path.join(isolatedHome, 'config.toml'), 'utf8');
+    assert.match(isolatedConfig, /Generated by MindExec LocalBridge for isolated AI node runs/);
+
+    const isolatedEnv = buildCodexChildEnv();
+    assert.equal(isolatedEnv.CODEX_HOME, path.resolve(isolatedHome));
+    assert.equal(isolatedEnv.MINDEXEC_CODEX_ISOLATED_HOME, '1');
+
+    console.log(JSON.stringify({
+        ok: true,
+        sharedCodexLoginHome: true,
+        explicitIsolationOnly: true
+    }));
+} finally {
+    if (previousCodexHome === undefined) {
+        delete process.env.CODEX_HOME;
+    } else {
+        process.env.CODEX_HOME = previousCodexHome;
+    }
+    if (previousMindExecCodexHome === undefined) {
+        delete process.env.MINDEXEC_CODEX_HOME;
+    } else {
+        process.env.MINDEXEC_CODEX_HOME = previousMindExecCodexHome;
+    }
+    await fs.rm(sharedHome, { recursive: true, force: true });
+    await fs.rm(isolatedHome, { recursive: true, force: true });
+}