@mintlify/cli 4.0.1812 → 4.1.1

package/__test__/agent-deployment.test.ts

@@ -1,106 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-import { getAgentWriteToken, provisionAgentSite } from '../src/agent-deployment.js';
-
-vi.mock('node:timers/promises', () => ({ setTimeout: vi.fn().mockResolvedValue(undefined) }));
-const ready = {
-  status: 'ready',
-  deploymentId: 'deployment',
-  subdomain: 'actual-name',
-  remote: 'https://git.example.com/repo.git',
-  branch: 'main',
-  expiresAt: '2026-12-01T00:00:00.000Z',
-};
-const existing = { ...ready, code: 'deployment_already_exists' };
-const provision = () =>
-  provisionAgentSite('https://api.example.com', 'access', {
-    subdomain: 'requested',
-    orgName: 'Docs',
-  });
-function response(body: unknown, status: number) {
-  return new Response(JSON.stringify(body), { status });
-}
-afterEach(() => vi.unstubAllGlobals());
-
-describe('agent deployment API', () => {
-  it('sends root content layout and uses the allocated subdomain', async () => {
-    const request = vi.fn().mockResolvedValue(response(ready, 201));
-    vi.stubGlobal('fetch', request);
-    expect(await provision()).toEqual({ ...ready, created: true });
-    expect(JSON.parse(request.mock.calls[0]?.[1].body)).toEqual({
-      subdomain: 'requested',
-      orgName: 'Docs',
-      docsPath: '',
-    });
-  });
-  it('requests a base when the project type is workspace', async () => {
-    const request = vi.fn().mockResolvedValue(response({ ...ready, orgSlug: 'acme' }, 201));
-    vi.stubGlobal('fetch', request);
-    expect(
-      await provisionAgentSite('https://api.example.com', 'access', {
-        subdomain: 'requested',
-        projectType: 'workspace',
-      })
-    ).toEqual({ ...ready, orgSlug: 'acme', created: true });
-    expect(JSON.parse(request.mock.calls[0]?.[1].body)).toEqual({
-      subdomain: 'requested',
-      projectType: 'workspace',
-      docsPath: '',
-    });
-  });
-  it('returns an existing site as an update, not a new creation', async () => {
-    vi.stubGlobal('fetch', vi.fn().mockResolvedValue(response(existing, 409)));
-    expect(await provision()).toEqual({ ...existing, created: false });
-  });
-  it('retries provisioning even when no deployment ID exists yet', async () => {
-    const request = vi
-      .fn()
-      .mockResolvedValueOnce(response({ status: 'provisioning', code: existing.code }, 409))
-      .mockResolvedValueOnce(response(existing, 409));
-    vi.stubGlobal('fetch', request);
-    expect((await provision()).status).toBe('ready');
-    expect(request).toHaveBeenCalledTimes(2);
-  });
-  it('bounds provisioning retries', async () => {
-    const request = vi
-      .fn()
-      .mockImplementation(async () =>
-        response({ status: 'provisioning', code: existing.code }, 409)
-      );
-    vi.stubGlobal('fetch', request);
-    await expect(provision()).rejects.toThrow('still provisioning');
-    expect(request).toHaveBeenCalledTimes(4);
-  });
-  it('distinguishes confirmed expiry from upstream failure', async () => {
-    const request = vi
-      .fn()
-      .mockResolvedValueOnce(response({ ...existing, status: 'expired' }, 409))
-      .mockResolvedValueOnce(response({ error: 'unavailable' }, 503));
-    vi.stubGlobal('fetch', request);
-    expect((await provision()).status).toBe('expired');
-    await expect(provision()).rejects.toThrow('503');
-  });
-  it('treats a swept registration as expired', async () => {
-    const swept = {
-      created: false,
-      code: 'deployment_claim_expired',
-      status: 'expired',
-      deploymentId: 'deployment',
-      subdomain: 'actual-name',
-    };
-    vi.stubGlobal('fetch', vi.fn().mockResolvedValue(response(swept, 409)));
-    expect(await provision()).toEqual(swept);
-  });
-  it('requests a write token without a caller-selected deployment', async () => {
-    const credential = {
-      remote: ready.remote,
-      branch: 'main',
-      token: 'write-secret',
-      tokenExpiresAt: ready.expiresAt,
-    };
-    const request = vi.fn().mockResolvedValue(response(credential, 200));
-    vi.stubGlobal('fetch', request);
-    expect(await getAgentWriteToken('https://api.example.com', 'access')).toEqual(credential);
-    expect(request.mock.calls[0]?.[1].body).toBeUndefined();
-  });
-});

package/__test__/agent-setup-config.test.ts

@@ -1,324 +0,0 @@
-import { parse as parseJsonc } from 'jsonc-parser';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { parse as parseToml } from 'smol-toml';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-
-import {
-  ADMIN_MCP_NAME,
-  ADMIN_MCP_URL,
-  prepareMcpConfig,
-  writeMcpConfig,
-  type SetupAgent,
-} from '../src/agent-setup-config.js';
-
-let directory: string;
-let cwd: string;
-let homeDir: string;
-
-const projectPaths: [SetupAgent, string][] = [
-  ['claude-code', '.mcp.json'],
-  ['codex', '.codex/config.toml'],
-  ['cursor', '.cursor/mcp.json'],
-];
-
-const globalPaths: [SetupAgent, string][] = [
-  ['claude-code', '.claude.json'],
-  ['codex', '.codex/config.toml'],
-  ['cursor', '.cursor/mcp.json'],
-];
-
-function options(global = false, env: NodeJS.ProcessEnv = {}) {
-  return { cwd, homeDir, global, env };
-}
-
-async function fixture(filePath: string, contents: string) {
-  await fs.mkdir(path.dirname(filePath), { recursive: true });
-  await fs.writeFile(filePath, contents);
-}
-
-beforeEach(async () => {
-  directory = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-agent-setup-config-'));
-  cwd = path.join(directory, 'project');
-  homeDir = path.join(directory, 'home');
-  await fs.mkdir(cwd);
-  await fs.mkdir(homeDir);
-});
-
-afterEach(async () => {
-  await fs.rm(directory, { recursive: true, force: true });
-});
-
-describe('agent setup MCP configuration', () => {
-  it.each(projectPaths)(
-    'prepares project configuration for %s without writing it',
-    async (agent, relativePath) => {
-      const plan = await prepareMcpConfig(agent, options());
-
-      expect(plan.path).toBe(path.join(cwd, relativePath));
-      expect(plan.original).toBeUndefined();
-      expect(plan.contents).toEqual(expect.any(String));
-      await expect(fs.readFile(plan.path, 'utf8')).rejects.toThrow();
-
-      if (plan.contents === undefined) throw new Error('Missing prepared configuration');
-      if (agent === 'codex') {
-        expect(parseToml(plan.contents)).toMatchObject({
-          mcp_servers: { [ADMIN_MCP_NAME]: { url: ADMIN_MCP_URL } },
-        });
-        return;
-      }
-
-      const expectedServer: { url: string; type?: string } = { url: ADMIN_MCP_URL };
-      if (agent === 'claude-code') expectedServer.type = 'http';
-      expect(parseJsonc(plan.contents)).toEqual({
-        mcpServers: { [ADMIN_MCP_NAME]: expectedServer },
-      });
-    }
-  );
-
-  it.each(globalPaths)(
-    'uses the user configuration path for global %s setup',
-    async (agent, relativePath) => {
-      const plan = await prepareMcpConfig(agent, options(true));
-
-      expect(plan.path).toBe(path.join(homeDir, relativePath));
-      expect(plan.original).toBeUndefined();
-      expect(plan.contents).toContain(ADMIN_MCP_URL);
-    }
-  );
-
-  it('honors CODEX_HOME for global setup while retaining project scope', async () => {
-    const codexHome = path.join(directory, 'custom-codex');
-    const env = { CODEX_HOME: codexHome };
-
-    const globalPlan = await prepareMcpConfig('codex', options(true, env));
-    const projectPlan = await prepareMcpConfig('codex', options(false, env));
-
-    expect(globalPlan.path).toBe(path.join(codexHome, 'config.toml'));
-    expect(projectPlan.path).toBe(path.join(cwd, '.codex/config.toml'));
-  });
-
-  it('refuses an unsupported Claude global directory without blocking project setup', async () => {
-    const env = { CLAUDE_CONFIG_DIR: path.join(directory, 'custom-claude') };
-
-    await expect(prepareMcpConfig('claude-code', options(true, env))).rejects.toThrow();
-    const projectPlan = await prepareMcpConfig('claude-code', options(false, env));
-    expect(projectPlan.path).toBe(path.join(cwd, '.mcp.json'));
-  });
-
-  it.each(['claude-code', 'cursor'])(
-    'preserves JSONC comments, trailing commas, and other %s settings',
-    async (client) => {
-      const agent = projectPaths.find(([name]) => name === client);
-      if (agent === undefined) throw new Error('Missing test agent');
-      const [name, relativePath] = agent;
-      const original = `{
-  // Personal preferences
-  "theme": "dark",
-  "mcpServers": {
-    "other": { "url": "https://example.com/mcp", },
-  },
-}
-`;
-      await fixture(path.join(cwd, relativePath), original);
-
-      const plan = await prepareMcpConfig(name, options());
-
-      expect(plan.original).toBe(original);
-      expect(plan.contents).toContain('// Personal preferences');
-      if (plan.contents === undefined) throw new Error('Missing prepared configuration');
-      expect(parseJsonc(plan.contents)).toMatchObject({
-        theme: 'dark',
-        mcpServers: {
-          other: { url: 'https://example.com/mcp' },
-          [ADMIN_MCP_NAME]: { url: ADMIN_MCP_URL },
-        },
-      });
-      expect(await fs.readFile(plan.path, 'utf8')).toBe(original);
-    }
-  );
-
-  it('appends Codex settings while preserving existing TOML text and tables', async () => {
-    const original =
-      '# Personal preferences\nmodel = "example-model"\n\n[mcp_servers.other]\nurl = "https://example.com/mcp"\n';
-    await fixture(path.join(cwd, '.codex/config.toml'), original);
-
-    const plan = await prepareMcpConfig('codex', options());
-
-    expect(plan.original).toBe(original);
-    expect(plan.contents?.startsWith(original)).toBe(true);
-    if (plan.contents === undefined) throw new Error('Missing prepared configuration');
-    expect(parseToml(plan.contents)).toMatchObject({
-      model: 'example-model',
-      mcp_servers: {
-        other: { url: 'https://example.com/mcp' },
-        [ADMIN_MCP_NAME]: { url: ADMIN_MCP_URL },
-      },
-    });
-  });
-
-  it.each(['claude-code', 'cursor'])(
-    'skips a matching %s server without changing extra fields',
-    async (client) => {
-      const agent = projectPaths.find(([name]) => name === client);
-      if (agent === undefined) throw new Error('Missing test agent');
-      const [name, relativePath] = agent;
-      const original = JSON.stringify({
-        mcpServers: {
-          [ADMIN_MCP_NAME]: {
-            url: ADMIN_MCP_URL,
-            type: 'http',
-            disabled: true,
-            headers: { Example: 'value' },
-          },
-        },
-      });
-      await fixture(path.join(cwd, relativePath), original);
-
-      const plan = await prepareMcpConfig(name, options());
-
-      expect(plan.original).toBe(original);
-      expect(plan.contents).toBeUndefined();
-      await writeMcpConfig(plan);
-      expect(await fs.readFile(plan.path, 'utf8')).toBe(original);
-    }
-  );
-
-  it('refuses to extend an inline Codex mcp_servers table', async () => {
-    const original = 'mcp_servers = { other = { url = "https://example.com/mcp" } }\n';
-    await fixture(path.join(cwd, '.codex/config.toml'), original);
-
-    await expect(prepareMcpConfig('codex', options())).rejects.toThrow(
-      `Add a ${ADMIN_MCP_NAME} entry with url = "${ADMIN_MCP_URL}" to mcp_servers manually.`
-    );
-    expect(await fs.readFile(path.join(cwd, '.codex/config.toml'), 'utf8')).toBe(original);
-  });
-
-  it('skips a matching Codex server without enabling or rewriting it', async () => {
-    const original = `[mcp_servers.${ADMIN_MCP_NAME}]\nurl = "${ADMIN_MCP_URL}"\nenabled = false\nstartup_timeout_sec = 20\n`;
-    await fixture(path.join(cwd, '.codex/config.toml'), original);
-
-    const plan = await prepareMcpConfig('codex', options());
-
-    expect(plan.original).toBe(original);
-    expect(plan.contents).toBeUndefined();
-    await writeMcpConfig(plan);
-    expect(await fs.readFile(plan.path, 'utf8')).toBe(original);
-  });
-
-  it.each([undefined, 'stdio'])('rejects an invalid Claude server transport %s', async (type) => {
-    const original = JSON.stringify({
-      mcpServers: { [ADMIN_MCP_NAME]: { url: ADMIN_MCP_URL, type } },
-    });
-    await fixture(path.join(cwd, '.mcp.json'), original);
-
-    await expect(prepareMcpConfig('claude-code', options())).rejects.toThrow('type');
-    expect(await fs.readFile(path.join(cwd, '.mcp.json'), 'utf8')).toBe(original);
-  });
-
-  it('detects changes to a server that was already configured', async () => {
-    const original = `[mcp_servers.${ADMIN_MCP_NAME}]\nurl = "${ADMIN_MCP_URL}"\n`;
-    const filePath = path.join(cwd, '.codex/config.toml');
-    await fixture(filePath, original);
-    const plan = await prepareMcpConfig('codex', options());
-    await fs.writeFile(filePath, '# Changed during installation\n');
-
-    await expect(writeMcpConfig(plan)).rejects.toThrow('changed during setup');
-    expect(await fs.readFile(filePath, 'utf8')).toBe('# Changed during installation\n');
-  });
-
-  it.each([
-    { url: 'https://example.com/different' },
-    { command: 'example-server', args: ['serve'] },
-  ])('refuses a conflicting JSON server %j', async (server) => {
-    for (const [agent, relativePath] of projectPaths) {
-      if (agent === 'codex') continue;
-      const original = JSON.stringify({ mcpServers: { [ADMIN_MCP_NAME]: server } });
-      const filePath = path.join(cwd, relativePath);
-      await fixture(filePath, original);
-
-      await expect(prepareMcpConfig(agent, options())).rejects.toThrow();
-      expect(await fs.readFile(filePath, 'utf8')).toBe(original);
-    }
-  });
-
-  it.each([
-    `url = "https://example.com/different"`,
-    `command = "example-server"\nargs = ["serve"]`,
-  ])('refuses a conflicting Codex server with %s', async (server) => {
-    const original = `[mcp_servers.${ADMIN_MCP_NAME}]\n${server}\n`;
-    const filePath = path.join(cwd, '.codex/config.toml');
-    await fixture(filePath, original);
-
-    await expect(prepareMcpConfig('codex', options())).rejects.toThrow();
-    expect(await fs.readFile(filePath, 'utf8')).toBe(original);
-  });
-
-  it.each(['{', '[]', '{"mcpServers": []}', '{"mcpServers": null}'])(
-    'rejects malformed or incompatible JSON configuration %s',
-    async (original) => {
-      const filePath = path.join(cwd, '.cursor/mcp.json');
-      await fixture(filePath, original);
-
-      await expect(prepareMcpConfig('cursor', options())).rejects.toThrow();
-      expect(await fs.readFile(filePath, 'utf8')).toBe(original);
-    }
-  );
-
-  it.each([
-    '[mcp_servers\n',
-    'mcp_servers = "example"\n',
-    'mcp_servers = { other = { url = "https://example.com/mcp" } }\n',
-  ])('rejects malformed or incompatible TOML configuration %s', async (original) => {
-    const filePath = path.join(cwd, '.codex/config.toml');
-    await fixture(filePath, original);
-
-    await expect(prepareMcpConfig('codex', options())).rejects.toThrow();
-    expect(await fs.readFile(filePath, 'utf8')).toBe(original);
-  });
-
-  it.each([0o640, 0o664])(
-    'writes the prepared contents while preserving permissions %i',
-    async (mode) => {
-      const filePath = path.join(cwd, '.mcp.json');
-      await fixture(filePath, '{"theme":"dark"}\n');
-      await fs.chmod(filePath, mode);
-      const plan = await prepareMcpConfig('claude-code', options());
-
-      await writeMcpConfig(plan);
-
-      expect(await fs.readFile(filePath, 'utf8')).toBe(plan.contents);
-      if (process.platform !== 'win32') expect((await fs.stat(filePath)).mode & 0o777).toBe(mode);
-      const rerun = await prepareMcpConfig('claude-code', options());
-      expect(rerun.contents).toBeUndefined();
-    }
-  );
-
-  it.each([false, true])(
-    'refuses configuration drift when an original file existed: %s',
-    async (existing) => {
-      const filePath = path.join(cwd, '.mcp.json');
-      if (existing) await fixture(filePath, '{}\n');
-      const plan = await prepareMcpConfig('claude-code', options());
-      const changed = '{"theme":"new-preference"}\n';
-      await fixture(filePath, changed);
-
-      await expect(writeMcpConfig(plan)).rejects.toThrow();
-      expect(await fs.readFile(filePath, 'utf8')).toBe(changed);
-    }
-  );
-
-  it('refuses to replace a configuration symlink or change its target', async () => {
-    const filePath = path.join(cwd, '.mcp.json');
-    const targetPath = path.join(directory, 'shared-config.json');
-    const original = '{"theme":"shared"}\n';
-    await fixture(targetPath, original);
-    const plan = await prepareMcpConfig('claude-code', options());
-    await fs.symlink(targetPath, filePath);
-
-    await expect(writeMcpConfig(plan)).rejects.toThrow();
-    expect((await fs.lstat(filePath)).isSymbolicLink()).toBe(true);
-    expect(await fs.readFile(targetPath, 'utf8')).toBe(original);
-  });
-});

package/__test__/agent-setup.test.ts

@@ -1,207 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { parse as parseToml } from 'smol-toml';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { installSkills, setupAgent } from '../src/agent-setup.js';
-
-let directory: string;
-let argumentsFile: string;
-let project: string;
-const originalIsTTY = process.stdin.isTTY;
-
-function executablePath(command: string): string {
-  const extension = process.platform === 'win32' ? '.cmd' : '';
-  return path.join(directory, `${command}${extension}`);
-}
-
-async function fakeExecutable(command: string, source: string) {
-  if (process.platform === 'win32') {
-    const script = path.join(directory, `${command}.cjs`);
-    await fs.writeFile(script, source);
-    await fs.writeFile(executablePath(command), `@"${process.execPath}" "${script}" %*\r\n`);
-    return;
-  }
-  await fs.writeFile(executablePath(command), `#!${process.execPath}\n${source}\n`, {
-    mode: 0o755,
-  });
-}
-
-beforeEach(async () => {
-  directory = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-agent-setup-'));
-  argumentsFile = path.join(directory, 'arguments.json');
-  project = path.join(directory, 'project');
-  await fs.mkdir(project);
-  vi.stubEnv('PATH', directory);
-  vi.stubEnv('CODEX_HOME', '');
-  vi.stubEnv('CLAUDE_CONFIG_DIR', '');
-  vi.spyOn(process, 'cwd').mockReturnValue(project);
-  vi.spyOn(os, 'homedir').mockReturnValue(path.join(directory, 'home'));
-  process.stdin.isTTY = false;
-  await fakeExecutable(
-    'npx',
-    `require('node:fs').writeFileSync(${JSON.stringify(argumentsFile)}, JSON.stringify(process.argv.slice(2)));`
-  );
-});
-
-afterEach(async () => {
-  vi.restoreAllMocks();
-  process.stdin.isTTY = originalIsTTY;
-  vi.unstubAllEnvs();
-  await fs.rm(directory, { recursive: true, force: true });
-});
-
-describe('agent setup skills installer', () => {
-  it('passes explicit agents and project scope without an interactive installer', async () => {
-    await installSkills(['claude-code', 'codex', 'cursor'], false);
-
-    expect(JSON.parse(await fs.readFile(argumentsFile, 'utf8'))).toEqual([
-      '--yes',
-      'skills@1.7.4',
-      'add',
-      'https://mintlify.com/docs',
-      '--agent',
-      'claude-code',
-      'codex',
-      'cursor',
-      '--yes',
-    ]);
-  });
-
-  it('forwards global scope to the skills installer', async () => {
-    await installSkills(['codex'], true);
-
-    expect(JSON.parse(await fs.readFile(argumentsFile, 'utf8'))).toContain('--global');
-  });
-
-  it('rejects a nonzero installer exit', async () => {
-    await fakeExecutable('npx', 'process.exit(1);');
-
-    await expect(installSkills(['codex'], false)).rejects.toThrow('Skills installation failed');
-  });
-
-  it('rejects partial installation failures even when the pinned installer exits zero', async () => {
-    await fakeExecutable('npx', "console.error('\\u001b[31mFailed to install 1\\u001b[0m');");
-
-    await expect(installSkills(['codex'], false)).rejects.toThrow('Skills installation failed');
-  });
-
-  it('rejects a missing npm runner', async () => {
-    await fs.unlink(executablePath('npx'));
-    const message =
-      process.platform === 'win32' ? 'Skills installation failed' : 'Could not run npx';
-
-    await expect(installSkills(['codex'], false)).rejects.toThrow(message);
-  });
-});
-
-describe('agent setup orchestration', () => {
-  it('passes a TOML URL override without embedded native argument quotes', async () => {
-    let output = '';
-    vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => {
-      output += chunk.toString();
-      return true;
-    });
-    await fakeExecutable(
-      'codex',
-      `require('node:fs').writeFileSync(${JSON.stringify(argumentsFile)}, JSON.stringify(process.argv.slice(2)));`
-    );
-
-    await setupAgent({ agents: ['codex'], global: false });
-    const command = output.match(/Codex: run (.+)\. Trust/)?.[1];
-    if (command === undefined) throw new Error('Missing Codex login command');
-
-    const result = spawnSync(command, { shell: true, env: process.env });
-    expect(result.status).toBe(0);
-    const args: unknown = JSON.parse(await fs.readFile(argumentsFile, 'utf8'));
-    if (!Array.isArray(args) || typeof args[1] !== 'string') {
-      throw new Error('Missing Codex configuration override');
-    }
-    expect(args[0]).toBe('-c');
-    expect(args[1]).not.toContain('"');
-    expect(args.slice(2)).toEqual(['mcp', 'login', 'mintlify-admin']);
-    expect(parseToml(args[1])).toEqual({
-      mcp_servers: { 'mintlify-admin': { url: 'https://mcp.mintlify.com' } },
-    });
-  });
-
-  it('preflights every target before installing skills or changing configuration', async () => {
-    await fs.mkdir(path.join(project, '.cursor'));
-    const conflict = '{"mcpServers":{"mintlify-admin":{"url":"https://example.com/mcp"}}}';
-    await fs.writeFile(path.join(project, '.cursor/mcp.json'), conflict);
-
-    await expect(setupAgent({ agents: ['codex', 'cursor'], global: false })).rejects.toThrow(
-      'different configuration'
-    );
-    await expect(fs.readFile(argumentsFile)).rejects.toThrow();
-    await expect(fs.readFile(path.join(project, '.codex/config.toml'))).rejects.toThrow();
-    expect(await fs.readFile(path.join(project, '.cursor/mcp.json'), 'utf8')).toBe(conflict);
-  });
-
-  it('leaves MCP configuration untouched when skills installation fails', async () => {
-    await fakeExecutable('npx', 'process.exit(1);');
-
-    await expect(setupAgent({ agents: ['codex'], global: false })).rejects.toThrow();
-    await expect(fs.readFile(path.join(project, '.codex/config.toml'))).rejects.toThrow();
-  });
-
-  it('configures all selected agents after skills finish and deduplicates targets', async () => {
-    await setupAgent({
-      agents: ['codex', 'claude-code', 'cursor', 'codex'],
-      global: false,
-    });
-
-    const args: unknown = JSON.parse(await fs.readFile(argumentsFile, 'utf8'));
-    expect(args).toEqual([
-      '--yes',
-      'skills@1.7.4',
-      'add',
-      'https://mintlify.com/docs',
-      '--agent',
-      'codex',
-      'claude-code',
-      'cursor',
-      '--yes',
-    ]);
-    for (const file of ['.codex/config.toml', '.mcp.json', '.cursor/mcp.json']) {
-      expect(await fs.readFile(path.join(project, file), 'utf8')).toContain(
-        'https://mcp.mintlify.com'
-      );
-    }
-  });
-
-  it('configures detected agents when running without a terminal', async () => {
-    vi.stubEnv('AI_AGENT', 'codex_cli');
-
-    await setupAgent({ global: false });
-
-    expect(JSON.parse(await fs.readFile(argumentsFile, 'utf8'))).toEqual([
-      '--yes',
-      'skills@1.7.4',
-      'add',
-      'https://mintlify.com/docs',
-      '--agent',
-      'codex',
-      '--yes',
-    ]);
-    expect(await fs.readFile(path.join(project, '.codex/config.toml'), 'utf8')).toContain(
-      'https://mcp.mintlify.com'
-    );
-  });
-
-  it('requires agent selection when no supported agents are detected without a terminal', async () => {
-    vi.stubEnv('AI_AGENT', 'unknown-agent');
-
-    await expect(setupAgent({ global: false })).rejects.toThrow('Pass --agent');
-    await expect(fs.readFile(argumentsFile)).rejects.toThrow();
-  });
-
-  it('rejects unsupported agent names before spawning a command', async () => {
-    await expect(setupAgent({ agents: ['codex;echo unsafe'], global: false })).rejects.toThrow(
-      'Unsupported agent'
-    );
-    await expect(fs.readFile(argumentsFile)).rejects.toThrow();
-  });
-});