@mintlify/cli 4.0.1654 → 4.0.1656

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mintlify/cli",
-  "version": "4.0.1654",
+  "version": "4.0.1656",
   "description": "The Mintlify CLI",
   "engines": {
     "node": ">=18.0.0"
@@ -45,13 +45,13 @@
   },
   "dependencies": {
     "@inquirer/prompts": "7.9.0",
-    "@mintlify/common": "1.0.1251",
-    "@mintlify/link-rot": "3.0.1472",
+    "@mintlify/common": "1.0.1252",
+    "@mintlify/link-rot": "3.0.1473",
     "@mintlify/models": "0.0.375",
-    "@mintlify/og": "0.0.49",
-    "@mintlify/prebuild": "1.0.1416",
-    "@mintlify/previewing": "4.0.1492",
-    "@mintlify/validation": "0.1.919",
+    "@mintlify/og": "0.0.50",
+    "@mintlify/prebuild": "1.0.1417",
+    "@mintlify/previewing": "4.0.1493",
+    "@mintlify/validation": "0.1.920",
     "adm-zip": "0.6.0",
     "chalk": "5.2.0",
     "color": "4.2.3",
@@ -79,14 +79,10 @@
     "zod": "4.3.6"
   },
   "optionalDependencies": {
-    "@anthropic-ai/claude-agent-sdk": "0.3.241",
-    "@anthropic-ai/sdk": "0.120.0",
-    "@modelcontextprotocol/sdk": "1.30.0",
-    "@openai/codex-sdk": "0.149.1",
     "keytar": "7.9.0"
   },
   "devDependencies": {
-    "@mintlify/editor": "0.0.510",
+    "@mintlify/editor": "0.0.511",
     "@mintlify/ts-config": "2.0.2",
     "@tsconfig/recommended": "1.0.2",
     "@types/detect-port": "1.3.2",
@@ -105,5 +101,5 @@
     "vitest": "2.1.9",
     "vitest-mock-process": "1.0.4"
   },
-  "gitHead": "eb7262d426ad3af6bed4bfb3bdcca1f01d7be5a1"
+  "gitHead": "ae1817e9de70256651892e22a38627b5b2a26ee8"
 }

package/src/cli.tsx

@@ -44,7 +44,6 @@ import { login } from './login.js';
 import { logout } from './logout.js';
 import { mdxLinter } from './mdxLinter.js';
 import { createTelemetryMiddleware } from './middlewares/telemetryMiddleware.js';
-import { mintTestHandler } from './mintTest.js';
 import { ogCommand } from './og.js';
 import {
   buildOverlayRegistryForCheck,
@@ -97,9 +96,7 @@ export const cli = ({ packageName = 'mint' }: { packageName?: string }) => {
   }
 
   const telemetryMiddleware = createTelemetryMiddleware();
-  if (commandArguments.find((argument) => !argument.startsWith('-')) !== 'test') {
-    render(<Logs />);
-  }
+  render(<Logs />);
 
   return (
     yargs(commandArguments)
@@ -267,14 +264,6 @@ export const cli = ({ packageName = 'mint' }: { packageName?: string }) => {
           );
         }
       )
-      .command(
-        'test',
-        'Test runnable code blocks with a local coding agent',
-        (yargs) => yargs.usage('usage: mint test'),
-        async () => {
-          await mintTestHandler();
-        }
-      )
       .command(
         'export',
         'Export a static site for air-gapped deployment',

package/__test__/mintTestFilePreview.test.ts

@@ -1,35 +0,0 @@
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-
-import { PREVIEW_BYTE_LIMIT, readFilePreview } from '../src/mintTestFilePreview.js';
-
-let temporaryDirectory: string;
-
-beforeEach(async () => {
-  temporaryDirectory = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-preview-'));
-});
-
-afterEach(async () => {
-  await fs.rm(temporaryDirectory, { recursive: true });
-});
-
-it('reads at most the preview limit plus the truncation marker byte', async () => {
-  const filePath = path.join(temporaryDirectory, 'large.txt');
-  await fs.writeFile(filePath, 'a'.repeat(PREVIEW_BYTE_LIMIT + 10_000));
-
-  const preview = await readFilePreview(filePath);
-
-  expect(preview).toEqual({
-    binary: false,
-    text: 'a'.repeat(PREVIEW_BYTE_LIMIT),
-    truncated: true,
-  });
-});
-
-it('rejects binary previews', async () => {
-  const filePath = path.join(temporaryDirectory, 'binary.dat');
-  await fs.writeFile(filePath, new Uint8Array([1, 0, 2]));
-
-  await expect(readFilePreview(filePath)).resolves.toEqual({ binary: true });
-});

package/__test__/mintTestOutput.test.ts

@@ -1,256 +0,0 @@
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-
-import { executeCodeBlocks } from '../src/agent-harness/executeCodeBlocks.js';
-import { generateTestCode } from '../src/agent-harness/generateTestCode.js';
-import type { GeneratedTask, TaskUpdate } from '../src/agent-harness/types.js';
-
-const agentMocks = vi.hoisted(() => ({ codexRun: vi.fn() }));
-
-vi.mock('../src/agent-harness/loadAgentSdk.js', () => ({
-  loadCodexSdk: vi.fn(async () => ({
-    Codex: class {
-      startThread() {
-        return { run: agentMocks.codexRun };
-      }
-    },
-  })),
-}));
-
-const temporaryDirectories: string[] = [];
-
-afterEach(async () => {
-  vi.clearAllMocks();
-  await Promise.all(
-    temporaryDirectories.splice(0).map((directory) => fs.rm(directory, { recursive: true }))
-  );
-});
-
-it('includes absolute generated file paths in updates and results', async () => {
-  const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-output-'));
-  temporaryDirectories.push(directory);
-  const generatedFile = path.join(directory, 'tests', 'generated.test.ts');
-  await fs.mkdir(path.dirname(generatedFile), { recursive: true });
-  await fs.writeFile(generatedFile, 'export const generated = true;\n');
-  const task: GeneratedTask = {
-    id: 'claude:guide.mdx',
-    agent: 'claude',
-    docsRoot: directory,
-    file: 'guide.mdx',
-    directory,
-    attempts: 1,
-    tokens: 10,
-    testable: true,
-    manifest: {
-      version: 1,
-      generatedFiles: ['tests/generated.test.ts'],
-      setupCommands: [],
-      testCommands: [],
-    },
-  };
-  const updates: TaskUpdate[] = [];
-
-  const results = await executeCodeBlocks({
-    tasks: [task],
-    docsRoot: directory,
-    concurrency: 1,
-    commandTimeoutMs: 1_000,
-    signal: new AbortController().signal,
-    onTaskUpdate: (update) => updates.push(update),
-  });
-
-  expect(results).toHaveLength(1);
-  expect(results[0]?.generatedFiles).toEqual([generatedFile]);
-  expect(updates.map((update) => update.generatedFiles)).toEqual([
-    [generatedFile],
-    [generatedFile],
-  ]);
-});
-
-it('includes partial generated files when generation fails', async () => {
-  const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-output-'));
-  temporaryDirectories.push(directory);
-  const generatedFile = path.join(directory, 'tests', 'partial.test.ts');
-  await fs.mkdir(path.dirname(generatedFile), { recursive: true });
-  await fs.writeFile(path.join(directory, 'package.json'), '{}\n');
-  agentMocks.codexRun.mockImplementation(async () => {
-    await fs.writeFile(generatedFile, 'export const partial = true;\n');
-    throw new Error('generation failed');
-  });
-  const updates: TaskUpdate[] = [];
-  const onGenerationResult = vi.fn();
-
-  const generated = await generateTestCode({
-    tasks: [generatedTask(directory)],
-    docsRoot: directory,
-    model: 'unused',
-    concurrency: 1,
-    signal: new AbortController().signal,
-    onTaskUpdate: (update) => updates.push(update),
-    onGenerationResult,
-  });
-
-  expect(updates.at(-1)).toMatchObject({
-    phase: 'agent_error',
-    generatedFiles: [generatedFile],
-  });
-  expect(onGenerationResult).toHaveBeenCalledWith({
-    status: 'failed',
-    agent: 'codex',
-    model: 'unused',
-    attemptCount: 2,
-    tokenCount: 0,
-    durationMs: expect.any(Number),
-    generatedFileCount: 1,
-  });
-  const results = await executeCodeBlocks({
-    tasks: generated,
-    docsRoot: directory,
-    concurrency: 1,
-    commandTimeoutMs: 1_000,
-    signal: new AbortController().signal,
-    onTaskUpdate: (update) => updates.push(update),
-  });
-  expect(results[0]?.generatedFiles).toEqual([generatedFile]);
-  expect(updates.at(-1)).toMatchObject({
-    phase: 'agent_error',
-    generatedFiles: [generatedFile],
-  });
-});
-
-it('reports a successful generation run', async () => {
-  const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-output-'));
-  temporaryDirectories.push(directory);
-  const generatedFile = path.join(directory, 'tests', 'generated.test.ts');
-  await fs.mkdir(path.dirname(generatedFile), { recursive: true });
-  await fs.writeFile(path.join(directory, 'package.json'), '{}\n');
-  agentMocks.codexRun.mockImplementation(async () => {
-    await fs.writeFile(generatedFile, 'export const generated = true;\n');
-    await fs.writeFile(
-      path.join(directory, 'mint-test.json'),
-      `${JSON.stringify({
-        version: 1,
-        generatedFiles: ['tests/generated.test.ts'],
-        setupCommands: [],
-        testCommands: [],
-      })}\n`
-    );
-    return {
-      finalResponse: 'done',
-      usage: {
-        input_tokens: 100,
-        cached_input_tokens: 25,
-        cache_write_input_tokens: 10,
-        output_tokens: 50,
-        reasoning_output_tokens: 15,
-      },
-    };
-  });
-  const onGenerationResult = vi.fn();
-
-  await generateTestCode({
-    tasks: [generatedTask(directory)],
-    docsRoot: directory,
-    model: 'gpt-test',
-    concurrency: 1,
-    signal: new AbortController().signal,
-    onTaskUpdate: () => {},
-    onGenerationResult,
-  });
-
-  expect(onGenerationResult).toHaveBeenCalledWith({
-    status: 'succeeded',
-    agent: 'codex',
-    model: 'gpt-test',
-    attemptCount: 1,
-    tokenCount: 200,
-    durationMs: expect.any(Number),
-    generatedFileCount: 1,
-  });
-});
-
-it('includes partial generated files when generation is cancelled', async () => {
-  const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-output-'));
-  temporaryDirectories.push(directory);
-  const generatedFile = path.join(directory, 'tests', 'partial.test.ts');
-  await fs.mkdir(path.dirname(generatedFile), { recursive: true });
-  const controller = new AbortController();
-  agentMocks.codexRun.mockImplementation(async () => {
-    await fs.writeFile(generatedFile, 'export const partial = true;\n');
-    controller.abort();
-    throw new Error('cancelled');
-  });
-  const updates: TaskUpdate[] = [];
-
-  const generated = await generateTestCode({
-    tasks: [generatedTask(directory)],
-    docsRoot: directory,
-    model: 'unused',
-    concurrency: 1,
-    signal: controller.signal,
-    onTaskUpdate: (update) => updates.push(update),
-  });
-
-  expect(updates.at(-1)).toMatchObject({
-    phase: 'cancelled',
-    generatedFiles: [generatedFile],
-  });
-  const results = await executeCodeBlocks({
-    tasks: generated,
-    docsRoot: directory,
-    concurrency: 1,
-    commandTimeoutMs: 1_000,
-    signal: controller.signal,
-    onTaskUpdate: (update) => updates.push(update),
-  });
-  expect(results[0]?.generatedFiles).toEqual([generatedFile]);
-  expect(updates.at(-1)).toMatchObject({
-    phase: 'cancelled',
-    generatedFiles: [generatedFile],
-  });
-});
-
-it.each([
-  { outcome: 'fails', aborted: false, status: 'agent_error', error: 'generation failed' },
-  { outcome: 'is cancelled', aborted: true, status: 'cancelled', error: 'run cancelled' },
-] as const)(
-  'forwards partial generated files through execution when generation $outcome',
-  async ({ aborted, status, error }) => {
-    const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-output-'));
-    temporaryDirectories.push(directory);
-    const generatedFile = path.join(directory, 'tests', 'partial.test.ts');
-    const controller = new AbortController();
-    if (aborted) controller.abort();
-    const updates: TaskUpdate[] = [];
-
-    const results = await executeCodeBlocks({
-      tasks: [{ ...generatedTask(directory), error, generatedFiles: [generatedFile] }],
-      docsRoot: directory,
-      concurrency: 1,
-      commandTimeoutMs: 1_000,
-      signal: controller.signal,
-      onTaskUpdate: (update) => updates.push(update),
-    });
-
-    expect(results).toEqual([
-      expect.objectContaining({ status, error, generatedFiles: [generatedFile], commands: [] }),
-    ]);
-    expect(updates).toEqual([
-      expect.objectContaining({ phase: status, generatedFiles: [generatedFile] }),
-    ]);
-  }
-);
-
-function generatedTask(directory: string): GeneratedTask {
-  return {
-    id: 'codex:guide.mdx',
-    agent: 'codex',
-    docsRoot: directory,
-    file: 'guide.mdx',
-    directory,
-    attempts: 0,
-    tokens: 0,
-    testable: true,
-  };
-}

package/__test__/runHistory.test.ts

@@ -1,240 +0,0 @@
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-
-import {
-  loadLatestTestRun,
-  loadTestRuns,
-  recordTestRun,
-  testRunReportPath,
-  testRunsIndexPath,
-  writeTestRunHistory,
-} from '../src/agent-harness/runHistory.js';
-import type { CodeTestReport } from '../src/agent-harness/types.js';
-
-const temporaryDirectories: string[] = [];
-
-afterEach(async () => {
-  vi.restoreAllMocks();
-  vi.unstubAllGlobals();
-  await Promise.all(
-    temporaryDirectories.splice(0).map((directory) => fs.rm(directory, { recursive: true }))
-  );
-});
-
-function makeReport(docsRoot: string, runId: string, completedAt: string): CodeTestReport {
-  return {
-    version: 1,
-    runId,
-    status: 'passed',
-    docsRoot,
-    outputDirectory: path.join(docsRoot, 'tests', 'mint-test', runId),
-    reportPath: testRunReportPath(docsRoot, runId),
-    agents: ['claude'],
-    model: 'claude-opus-4-8',
-    selectedFiles: ['guide.mdx'],
-    startedAt: '2026-09-01T12:00:00.000Z',
-    completedAt,
-    durationMs: 1_000,
-    tasks: [
-      {
-        id: 'claude:guide.mdx',
-        agent: 'claude',
-        file: 'guide.mdx',
-        directory: path.join(docsRoot, 'tests', 'mint-test', runId, 'claude', '001-guide'),
-        generatedFiles: [
-          path.join(
-            docsRoot,
-            'tests',
-            'mint-test',
-            runId,
-            'claude',
-            '001-guide',
-            'tests',
-            'guide.test.ts'
-          ),
-        ],
-        testable: true,
-        attempts: 1,
-        tokens: 100,
-        status: 'passed',
-        commands: [],
-      },
-    ],
-  };
-}
-
-it('stores each result and tracks every run in newest-first order', async () => {
-  const docsRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-history-'));
-  temporaryDirectories.push(docsRoot);
-  const first = makeReport(docsRoot, '20260901120000-first', '2026-09-01T12:00:01.000Z');
-  const second = makeReport(docsRoot, '20260901130000-second', '2026-09-01T13:00:01.000Z');
-
-  await writeTestRunHistory(docsRoot, first);
-  await writeTestRunHistory(docsRoot, second);
-
-  expect(JSON.parse(await fs.readFile(testRunReportPath(docsRoot, first.runId), 'utf8'))).toEqual(
-    first
-  );
-  const index = await loadTestRuns(docsRoot);
-  expect(index.runs.map((run) => run.runId)).toEqual([second.runId, first.runId]);
-  expect(index.runs[0]?.counts).toEqual({
-    passed: 1,
-    failed: 0,
-    cancelled: 0,
-    agentErrors: 0,
-  });
-  await expect(loadLatestTestRun(docsRoot)).resolves.toEqual(second);
-});
-
-it('rebuilds testRuns.json data from saved run results', async () => {
-  const docsRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-history-'));
-  temporaryDirectories.push(docsRoot);
-  const report = makeReport(docsRoot, '20260901120000-rebuild', '2026-09-01T12:00:01.000Z');
-  await writeTestRunHistory(docsRoot, report);
-  await fs.unlink(testRunsIndexPath(docsRoot));
-
-  const rebuilt = await loadTestRuns(docsRoot);
-
-  expect(rebuilt.runs).toHaveLength(1);
-  expect(rebuilt.runs[0]?.runId).toBe(report.runId);
-});
-
-it('keeps every run when history writes overlap', async () => {
-  const docsRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-history-'));
-  temporaryDirectories.push(docsRoot);
-  const reports = Array.from({ length: 12 }, (_, index) =>
-    makeReport(
-      docsRoot,
-      `20260901120000-concurrent-${index}`,
-      `2026-09-01T12:00:${String(index).padStart(2, '0')}.000Z`
-    )
-  );
-
-  await Promise.all(reports.map((report) => writeTestRunHistory(docsRoot, report)));
-
-  const index = JSON.parse(await fs.readFile(testRunsIndexPath(docsRoot), 'utf8')) as {
-    runs: Array<{ runId: string }>;
-  };
-  expect(index.runs.map((run) => run.runId).sort()).toEqual(
-    reports.map((report) => report.runId).sort()
-  );
-}, 60_000);
-
-it('retries a temporarily unavailable Windows history lock', async () => {
-  vi.stubGlobal('process', { ...process, platform: 'win32' });
-  const docsRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-history-'));
-  temporaryDirectories.push(docsRoot);
-  const report = makeReport(docsRoot, 'windows-retry', '2026-09-01T12:00:01.000Z');
-  const open = vi
-    .spyOn(fs, 'open')
-    .mockRejectedValueOnce(Object.assign(new Error('Lock deletion pending'), { code: 'EPERM' }));
-
-  await writeTestRunHistory(docsRoot, report);
-
-  expect(open).toHaveBeenCalledTimes(2);
-  expect(open).toHaveBeenNthCalledWith(
-    2,
-    path.join(docsRoot, '.mintlify/test/testRuns.lock'),
-    'wx'
-  );
-  expect(JSON.parse(await fs.readFile(testRunsIndexPath(docsRoot), 'utf8'))).toMatchObject({
-    runs: [{ runId: report.runId }],
-  });
-  await expect(
-    fs.access(path.join(docsRoot, '.mintlify/test/testRuns.lock'))
-  ).rejects.toMatchObject({
-    code: 'ENOENT',
-  });
-});
-
-it.each([
-  ['linux', 'EPERM'],
-  ['win32', 'EACCES'],
-])('propagates %s lock acquisition errors with code %s', async (platform, code) => {
-  vi.stubGlobal('process', { ...process, platform });
-  const docsRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-history-'));
-  temporaryDirectories.push(docsRoot);
-  const report = makeReport(docsRoot, 'denied', '2026-09-01T12:00:01.000Z');
-  const error = Object.assign(new Error('Permission denied'), { code });
-  const open = vi.spyOn(fs, 'open').mockRejectedValue(error);
-
-  await expect(writeTestRunHistory(docsRoot, report)).rejects.toBe(error);
-  expect(open).toHaveBeenCalledTimes(1);
-});
-
-it('stops retrying a Windows lock at the acquisition deadline', async () => {
-  vi.stubGlobal('process', { ...process, platform: 'win32' });
-  const docsRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-history-'));
-  temporaryDirectories.push(docsRoot);
-  const report = makeReport(docsRoot, 'timeout', '2026-09-01T12:00:01.000Z');
-  vi.spyOn(fs, 'open').mockRejectedValue(
-    Object.assign(new Error('Permission denied'), { code: 'EPERM' })
-  );
-  vi.spyOn(Date, 'now').mockReturnValueOnce(0).mockReturnValueOnce(0).mockReturnValue(40_000);
-
-  await expect(writeTestRunHistory(docsRoot, report)).rejects.toThrow(
-    'Timed out updating mint test run history'
-  );
-});
-
-it('does not retry a token write failure after acquiring the Windows lock', async () => {
-  vi.stubGlobal('process', { ...process, platform: 'win32' });
-  const docsRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-history-'));
-  temporaryDirectories.push(docsRoot);
-  const report = makeReport(docsRoot, 'token-failure', '2026-09-01T12:00:01.000Z');
-  const error = Object.assign(new Error('Cannot write token'), { code: 'EPERM' });
-  const realOpen = fs.open;
-  const open = vi.spyOn(fs, 'open').mockImplementationOnce(async (...args) => {
-    const handle = await realOpen(...args);
-    vi.spyOn(handle, 'writeFile').mockRejectedValueOnce(error);
-    return handle;
-  });
-
-  await expect(writeTestRunHistory(docsRoot, report)).rejects.toBe(error);
-  expect(open).toHaveBeenCalledTimes(1);
-});
-
-it('recovers a stale history lock left by an interrupted process', async () => {
-  const docsRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-history-'));
-  temporaryDirectories.push(docsRoot);
-  const historyDirectory = path.join(docsRoot, '.mintlify', 'test');
-  const lockPath = path.join(historyDirectory, 'testRuns.lock');
-  await fs.mkdir(historyDirectory, { recursive: true });
-  await fs.writeFile(lockPath, 'interrupted-process');
-  const staleTime = new Date(Date.now() - 31_000);
-  await fs.utimes(lockPath, staleTime, staleTime);
-  const report = makeReport(docsRoot, '20260901120000-after-crash', '2026-09-01T12:00:01.000Z');
-
-  await writeTestRunHistory(docsRoot, report);
-
-  await expect(fs.access(lockPath)).rejects.toMatchObject({ code: 'ENOENT' });
-  await expect(loadLatestTestRun(docsRoot)).resolves.toEqual(report);
-});
-
-it('returns the report as-is when history is saved', async () => {
-  const docsRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-history-'));
-  temporaryDirectories.push(docsRoot);
-  const report = makeReport(docsRoot, '20260901120000-saved', '2026-09-01T12:00:01.000Z');
-  const fallbackReportPath = path.join(report.outputDirectory, 'report.json');
-
-  await expect(recordTestRun(docsRoot, report, fallbackReportPath)).resolves.toBe(report);
-  await expect(loadLatestTestRun(docsRoot)).resolves.toEqual(report);
-});
-
-it('keeps a finished run usable when history cannot be saved', async () => {
-  const docsRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-history-'));
-  temporaryDirectories.push(docsRoot);
-  await fs.mkdir(path.join(docsRoot, '.mintlify'), { recursive: true });
-  await fs.writeFile(path.join(docsRoot, '.mintlify', 'test'), 'blocks the history directory\n');
-  const report = makeReport(docsRoot, '20260901120000-unsaved', '2026-09-01T12:00:01.000Z');
-  const fallbackReportPath = path.join(report.outputDirectory, 'report.json');
-
-  const recorded = await recordTestRun(docsRoot, report, fallbackReportPath);
-
-  expect(recorded).toEqual({
-    ...report,
-    reportPath: fallbackReportPath,
-    historyError: expect.stringContaining('run history could not be saved: '),
-  });
-});

package/bin/agent-harness/agentPreflight.js

@@ -1,24 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { loadClaudeAgentSdk, loadCodexSdk } from './loadAgentSdk.js';
-/**
- * Fail fast, before any page is checked, when an agent SDK is not installed. Without this every
- * page reports the same missing-dependency error minutes later as "test could not be generated".
- */
-export function ensureAgentSdks(agents) {
-    return __awaiter(this, void 0, void 0, function* () {
-        for (const agent of new Set(agents)) {
-            if (agent === 'claude')
-                yield loadClaudeAgentSdk();
-            else
-                yield loadCodexSdk();
-        }
-    });
-}