@mintlify/cli 4.0.1812 → 4.1.1

package/src/agent-claim.ts

@@ -1,124 +0,0 @@
-import { z } from 'zod';
-
-import {
-  agentIdentityAssertionSchema,
-  discoverAgentAuth,
-  exchangeAgentToken,
-} from './agent-auth.js';
-import {
-  loadAgentCredentials,
-  saveAgentCredentials,
-  type AgentCredentials,
-} from './agent-credentials.js';
-import { AgentApiError, agentRequest, agentResponse } from './agent-http.js';
-import { DASHBOARD_URL } from './constants.js';
-import { trackEvent } from './telemetry/track.js';
-
-const claimAttemptSchema = z.object({ attempt: z.object({ verification_uri: z.url() }) });
-
-export async function createAgentClaimLink(
-  apiUrl: string,
-  credentials: AgentCredentials,
-  email: string
-): Promise<string> {
-  const loginHint = z.email().parse(email);
-  const discovery = await discoverAgentAuth(apiUrl);
-  if (new URL(discovery.issuer).origin !== new URL(credentials.issuer).origin) {
-    throw new Error('Saved agent credentials belong to another issuer.');
-  }
-  const claim = await agentResponse(
-    await agentRequest(discovery.agent_auth.claim_endpoint, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        type: 'service_auth',
-        claim_token: credentials.claimToken,
-        login_hint: loginHint,
-      }),
-    }),
-    claimAttemptSchema
-  ).catch((error: unknown) => {
-    if (error instanceof AgentApiError && error.code === 'too_many_attempts') {
-      throw new Error(
-        'Too many claim links are still pending. Send the user the last claim link, or wait 5 minutes and retry.'
-      );
-    }
-    throw error;
-  });
-  const token = z
-    .string()
-    .min(1)
-    .parse(new URL(claim.attempt.verification_uri).searchParams.get('token'));
-  const claimUrl = new URL('/agent-claim', DASHBOARD_URL);
-  claimUrl.searchParams.set('token', token);
-  claimUrl.searchParams.set('registration', credentials.registrationId);
-  void trackEvent('agent_signup.claim_started', { registration_id: credentials.registrationId });
-  return claimUrl.toString();
-}
-
-const completedClaimSchema = z.object({
-  identity: agentIdentityAssertionSchema,
-});
-const signupSchema = z.object({ orgId: z.string().min(1), claimed: z.literal(true) });
-
-export async function claimDeployment(
-  options: { apiUrl: string; directory: string; code?: string; email?: string },
-  progress: (message: string) => void = () => {}
-): Promise<string> {
-  const { apiUrl, directory } = options;
-  const code = options.code?.trim();
-  const email = options.email?.trim();
-  if ((!code && !email) || (code && email)) {
-    throw new Error(
-      'Provide either --email <email> for a claim link or --code <code> to finish the claim.'
-    );
-  }
-  let credentials = await loadAgentCredentials(apiUrl, directory);
-  if (!credentials)
-    throw new Error(
-      'No saved agent registration. Run from the directory used for mint deploy, or pass --directory.'
-    );
-  if (email && !credentials.claimVerified) {
-    progress('Creating the claim link...');
-    const link = await createAgentClaimLink(apiUrl, credentials, email);
-    return `Claim link for the user: ${link}\nAsk the user to open it, sign in, and return the displayed code. Then run mint claim --code <code> from the same directory (or repeat --directory).`;
-  }
-  const discovery = await discoverAgentAuth(apiUrl);
-  if (new URL(discovery.issuer).origin !== new URL(credentials.issuer).origin) {
-    throw new Error('Saved agent credentials belong to another issuer.');
-  }
-  const save = (value: AgentCredentials) => saveAgentCredentials(apiUrl, directory, value);
-  if (!credentials.claimVerified) {
-    progress('Completing the WorkOS claim...');
-    const completed = await agentResponse(
-      await agentRequest(`${discovery.agent_auth.claim_endpoint.replace(/\/$/, '')}/complete`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ claim_token: credentials.claimToken, user_code: code }),
-      }),
-      completedClaimSchema
-    );
-    void trackEvent('agent_signup.claim_completed', {
-      registration_id: credentials.registrationId,
-    });
-    credentials = {
-      ...credentials,
-      assertion: completed.identity.assertion,
-      claimVerified: true,
-      accessToken: undefined,
-      accessTokenExpiresAt: undefined,
-    };
-    await save(credentials);
-  }
-  progress('Finishing the site claim...');
-  const authenticated = await exchangeAgentToken(discovery, credentials);
-  await agentResponse(
-    await agentRequest(`${apiUrl}/api/agent/signup`, {
-      method: 'POST',
-      headers: { Authorization: `Bearer ${authenticated.accessToken}` },
-    }),
-    signupSchema
-  );
-  await save(authenticated);
-  return 'Site claimed successfully. The user can now manage it in the Mintlify dashboard.';
-}

package/src/agent-credentials.ts

@@ -1,104 +0,0 @@
-import { createHash } from 'node:crypto';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { z } from 'zod';
-
-import { CONFIG_DIR } from './constants.js';
-import { getKeytar } from './keyring.js';
-
-const service = 'mintlify-agent';
-const fallbackFile = () => path.join(CONFIG_DIR, 'agent-credentials.json');
-
-export const agentCredentialsSchema = z.object({
-  registrationId: z.string().min(1),
-  issuer: z.url(),
-  assertion: z.string().min(1),
-  claimToken: z.string().min(1),
-  claimVerified: z.boolean().optional(),
-  accessToken: z.string().min(1).optional(),
-  accessTokenExpiresAt: z.number().optional(),
-});
-
-export type AgentCredentials = z.infer<typeof agentCredentialsSchema>;
-
-function projectAccount(apiUrl: string, directory: string): string {
-  return `project:${createHash('sha256')
-    .update(JSON.stringify([new URL(apiUrl).origin, path.resolve(directory)]))
-    .digest('hex')}`;
-}
-
-function registrationAccount(apiUrl: string, registrationId: string): string {
-  return `${new URL(apiUrl).origin}:${registrationId}`;
-}
-
-async function readFallback(): Promise<Record<string, string>> {
-  try {
-    return z
-      .record(z.string(), z.string())
-      .parse(JSON.parse(await fs.readFile(fallbackFile(), 'utf-8')));
-  } catch {
-    return {};
-  }
-}
-
-async function writeFallback(entries: Record<string, string>): Promise<void> {
-  await fs.mkdir(CONFIG_DIR, { recursive: true });
-  const temp = `${fallbackFile()}.${process.pid}.tmp`;
-  await fs.writeFile(temp, JSON.stringify(entries, null, 2), { mode: 0o600 });
-  await fs.chmod(temp, 0o600);
-  await fs.rename(temp, fallbackFile());
-}
-
-async function getSecret(account: string): Promise<string | null> {
-  let keyringError: unknown;
-  try {
-    const value = await (await getKeytar()).getPassword(service, account);
-    if (value) return value;
-  } catch (error) {
-    keyringError = error;
-  }
-  const value = (await readFallback())[account];
-  if (value) return value;
-  if (keyringError) throw keyringError;
-  return null;
-}
-
-async function setSecret(account: string, value: string): Promise<void> {
-  try {
-    await (await getKeytar()).setPassword(service, account, value);
-  } catch {
-    await writeFallback({ ...(await readFallback()), [account]: value });
-    await getKeytar()
-      .then((keytar) => keytar.deletePassword(service, account))
-      .catch(() => {});
-    return;
-  }
-  const { [account]: stale, ...rest } = await readFallback();
-  if (stale) await writeFallback(rest).catch(() => {});
-}
-
-export async function loadAgentCredentials(
-  apiUrl: string,
-  directory: string
-): Promise<AgentCredentials | null> {
-  const registrationId = await getSecret(projectAccount(apiUrl, directory));
-  if (!registrationId) return null;
-  const value = await getSecret(registrationAccount(apiUrl, registrationId));
-  if (!value)
-    throw new Error('Saved agent credentials are missing. Use --new to create another site.');
-  const credentials = agentCredentialsSchema.parse(JSON.parse(value));
-  if (credentials.registrationId !== registrationId) {
-    throw new Error('Saved agent credentials do not match this project.');
-  }
-  return credentials;
-}
-
-export async function saveAgentCredentials(
-  apiUrl: string,
-  directory: string,
-  credentials: AgentCredentials
-): Promise<void> {
-  const value = agentCredentialsSchema.parse(credentials);
-  await setSecret(registrationAccount(apiUrl, value.registrationId), JSON.stringify(value));
-  await setSecret(projectAccount(apiUrl, directory), value.registrationId);
-}

package/src/agent-deployment.ts

@@ -1,116 +0,0 @@
-import { setTimeout } from 'node:timers/promises';
-import { z } from 'zod';
-
-import { agentRequest, agentResponse } from './agent-http.js';
-
-const readySchema = z.object({
-  status: z.literal('ready'),
-  deploymentId: z.string().min(1),
-  subdomain: z.string().min(1),
-  remote: z.url(),
-  branch: z.literal('main'),
-  expiresAt: z.iso.datetime(),
-  orgSlug: z.string().min(1).optional(),
-});
-const existingSchema = z.discriminatedUnion('status', [
-  readySchema.extend({ code: z.literal('deployment_already_exists') }),
-  z.object({
-    status: z.literal('provisioning'),
-    code: z.literal('deployment_already_exists'),
-    deploymentId: z.string().optional(),
-    subdomain: z.string().optional(),
-  }),
-  z.object({
-    status: z.literal('expired'),
-    code: z.enum(['deployment_already_exists', 'deployment_claim_expired']),
-    deploymentId: z.string(),
-    subdomain: z.string(),
-    expiresAt: z.iso.datetime().optional(),
-  }),
-]);
-const writeTokenSchema = z.object({
-  remote: z.url(),
-  branch: z.literal('main'),
-  token: z.string().min(1),
-  tokenExpiresAt: z.iso.datetime(),
-});
-
-const trustedReposSchema = z.object({
-  subdomain: z.string().min(1),
-  trustedRepos: z.array(
-    z.object({ repositoryId: z.string(), repository: z.string(), branch: z.string() })
-  ),
-});
-
-export type AgentSite = z.infer<typeof readySchema>;
-export type AgentWriteToken = z.infer<typeof writeTokenSchema>;
-export type AgentProjectType = 'site' | 'workspace';
-export type AgentSiteSettings = {
-  subdomain: string;
-  orgName?: string;
-  projectType?: AgentProjectType;
-};
-
-export async function provisionAgentSite(
-  apiUrl: string,
-  accessToken: string,
-  settings: AgentSiteSettings
-) {
-  for (let attempt = 0; attempt < 4; attempt++) {
-    const response = await agentRequest(`${apiUrl}/api/agent/deployments/provision`, {
-      method: 'POST',
-      headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' },
-      body: JSON.stringify({ ...settings, docsPath: '' }),
-    });
-    if (response.status !== 409) {
-      return { ...(await agentResponse(response, readySchema)), created: true };
-    }
-    const body: unknown = await response.json().catch(() => null);
-    const parsed = existingSchema.safeParse(body);
-    if (!parsed.success) throw new Error('The deployment service returned an unexpected response.');
-    if (parsed.data.status !== 'provisioning') return { ...parsed.data, created: false };
-    if (attempt < 3) await setTimeout(1000 * (attempt + 1));
-  }
-  throw new Error('Your site is still provisioning. Run the same command again.');
-}
-
-export async function getAgentWriteToken(
-  apiUrl: string,
-  accessToken: string
-): Promise<AgentWriteToken> {
-  return agentResponse(
-    await agentRequest(`${apiUrl}/api/agent/deployments/token`, {
-      method: 'POST',
-      headers: { Authorization: `Bearer ${accessToken}` },
-    }),
-    writeTokenSchema
-  );
-}
-
-export async function getGithubActionsWriteToken(
-  apiUrl: string,
-  oidcToken: string,
-  subdomain: string
-): Promise<AgentWriteToken> {
-  return agentResponse(
-    await agentRequest(`${apiUrl}/api/agent/deployments/github-actions/token`, {
-      method: 'POST',
-      headers: { Authorization: `Bearer ${oidcToken}`, 'Content-Type': 'application/json' },
-      body: JSON.stringify({ subdomain }),
-    }),
-    writeTokenSchema
-  );
-}
-
-export type TrustedRepo = { repositoryId: string; repository: string; branch: string };
-
-export async function trustGithubRepo(apiUrl: string, accessToken: string, repo: TrustedRepo) {
-  return agentResponse(
-    await agentRequest(`${apiUrl}/api/agent/deployments/trusted-repos`, {
-      method: 'POST',
-      headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' },
-      body: JSON.stringify(repo),
-    }),
-    trustedReposSchema
-  );
-}

package/src/agent-http.ts

@@ -1,34 +0,0 @@
-import { z } from 'zod';
-
-const errorSchema = z.object({ code: z.string().optional(), error: z.string().optional() });
-
-export class AgentApiError extends Error {
-  constructor(
-    public readonly status: number,
-    public readonly code?: string
-  ) {
-    super(`Agent request failed (HTTP ${status}).${code ? ` Code: ${code}.` : ''}`);
-  }
-}
-
-export async function agentRequest(url: string, init?: RequestInit): Promise<Response> {
-  try {
-    const timeout = AbortSignal.timeout(30_000);
-    const signal = init?.signal ? AbortSignal.any([init.signal, timeout]) : timeout;
-    return await fetch(url, { ...init, redirect: 'error', signal });
-  } catch {
-    throw new Error('Could not reach the agent service. Retry the same command.');
-  }
-}
-
-export async function agentResponse<T>(response: Response, schema: z.ZodType<T>): Promise<T> {
-  const body: unknown = await response.json().catch(() => null);
-  if (!response.ok) {
-    const error = errorSchema.safeParse(body);
-    const code = error.success ? (error.data.code ?? error.data.error) : undefined;
-    throw new AgentApiError(response.status, code?.match(/^[a-z_]{1,80}$/)?.[0]);
-  }
-  const parsed = schema.safeParse(body);
-  if (!parsed.success) throw new Error('The agent service returned an unexpected response.');
-  return parsed.data;
-}

package/src/agent-setup-config.ts

@@ -1,144 +0,0 @@
-import { applyEdits, modify, parse, type ParseError } from 'jsonc-parser';
-import { randomUUID } from 'node:crypto';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { parse as parseToml } from 'smol-toml';
-
-export type SetupAgent = 'claude-code' | 'codex' | 'cursor';
-
-export const ADMIN_MCP_NAME = 'mintlify-admin';
-export const ADMIN_MCP_URL = 'https://mcp.mintlify.com';
-
-type ConfigLocation = {
-  cwd: string;
-  homeDir: string;
-  global: boolean;
-  env?: NodeJS.ProcessEnv;
-};
-
-type McpConfigPlan = {
-  path: string;
-  original: string | undefined;
-  contents: string | undefined;
-};
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-async function readConfig(file: string): Promise<string | undefined> {
-  try {
-    return await fs.readFile(file, 'utf8');
-  } catch (error) {
-    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') return undefined;
-    throw error;
-  }
-}
-
-function configPath(agent: SetupAgent, options: ConfigLocation): string {
-  const env = options.env ?? process.env;
-  if (agent === 'codex') {
-    let directory = path.join(options.cwd, '.codex');
-    if (options.global) directory = env.CODEX_HOME || path.join(options.homeDir, '.codex');
-    return path.join(directory, 'config.toml');
-  }
-  if (agent === 'cursor') {
-    const directory = options.global ? options.homeDir : options.cwd;
-    return path.join(directory, '.cursor', 'mcp.json');
-  }
-  if (options.global) {
-    if (env.CLAUDE_CONFIG_DIR) {
-      throw new Error(
-        'CLAUDE_CONFIG_DIR is set. Configure Claude Code with: claude mcp add --scope user --transport http mintlify-admin https://mcp.mintlify.com'
-      );
-    }
-    return path.join(options.homeDir, '.claude.json');
-  }
-  return path.join(options.cwd, '.mcp.json');
-}
-
-export async function prepareMcpConfig(
-  agent: SetupAgent,
-  options: ConfigLocation
-): Promise<McpConfigPlan> {
-  const requestedPath = configPath(agent, options);
-  const file = await fs.realpath(requestedPath).catch((error: unknown) => {
-    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') return requestedPath;
-    throw error;
-  });
-  const original = await readConfig(file);
-  const source = original ?? '';
-  const key = agent === 'codex' ? 'mcp_servers' : 'mcpServers';
-  let config: unknown;
-  try {
-    if (agent === 'codex') {
-      config = parseToml(source);
-    } else {
-      const errors: ParseError[] = [];
-      config = parse(source || '{}', errors, { allowTrailingComma: true });
-      if (errors.length > 0) throw new Error('Invalid JSON');
-    }
-  } catch {
-    throw new Error(`Cannot parse ${file}. Fix its configuration before running setup.`);
-  }
-  if (!isRecord(config)) throw new Error(`Expected an object in ${file}.`);
-  const servers = config[key];
-  if (servers !== undefined && !isRecord(servers)) {
-    throw new Error(`Expected ${key} to be an object in ${file}.`);
-  }
-  const existing = servers?.[ADMIN_MCP_NAME];
-  if (existing !== undefined) {
-    if (!isRecord(existing) || existing.url !== ADMIN_MCP_URL || existing.command !== undefined) {
-      throw new Error(
-        `${ADMIN_MCP_NAME} already has a different configuration in ${file}. Rename or remove that entry before running setup.`
-      );
-    }
-    if (agent === 'claude-code' && existing.type !== 'http') {
-      throw new Error(`Set type to "http" for ${ADMIN_MCP_NAME} in ${file} before running setup.`);
-    }
-    return { path: file, original, contents: undefined };
-  }
-  const newline = source.includes('\r\n') ? '\r\n' : '\n';
-  let contents: string;
-  if (agent === 'codex') {
-    contents = `${source}${newline}[mcp_servers.${ADMIN_MCP_NAME}]${newline}url = "${ADMIN_MCP_URL}"${newline}`;
-    try {
-      parseToml(contents);
-    } catch {
-      throw new Error(
-        `Cannot safely extend ${file}. Add a ${ADMIN_MCP_NAME} entry with url = "${ADMIN_MCP_URL}" to mcp_servers manually.`
-      );
-    }
-  } else {
-    const server: Record<string, string> = { url: ADMIN_MCP_URL };
-    if (agent === 'claude-code') server.type = 'http';
-    contents = applyEdits(
-      source || '{}',
-      modify(source || '{}', [key, ADMIN_MCP_NAME], server, {
-        formattingOptions: { insertSpaces: true, tabSize: 2, eol: newline },
-      })
-    );
-    if (!contents.endsWith(newline)) contents += newline;
-  }
-  return { path: file, original, contents };
-}
-
-export async function writeMcpConfig(plan: McpConfigPlan): Promise<void> {
-  if ((await readConfig(plan.path)) !== plan.original) {
-    throw new Error(
-      `${plan.path} changed during setup. Run setup again to preserve those changes.`
-    );
-  }
-  if (plan.contents === undefined) return;
-  await fs.mkdir(path.dirname(plan.path), { recursive: true, mode: 0o700 });
-  let mode = 0o600;
-  if (plan.original !== undefined) mode = (await fs.stat(plan.path)).mode;
-  const temporaryPath = `${plan.path}.${randomUUID()}.tmp`;
-  try {
-    await fs.writeFile(temporaryPath, plan.contents, { mode, flag: 'wx' });
-    if (plan.original !== undefined) await fs.chmod(temporaryPath, mode);
-    await fs.rename(temporaryPath, plan.path);
-  } finally {
-    await fs.rm(temporaryPath, { force: true });
-  }
-}

package/src/agent-setup.ts

@@ -1,165 +0,0 @@
-import { checkbox } from '@inquirer/prompts';
-import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { stripVTControlCharacters } from 'node:util';
-
-import {
-  ADMIN_MCP_NAME,
-  ADMIN_MCP_URL,
-  prepareMcpConfig,
-  writeMcpConfig,
-  type SetupAgent,
-} from './agent-setup-config.js';
-import { detectAgent } from './agent.js';
-
-export const SETUP_AGENTS: SetupAgent[] = ['claude-code', 'codex', 'cursor'];
-
-const AGENT_LABELS: Record<SetupAgent, string> = {
-  'claude-code': 'Claude Code',
-  codex: 'Codex',
-  cursor: 'Cursor',
-};
-
-type SetupOptions = {
-  agents?: string[];
-  global: boolean;
-};
-
-function isSetupAgent(value: string): value is SetupAgent {
-  return SETUP_AGENTS.some((agent) => agent === value);
-}
-
-function detectedAgents(): SetupAgent[] {
-  const homeDir = os.homedir();
-  const current = detectAgent();
-  return SETUP_AGENTS.filter((agent) => {
-    if (agent === 'codex') {
-      return (
-        current === 'codex_cli' ||
-        existsSync(process.env.CODEX_HOME || path.join(homeDir, '.codex'))
-      );
-    }
-    if (agent === 'claude-code') {
-      return (
-        current === 'claude_code' ||
-        existsSync(process.env.CLAUDE_CONFIG_DIR || path.join(homeDir, '.claude'))
-      );
-    }
-    return (
-      current === 'cursor' || current === 'cursor-cli' || existsSync(path.join(homeDir, '.cursor'))
-    );
-  });
-}
-
-export function installSkills(agents: SetupAgent[], global: boolean): Promise<void> {
-  const args = [
-    '--yes',
-    'skills@1.7.4',
-    'add',
-    'https://mintlify.com/docs',
-    '--agent',
-    ...agents,
-    '--yes',
-  ];
-  if (global) args.push('--global');
-  return new Promise((resolve, reject) => {
-    const child = spawn('npx', args, {
-      stdio: ['ignore', 'pipe', 'pipe'],
-      shell: process.platform === 'win32',
-    });
-    let output = '';
-    const recordOutput = (chunk: Buffer) => {
-      output = (output + chunk.toString()).slice(-65_536);
-    };
-    child.stdout.on('data', (chunk: Buffer) => {
-      recordOutput(chunk);
-      process.stdout.write(chunk.toString());
-    });
-    child.stderr.on('data', (chunk: Buffer) => {
-      recordOutput(chunk);
-      process.stderr.write(chunk.toString());
-    });
-    child.on('error', () =>
-      reject(new Error('Could not run npx. Install npm and run setup again.'))
-    );
-    child.on('close', (code, signal) => {
-      if (code !== 0 || /Failed to install\s+\d+/.test(stripVTControlCharacters(output))) {
-        reject(
-          new Error(
-            `Skills installation failed (${signal ?? code}). Review the installer output and run setup again.`
-          )
-        );
-      } else {
-        resolve();
-      }
-    });
-  });
-}
-
-export async function setupAgent(options: SetupOptions): Promise<void> {
-  const [major = 0, minor = 0] = process.versions.node.split('.').map(Number);
-  if (major < 22 || (major === 22 && minor < 20)) {
-    throw new Error(
-      'mint agent setup requires Node.js 22.20 or later to install skills. Upgrade Node.js and try again.'
-    );
-  }
-  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
-  let agents: SetupAgent[] = [];
-  for (const agent of options.agents ?? []) {
-    if (!isSetupAgent(agent)) throw new Error(`Unsupported agent: ${agent}`);
-    if (!agents.includes(agent)) agents.push(agent);
-  }
-  if (agents.length === 0) {
-    const detected = detectedAgents();
-    if (!interactive) {
-      agents = detected;
-    } else {
-      agents = await checkbox({
-        message: 'Which agents should use Mintlify?',
-        choices: SETUP_AGENTS.map((agent) => ({
-          name: AGENT_LABELS[agent],
-          value: agent,
-          checked: detected.includes(agent),
-        })),
-        required: true,
-      });
-    }
-  }
-  if (agents.length === 0) {
-    throw new Error('No supported agents detected. Pass --agent claude-code, codex, or cursor.');
-  }
-  const location = { cwd: process.cwd(), homeDir: os.homedir(), global: options.global };
-  const plans = await Promise.all(agents.map((agent) => prepareMcpConfig(agent, location)));
-  const scope = options.global ? 'your user account' : 'this project';
-  process.stdout.write(`Setting up Mintlify skills and Admin MCP for ${scope}.\n`);
-  await installSkills(agents, options.global);
-  for (const plan of plans) {
-    await writeMcpConfig(plan);
-    const action = plan.contents === undefined ? 'Already configured' : 'Configured';
-    process.stdout.write(`${action}: ${plan.path}\n`);
-  }
-  process.stdout.write(
-    '\nAdmin MCP is configured. Complete OAuth sign-in to grant account and project access:\n'
-  );
-  for (const agent of agents) {
-    if (agent === 'codex') {
-      let command = `codex mcp login ${ADMIN_MCP_NAME}`;
-      if (!options.global) {
-        const config = `mcp_servers.${ADMIN_MCP_NAME}.url='${ADMIN_MCP_URL}'`;
-        command = `codex -c "${config}" mcp login ${ADMIN_MCP_NAME}`;
-      }
-      process.stdout.write(
-        `  Codex: run ${command}. Trust the project before using its MCP configuration.\n`
-      );
-    } else if (agent === 'claude-code') {
-      process.stdout.write(
-        `  Claude Code: open /mcp and authenticate ${ADMIN_MCP_NAME}. Approve the project server if prompted.\n`
-      );
-    } else {
-      process.stdout.write(`  Cursor: open MCP settings and connect ${ADMIN_MCP_NAME}.\n`);
-    }
-  }
-  process.stdout.write('Setup: https://mintlify.com/docs/ai/mintlify-mcp\n');
-}