@mindexec/cli 0.2.477 → 0.2.478

package/scripts/codex-sdk-image-live-smoke.mjs

@@ -1,43 +1,43 @@
-import assert from 'node:assert/strict';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { createCodexRuntime, resolveCodexRuntimeHome } from '../codex-runtime.js';
-
-if (!process.argv.includes('--live')) {
-    console.log(JSON.stringify({ ok: true, liveImage: false }));
-    process.exit(0);
-}
-
-const scriptDir = path.dirname(fileURLToPath(import.meta.url));
-const packageRoot = path.resolve(scriptDir, '..');
-const workspaceRoot = path.resolve(packageRoot, '..');
-const runtime = createCodexRuntime({
-    packageRoot,
-    resolveWorkingDirectory: async () => workspaceRoot,
-    getCurrentRuntime: () => ({}),
-    getModelCatalog: async () => ({ models: [], source: 'live-smoke', updatedAt: new Date().toISOString() }),
-    log: () => {}
-});
-
-const result = await runtime.runImage({
-    prompt: 'Create a clean square test image with one solid blue circle centered on a white background. No text.',
-    size: '1024x1024',
-    quality: 'low'
-});
-
-assert.equal(result.success, true, result.error);
-assert.equal(result.providerKind, 'TypeScriptSdk');
-assert.equal(result.authenticationRequired, false);
-assert.equal(result.loginOpened, false, 'The existing Codex login should be reused without opening sign-in.');
-assert.ok(result.imageBase64.length > 1000, 'The live SDK image result was unexpectedly small.');
-assert.match(result.mimeType, /^image\//);
-
-console.log(JSON.stringify({
-    ok: true,
-    liveImage: true,
-    providerKind: result.providerKind,
-    sharedCodexHome: resolveCodexRuntimeHome(),
-    loginOpened: result.loginOpened,
-    mimeType: result.mimeType,
-    imageBytesApprox: Math.floor(result.imageBase64.length * 0.75)
-}));
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createCodexRuntime, resolveCodexRuntimeHome } from '../codex-runtime.js';
+
+if (!process.argv.includes('--live')) {
+    console.log(JSON.stringify({ ok: true, liveImage: false }));
+    process.exit(0);
+}
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.resolve(scriptDir, '..');
+const workspaceRoot = path.resolve(packageRoot, '..');
+const runtime = createCodexRuntime({
+    packageRoot,
+    resolveWorkingDirectory: async () => workspaceRoot,
+    getCurrentRuntime: () => ({}),
+    getModelCatalog: async () => ({ models: [], source: 'live-smoke', updatedAt: new Date().toISOString() }),
+    log: () => {}
+});
+
+const result = await runtime.runImage({
+    prompt: 'Create a clean square test image with one solid blue circle centered on a white background. No text.',
+    size: '1024x1024',
+    quality: 'low'
+});
+
+assert.equal(result.success, true, result.error);
+assert.equal(result.providerKind, 'TypeScriptSdk');
+assert.equal(result.authenticationRequired, false);
+assert.equal(result.loginOpened, false, 'The existing Codex login should be reused without opening sign-in.');
+assert.ok(result.imageBase64.length > 1000, 'The live SDK image result was unexpectedly small.');
+assert.match(result.mimeType, /^image\//);
+
+console.log(JSON.stringify({
+    ok: true,
+    liveImage: true,
+    providerKind: result.providerKind,
+    sharedCodexHome: resolveCodexRuntimeHome(),
+    loginOpened: result.loginOpened,
+    mimeType: result.mimeType,
+    imageBytesApprox: Math.floor(result.imageBase64.length * 0.75)
+}));

package/scripts/codex-sdk-image-runtime-smoke.mjs

@@ -1,122 +1,122 @@
-import assert from 'node:assert/strict';
-import { promises as fs } from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { createCodexRuntime } from '../codex-runtime.js';
-
-const scriptDir = path.dirname(fileURLToPath(import.meta.url));
-const packageRoot = path.resolve(scriptDir, '..');
-const workspaceRoot = path.resolve(packageRoot, '..');
-const runtimeHome = await fs.mkdtemp(path.join(os.tmpdir(), 'mindexec-codex-sdk-image-'));
-const tinyPngBase64 = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+jX8kAAAAASUVORK5CYII=';
-
-function imageEvents() {
-    return (async function* generateEvents() {
-        yield { type: 'thread.started', thread_id: 'thread-image-smoke' };
-        yield {
-            type: 'event_msg',
-            payload: {
-                type: 'image_generation_end',
-                result: `data:image/png;base64,${tinyPngBase64}`
-            }
-        };
-        yield { type: 'turn.completed' };
-    })();
-}
-
-function createFakeSdk(runStreamed, captures) {
-    return {
-        Codex: class FakeCodex {
-            constructor(options) {
-                captures.codexOptions.push(options);
-            }
-
-            startThread(options) {
-                captures.threadOptions.push(options);
-                return {
-                    runStreamed: async input => {
-                        captures.inputs.push(input);
-                        return { events: runStreamed() };
-                    }
-                };
-            }
-        }
-    };
-}
-
-function createRuntime(fakeSdk, loginCodex) {
-    return createCodexRuntime({
-        packageRoot,
-        resolveWorkingDirectory: async () => workspaceRoot,
-        getCurrentRuntime: () => ({}),
-        getModelCatalog: async () => ({ models: [], source: 'smoke', updatedAt: new Date().toISOString() }),
-        loadCodexSdk: async () => fakeSdk,
-        ensureCodexRuntimeHome: async () => {
-            await fs.mkdir(path.join(runtimeHome, 'generated_images'), { recursive: true });
-            return runtimeHome;
-        },
-        buildCodexChildEnv: () => ({ CODEX_HOME: runtimeHome }),
-        loginCodex,
-        log: () => {}
-    });
-}
-
-try {
-    const captures = { codexOptions: [], threadOptions: [], inputs: [] };
-    const runtime = createRuntime(createFakeSdk(imageEvents, captures), async () => {
-        throw new Error('Login must not run for an authenticated image request.');
-    });
-    const generated = await runtime.runImage({
-        prompt: 'Create a blue product icon.',
-        model: 'gpt-5.5',
-        size: '1024x1024',
-        quality: 'high',
-        referenceImages: [{ base64: tinyPngBase64, mimeType: 'image/png', fileName: 'source.png' }]
-    });
-
-    assert.equal(generated.success, true, generated.error);
-    assert.equal(generated.providerKind, 'TypeScriptSdk');
-    assert.equal(generated.imageBase64, tinyPngBase64);
-    assert.equal(generated.mimeType, 'image/png');
-    assert.equal(captures.codexOptions[0].config.features.image_generation, true);
-    assert.deepEqual(captures.codexOptions[0].config.mcp_servers, {});
-    assert.equal(captures.threadOptions[0].sandboxMode, 'read-only');
-    assert.equal(captures.inputs[0][0].type, 'text');
-    assert.equal(captures.inputs[0][1].type, 'local_image');
-    assert.equal(await fs.stat(captures.inputs[0][1].path).then(() => true).catch(() => false), false);
-
-    let attempts = 0;
-    let loginCount = 0;
-    const authCaptures = { codexOptions: [], threadOptions: [], inputs: [] };
-    const authSdk = createFakeSdk(() => {
-        attempts += 1;
-        if (attempts === 1) {
-            return (async function* invalidAuth() {
-                throw new Error('401 Unauthorized: invalid_refresh_token. Please log out and sign in again.');
-            })();
-        }
-        return imageEvents();
-    }, authCaptures);
-    const authRuntime = createRuntime(authSdk, async () => {
-        loginCount += 1;
-        return { success: true, exitCode: 0 };
-    });
-    const retried = await authRuntime.runImage({ prompt: 'Create one test image.' });
-
-    assert.equal(loginCount, 1);
-    assert.equal(attempts, 2);
-    assert.equal(retried.success, true, retried.error);
-    assert.equal(retried.loginOpened, true);
-    assert.equal(retried.authenticationRequired, false);
-    assert.equal(retried.providerKind, 'TypeScriptSdk');
-
-    console.log(JSON.stringify({
-        ok: true,
-        providerKind: generated.providerKind,
-        referenceAttachment: true,
-        browserLoginRetry: true
-    }));
-} finally {
-    await fs.rm(runtimeHome, { 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 { fileURLToPath } from 'node:url';
+import { createCodexRuntime } from '../codex-runtime.js';
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.resolve(scriptDir, '..');
+const workspaceRoot = path.resolve(packageRoot, '..');
+const runtimeHome = await fs.mkdtemp(path.join(os.tmpdir(), 'mindexec-codex-sdk-image-'));
+const tinyPngBase64 = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+jX8kAAAAASUVORK5CYII=';
+
+function imageEvents() {
+    return (async function* generateEvents() {
+        yield { type: 'thread.started', thread_id: 'thread-image-smoke' };
+        yield {
+            type: 'event_msg',
+            payload: {
+                type: 'image_generation_end',
+                result: `data:image/png;base64,${tinyPngBase64}`
+            }
+        };
+        yield { type: 'turn.completed' };
+    })();
+}
+
+function createFakeSdk(runStreamed, captures) {
+    return {
+        Codex: class FakeCodex {
+            constructor(options) {
+                captures.codexOptions.push(options);
+            }
+
+            startThread(options) {
+                captures.threadOptions.push(options);
+                return {
+                    runStreamed: async input => {
+                        captures.inputs.push(input);
+                        return { events: runStreamed() };
+                    }
+                };
+            }
+        }
+    };
+}
+
+function createRuntime(fakeSdk, loginCodex) {
+    return createCodexRuntime({
+        packageRoot,
+        resolveWorkingDirectory: async () => workspaceRoot,
+        getCurrentRuntime: () => ({}),
+        getModelCatalog: async () => ({ models: [], source: 'smoke', updatedAt: new Date().toISOString() }),
+        loadCodexSdk: async () => fakeSdk,
+        ensureCodexRuntimeHome: async () => {
+            await fs.mkdir(path.join(runtimeHome, 'generated_images'), { recursive: true });
+            return runtimeHome;
+        },
+        buildCodexChildEnv: () => ({ CODEX_HOME: runtimeHome }),
+        loginCodex,
+        log: () => {}
+    });
+}
+
+try {
+    const captures = { codexOptions: [], threadOptions: [], inputs: [] };
+    const runtime = createRuntime(createFakeSdk(imageEvents, captures), async () => {
+        throw new Error('Login must not run for an authenticated image request.');
+    });
+    const generated = await runtime.runImage({
+        prompt: 'Create a blue product icon.',
+        model: 'gpt-5.5',
+        size: '1024x1024',
+        quality: 'high',
+        referenceImages: [{ base64: tinyPngBase64, mimeType: 'image/png', fileName: 'source.png' }]
+    });
+
+    assert.equal(generated.success, true, generated.error);
+    assert.equal(generated.providerKind, 'TypeScriptSdk');
+    assert.equal(generated.imageBase64, tinyPngBase64);
+    assert.equal(generated.mimeType, 'image/png');
+    assert.equal(captures.codexOptions[0].config.features.image_generation, true);
+    assert.deepEqual(captures.codexOptions[0].config.mcp_servers, {});
+    assert.equal(captures.threadOptions[0].sandboxMode, 'read-only');
+    assert.equal(captures.inputs[0][0].type, 'text');
+    assert.equal(captures.inputs[0][1].type, 'local_image');
+    assert.equal(await fs.stat(captures.inputs[0][1].path).then(() => true).catch(() => false), false);
+
+    let attempts = 0;
+    let loginCount = 0;
+    const authCaptures = { codexOptions: [], threadOptions: [], inputs: [] };
+    const authSdk = createFakeSdk(() => {
+        attempts += 1;
+        if (attempts === 1) {
+            return (async function* invalidAuth() {
+                throw new Error('401 Unauthorized: invalid_refresh_token. Please log out and sign in again.');
+            })();
+        }
+        return imageEvents();
+    }, authCaptures);
+    const authRuntime = createRuntime(authSdk, async () => {
+        loginCount += 1;
+        return { success: true, exitCode: 0 };
+    });
+    const retried = await authRuntime.runImage({ prompt: 'Create one test image.' });
+
+    assert.equal(loginCount, 1);
+    assert.equal(attempts, 2);
+    assert.equal(retried.success, true, retried.error);
+    assert.equal(retried.loginOpened, true);
+    assert.equal(retried.authenticationRequired, false);
+    assert.equal(retried.providerKind, 'TypeScriptSdk');
+
+    console.log(JSON.stringify({
+        ok: true,
+        providerKind: generated.providerKind,
+        referenceAttachment: true,
+        browserLoginRetry: true
+    }));
+} finally {
+    await fs.rm(runtimeHome, { recursive: true, force: true });
+}

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

@@ -1,89 +1,89 @@
-import assert from 'node:assert/strict';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { createCodexRuntime } from '../codex-runtime.js';
-
-const scriptDir = path.dirname(fileURLToPath(import.meta.url));
-const packageRoot = path.resolve(scriptDir, '..');
-const workspaceRoot = path.resolve(packageRoot, '..');
-const runLiveTurn = process.argv.includes('--live');
-const runLiveTools = process.argv.includes('--live-tools');
-
-const runtime = createCodexRuntime({
-    packageRoot,
-    resolveWorkingDirectory: async () => workspaceRoot,
-    getCurrentRuntime: () => ({}),
-    getModelCatalog: async () => ({
-        models: [],
-        source: 'smoke',
-        updatedAt: new Date().toISOString()
-    }),
-    log: () => {}
-});
-
-const capabilities = await runtime.getCapabilities();
-const sdkProvider = capabilities.providers.find(provider => provider.kind === 'TypeScriptSdk');
-assert.equal(sdkProvider?.available, true, sdkProvider?.error || 'Codex TypeScript SDK must be available.');
-assert.equal(capabilities.preferredProviderKind, 'TypeScriptSdk');
-
-const started = await runtime.startThread({
-    providerKind: 'TypeScriptSdk',
-    prompt: 'smoke',
-    workingDir: workspaceRoot,
-    sandbox: 'read_only',
-    approvalPolicy: 'on-request',
-    networkAccessEnabled: true,
-    webSearchMode: 'live'
-});
-assert.equal(started.success, true);
-assert.equal(started.providerKind, 'TypeScriptSdk');
-
-const status = runtime.getThreadStatus(started.threadId);
-assert.equal(status.providerKind, 'TypeScriptSdk');
-assert.equal(status.options.sandboxMode, 'read_only');
-assert.equal(status.options.networkAccessEnabled, true);
-assert.equal(status.options.webSearchMode, 'live');
-
-if (runLiveTurn) {
-    const marker = `CODEX_SDK_RUNTIME_OK_${Date.now()}`;
-    const result = await runtime.runThread({
-        providerKind: 'TypeScriptSdk',
-        prompt: `Return exactly this marker and nothing else: ${marker}`,
-        workingDir: workspaceRoot,
-        sandbox: 'read_only',
-        approvalPolicy: 'on-request',
-        networkAccessEnabled: false,
-        webSearchMode: 'disabled'
-    });
-
-    assert.equal(result.providerKind, 'TypeScriptSdk');
-    assert.equal(result.success, true, result.error || 'Codex SDK live turn failed.');
-    assert.match(result.finalResponse, new RegExp(marker));
-}
-
-if (runLiveTools) {
-    const result = await runtime.runThread({
-        providerKind: 'TypeScriptSdk',
-        prompt: 'Use the built-in web search tool to find the title of the official OpenAI Codex SDK documentation page. Return the title and its source URL.',
-        workingDir: workspaceRoot,
-        sandbox: 'read_only',
-        approvalPolicy: 'on-request',
-        networkAccessEnabled: true,
-        webSearchMode: 'live'
-    });
-
-    assert.equal(result.providerKind, 'TypeScriptSdk');
-    assert.equal(result.success, true, result.error || 'Codex SDK live tool turn failed.');
-    assert.equal(
-        result.toolEvents.some(event => event.type === 'web_search'),
-        true,
-        `Expected a web_search tool event, got: ${JSON.stringify(result.toolEvents)}`);
-}
-
-console.log(JSON.stringify({
-    ok: true,
-    providerKind: capabilities.preferredProviderKind,
-    sdkVersion: sdkProvider?.version || null,
-    liveTurn: runLiveTurn,
-    liveTools: runLiveTools
-}));
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createCodexRuntime } from '../codex-runtime.js';
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.resolve(scriptDir, '..');
+const workspaceRoot = path.resolve(packageRoot, '..');
+const runLiveTurn = process.argv.includes('--live');
+const runLiveTools = process.argv.includes('--live-tools');
+
+const runtime = createCodexRuntime({
+    packageRoot,
+    resolveWorkingDirectory: async () => workspaceRoot,
+    getCurrentRuntime: () => ({}),
+    getModelCatalog: async () => ({
+        models: [],
+        source: 'smoke',
+        updatedAt: new Date().toISOString()
+    }),
+    log: () => {}
+});
+
+const capabilities = await runtime.getCapabilities();
+const sdkProvider = capabilities.providers.find(provider => provider.kind === 'TypeScriptSdk');
+assert.equal(sdkProvider?.available, true, sdkProvider?.error || 'Codex TypeScript SDK must be available.');
+assert.equal(capabilities.preferredProviderKind, 'TypeScriptSdk');
+
+const started = await runtime.startThread({
+    providerKind: 'TypeScriptSdk',
+    prompt: 'smoke',
+    workingDir: workspaceRoot,
+    sandbox: 'read_only',
+    approvalPolicy: 'on-request',
+    networkAccessEnabled: true,
+    webSearchMode: 'live'
+});
+assert.equal(started.success, true);
+assert.equal(started.providerKind, 'TypeScriptSdk');
+
+const status = runtime.getThreadStatus(started.threadId);
+assert.equal(status.providerKind, 'TypeScriptSdk');
+assert.equal(status.options.sandboxMode, 'read_only');
+assert.equal(status.options.networkAccessEnabled, true);
+assert.equal(status.options.webSearchMode, 'live');
+
+if (runLiveTurn) {
+    const marker = `CODEX_SDK_RUNTIME_OK_${Date.now()}`;
+    const result = await runtime.runThread({
+        providerKind: 'TypeScriptSdk',
+        prompt: `Return exactly this marker and nothing else: ${marker}`,
+        workingDir: workspaceRoot,
+        sandbox: 'read_only',
+        approvalPolicy: 'on-request',
+        networkAccessEnabled: false,
+        webSearchMode: 'disabled'
+    });
+
+    assert.equal(result.providerKind, 'TypeScriptSdk');
+    assert.equal(result.success, true, result.error || 'Codex SDK live turn failed.');
+    assert.match(result.finalResponse, new RegExp(marker));
+}
+
+if (runLiveTools) {
+    const result = await runtime.runThread({
+        providerKind: 'TypeScriptSdk',
+        prompt: 'Use the built-in web search tool to find the title of the official OpenAI Codex SDK documentation page. Return the title and its source URL.',
+        workingDir: workspaceRoot,
+        sandbox: 'read_only',
+        approvalPolicy: 'on-request',
+        networkAccessEnabled: true,
+        webSearchMode: 'live'
+    });
+
+    assert.equal(result.providerKind, 'TypeScriptSdk');
+    assert.equal(result.success, true, result.error || 'Codex SDK live tool turn failed.');
+    assert.equal(
+        result.toolEvents.some(event => event.type === 'web_search'),
+        true,
+        `Expected a web_search tool event, got: ${JSON.stringify(result.toolEvents)}`);
+}
+
+console.log(JSON.stringify({
+    ok: true,
+    providerKind: capabilities.preferredProviderKind,
+    sdkVersion: sdkProvider?.version || null,
+    liveTurn: runLiveTurn,
+    liveTools: runLiveTools
+}));