@mintlify/cli 4.0.1813 → 4.1.1

package/src/accessibility.ts

@@ -1,180 +0,0 @@
-import Color from 'color';
-
-export const WCAG_STANDARDS = {
-  AA_NORMAL: 4.5,
-  AA_LARGE: 3,
-  AAA_NORMAL: 7,
-  AAA_LARGE: 4.5,
-} as const;
-
-export type ContrastResult = {
-  ratio: number;
-  meetsAA: boolean;
-  meetsAAA: boolean;
-  recommendation: 'pass' | 'warning' | 'fail';
-  message: string;
-};
-
-export function checkColorContrast(
-  foreground: string,
-  background: string,
-  minThreshold: number = WCAG_STANDARDS.AA_NORMAL
-): ContrastResult | null {
-  try {
-    const fg = Color(foreground);
-    const bg = Color(background);
-
-    const ratio = fg.contrast(bg);
-    const level = fg.level(bg);
-
-    const meetsAA = level === 'AA' || level === 'AAA';
-    const meetsAAA = level === 'AAA';
-
-    let recommendation: 'pass' | 'warning' | 'fail';
-    let message: string;
-
-    if (minThreshold !== WCAG_STANDARDS.AA_NORMAL) {
-      if (ratio >= minThreshold) {
-        recommendation = 'pass';
-        message = `Contrast ratio: ${ratio.toFixed(
-          2
-        )}:1 (meets minimum threshold of ${minThreshold}:1)`;
-      } else {
-        recommendation = 'fail';
-        message = `Poor contrast ratio: ${ratio.toFixed(
-          2
-        )}:1 (fails minimum threshold, required: ${minThreshold}:1)`;
-      }
-    } else {
-      if (meetsAAA) {
-        recommendation = 'pass';
-        message = `Excellent contrast ratio: ${ratio.toFixed(2)}:1 (meets WCAG AAA)`;
-      } else if (meetsAA) {
-        recommendation = 'warning';
-        message = `Good contrast ratio: ${ratio.toFixed(
-          2
-        )}:1 (meets WCAG AA, consider AAA for better accessibility)`;
-      } else {
-        recommendation = 'fail';
-        message = `Poor contrast ratio: ${ratio.toFixed(2)}:1 (fails WCAG AA, minimum required: ${
-          WCAG_STANDARDS.AA_NORMAL
-        }:1)`;
-      }
-    }
-
-    return {
-      ratio,
-      meetsAA,
-      meetsAAA,
-      recommendation,
-      message,
-    };
-  } catch {
-    return null;
-  }
-}
-
-export interface AccessibilityCheckResult {
-  primaryContrast: ContrastResult | null;
-  lightContrast: ContrastResult | null;
-  darkContrast: ContrastResult | null;
-  darkOnLightContrast: ContrastResult | null;
-  anchorResults: Array<{
-    name: string;
-    lightContrast: ContrastResult | null;
-    darkContrast: ContrastResult | null;
-  }>;
-  overallScore: 'pass' | 'warning' | 'fail';
-}
-
-export function checkDocsColors(
-  colors: {
-    primary?: string;
-    light?: string;
-    dark?: string;
-  },
-  background: {
-    lightHex: string;
-    darkHex: string;
-  },
-  navigation?: {
-    global?: {
-      anchors?: Array<{
-        anchor: string;
-        color?: {
-          light?: string;
-          dark?: string;
-        };
-      }>;
-    };
-  }
-): AccessibilityCheckResult {
-  const lightBackground = background.lightHex;
-  const darkBackground = background.darkHex;
-
-  const primaryContrast = colors.primary
-    ? checkColorContrast(colors.primary, lightBackground)
-    : null;
-
-  const lightContrast = colors.light ? checkColorContrast(colors.light, darkBackground) : null;
-
-  const darkContrast = colors.dark ? checkColorContrast(colors.dark, darkBackground, 3) : null;
-
-  const darkOnLightContrast = colors.dark
-    ? checkColorContrast(colors.dark, lightBackground, 3)
-    : null;
-
-  const anchorResults: Array<{
-    name: string;
-    lightContrast: ContrastResult | null;
-    darkContrast: ContrastResult | null;
-  }> = [];
-
-  if (navigation?.global?.anchors) {
-    for (const anchor of navigation.global.anchors) {
-      if (anchor.color) {
-        const lightContrast = anchor.color.light
-          ? checkColorContrast(anchor.color.light, lightBackground)
-          : null;
-        const darkContrast = anchor.color.dark
-          ? checkColorContrast(anchor.color.dark, darkBackground)
-          : null;
-
-        anchorResults.push({
-          name: anchor.anchor,
-          lightContrast,
-          darkContrast,
-        });
-      }
-    }
-  }
-
-  const results = [
-    primaryContrast,
-    lightContrast,
-    darkContrast,
-    darkOnLightContrast,
-    ...anchorResults.flatMap((anchor) => [anchor.lightContrast, anchor.darkContrast]),
-  ].filter(Boolean);
-
-  const hasFailure = results.some((result) => result!.recommendation === 'fail');
-  const hasWarning = results.some((result) => result!.recommendation === 'warning');
-
-  let overallScore: 'pass' | 'warning' | 'fail';
-  if (hasFailure) {
-    overallScore = 'fail';
-  } else if (hasWarning) {
-    overallScore = 'warning';
-  } else {
-    overallScore = 'pass';
-  }
-
-  return {
-    primaryContrast,
-    lightContrast,
-    darkContrast,
-    darkOnLightContrast,
-    anchorResults,
-    overallScore,
-  };
-}

package/src/accessibilityCheck.tsx

@@ -1,150 +0,0 @@
-import { getBackgroundColors } from '@mintlify/common';
-import { getConfigObj, getConfigPath } from '@mintlify/prebuild';
-import { addLog, ErrorLog, WarningLog } from '@mintlify/previewing';
-import type { DocsConfig } from '@mintlify/validation';
-import { Text } from 'ink';
-
-import { checkDocsColors, type AccessibilityCheckResult } from './accessibility.js';
-import { ContrastResult } from './accessibility.js';
-import { CMD_EXEC_PATH, checkForDocsJson } from './helpers.js';
-
-export type TerminateCode = 0 | 1;
-
-export const accessibilityCheck = async (): Promise<TerminateCode> => {
-  try {
-    await checkForDocsJson();
-
-    const docsConfigPath = await getConfigPath(CMD_EXEC_PATH, 'docs');
-    const mintConfigPath = await getConfigPath(CMD_EXEC_PATH, 'mint');
-
-    if (!docsConfigPath && !mintConfigPath) {
-      addLog(
-        <ErrorLog message="No configuration file found. Please run this command from a directory with a mint.json or docs.json file." />
-      );
-      return 1;
-    }
-
-    const configType = docsConfigPath ? 'docs' : 'mint';
-    const config = (await getConfigObj(CMD_EXEC_PATH, configType)) as DocsConfig | null;
-
-    if (!config?.colors) {
-      addLog(<WarningLog message="No colors section found in configuration file" />);
-      return 0;
-    }
-
-    const { colors, navigation } = config;
-
-    const { lightHex, darkHex } = getBackgroundColors(config);
-
-    const results: AccessibilityCheckResult = checkDocsColors(
-      colors,
-      { lightHex, darkHex },
-      navigation
-    );
-
-    const displayContrastResult = (
-      result: ContrastResult | null,
-      label: string,
-      prefix: string = ''
-    ) => {
-      if (!result) return;
-
-      const { recommendation, message } = result;
-      const icon =
-        recommendation === 'pass' ? 'PASS' : recommendation === 'warning' ? 'WARN' : 'FAIL';
-      const color =
-        recommendation === 'pass' ? 'green' : recommendation === 'warning' ? 'yellow' : 'red';
-
-      addLog(
-        <Text>
-          <Text bold={prefix === ''}>
-            {prefix}
-            {label}:{' '}
-          </Text>
-          <Text color={color}>
-            {icon} {message}
-          </Text>
-        </Text>
-      );
-    };
-
-    addLog(
-      <Text bold color="cyan">
-        Checking color accessibility...
-      </Text>
-    );
-    addLog(<Text></Text>);
-
-    displayContrastResult(
-      results.primaryContrast,
-      `Primary Color (${colors.primary}) vs Light Background`
-    );
-    displayContrastResult(
-      results.lightContrast,
-      `Light Color (${colors.light}) vs Dark Background`
-    );
-    displayContrastResult(results.darkContrast, `Dark Color (${colors.dark}) vs Dark Background`);
-    displayContrastResult(
-      results.darkOnLightContrast,
-      `Dark Color (${colors.dark}) vs Light Background`
-    );
-
-    const anchorsWithResults = results.anchorResults.filter(
-      (anchor) => anchor.lightContrast || anchor.darkContrast
-    );
-
-    if (anchorsWithResults.length > 0) {
-      addLog(<Text></Text>);
-      addLog(
-        <Text bold color="cyan">
-          Navigation Anchors:
-        </Text>
-      );
-
-      for (const anchor of anchorsWithResults) {
-        addLog(<Text bold> {anchor.name}:</Text>);
-        displayContrastResult(anchor.lightContrast, 'Light variant vs Light Background', '    ');
-        displayContrastResult(anchor.darkContrast, 'Dark variant vs Dark Background', '    ');
-      }
-    }
-
-    addLog(<Text></Text>);
-    const overallIcon =
-      results.overallScore === 'pass'
-        ? 'PASS'
-        : results.overallScore === 'warning'
-          ? 'WARN'
-          : 'FAIL';
-    const overallColor =
-      results.overallScore === 'pass'
-        ? 'green'
-        : results.overallScore === 'warning'
-          ? 'yellow'
-          : 'red';
-    const overallMessage =
-      results.overallScore === 'pass'
-        ? 'All colors meet accessibility standards!'
-        : results.overallScore === 'warning'
-          ? 'Some colors could be improved for better accessibility'
-          : 'Some colors fail accessibility standards and should be updated';
-
-    addLog(
-      <Text>
-        <Text bold color={overallColor}>
-          Overall Assessment: {overallIcon} {overallMessage}
-        </Text>
-      </Text>
-    );
-
-    return results.overallScore === 'fail' ? 1 : 0;
-  } catch (error) {
-    addLog(
-      <ErrorLog
-        message={`Accessibility check failed: ${
-          error instanceof Error ? error.message : 'Unknown error'
-        }`}
-      />
-    );
-    return 1;
-  }
-};

package/src/addDomain.tsx

@@ -1,206 +0,0 @@
-import {
-  getRelativeRecordName,
-  normalizeBasePath,
-  validateCustomDomainBasePath,
-} from '@mintlify/common';
-import { addLog, ErrorLog, removeLastLog, SpinnerLog, SuccessLog } from '@mintlify/previewing';
-import { Box, Text } from 'ink';
-
-import { authenticatedFetch } from './authenticatedFetch.js';
-import { getConfigValue } from './config.js';
-import { API_URL, CUSTOM_DOMAIN_CNAME_TARGET } from './constants.js';
-import { getAccessToken } from './keyring.js';
-import { getCliSubdomains } from './status.js';
-
-interface DnsRecord {
-  type: string;
-  domain: string;
-  value: string;
-  isConfigured?: boolean;
-}
-
-interface CustomDomainCheckResponse {
-  cloudflare?: { dnsRecords?: DnsRecord[] };
-}
-
-const DNS_POLL_INTERVAL_MS = 5_000;
-const DNS_POLL_MAX_ATTEMPTS = 3;
-
-const DOMAIN_PATTERN = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)+$/i;
-
-export async function addDomain(domain: string, basePath?: string): Promise<void> {
-  if (!DOMAIN_PATTERN.test(domain)) {
-    addLog(
-      <ErrorLog
-        message={`invalid domain "${domain}". Expected a bare hostname, e.g. docs.example.com`}
-      />
-    );
-    return;
-  }
-
-  const normalizedBasePath = normalizeBasePath(basePath?.trim());
-  if (normalizedBasePath) {
-    const basePathError = validateCustomDomainBasePath(normalizedBasePath);
-    if (basePathError) {
-      addLog(<ErrorLog message={`invalid base path "${basePath}": ${basePathError}`} />);
-      return;
-    }
-  }
-
-  const accessToken = await getAccessToken();
-  if (!accessToken) {
-    addLog(<ErrorLog message="not logged in. Run `mint login` to authenticate." />);
-    return;
-  }
-
-  const subdomains = await getCliSubdomains(accessToken);
-  const configuredSubdomain = getConfigValue('subdomain');
-  const subdomain =
-    configuredSubdomain && subdomains.includes(configuredSubdomain)
-      ? configuredSubdomain
-      : subdomains[0];
-  if (!subdomain) {
-    addLog(<ErrorLog message="no subdomain found. Run `mint status` to check your account." />);
-    return;
-  }
-
-  try {
-    const addRes = await authenticatedFetch(
-      `${API_URL}/api/cli/deployment/custom-domain/${subdomain}/${domain}`,
-      {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ basePath: normalizedBasePath ? '/docs' : '' }),
-      }
-    );
-
-    if (!addRes.ok) {
-      const body = await addRes.json().catch(() => ({}));
-      addLog(<ErrorLog message={`could not add domain: ${body.error ?? 'unknown error'}`} />);
-      return;
-    }
-  } catch {
-    addLog(<ErrorLog message="could not reach the server" />);
-    return;
-  }
-
-  let basePathSaved = false;
-  let basePathPending = false;
-  if (normalizedBasePath) {
-    addLog(<SpinnerLog message={`setting base path to ${normalizedBasePath}...`} />);
-    try {
-      const basePathRes = await authenticatedFetch(
-        `${API_URL}/api/cli/deployment/base-path/${subdomain}`,
-        {
-          method: 'PUT',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ basePath: normalizedBasePath }),
-        }
-      );
-
-      removeLastLog();
-
-      if (basePathRes.ok) {
-        const body = (await basePathRes.json().catch(() => ({}))) as {
-          pendingBasePathUpdate?: unknown;
-        };
-        basePathSaved = true;
-        basePathPending = Boolean(body.pendingBasePathUpdate);
-      } else {
-        const body = (await basePathRes.json().catch(() => ({}))) as {
-          error?: string;
-          issues?: Array<{ message?: string }>;
-        };
-        const reason = body.issues?.[0]?.message ?? body.error ?? 'unknown error';
-        addLog(<ErrorLog message={`domain added, but base path was not saved: ${reason}`} />);
-      }
-    } catch {
-      removeLastLog();
-      addLog(
-        <ErrorLog message="domain added, but base path was not saved: could not reach the server" />
-      );
-    }
-  }
-
-  const maxWaitSeconds = ((DNS_POLL_MAX_ATTEMPTS - 1) * DNS_POLL_INTERVAL_MS) / 1000;
-  addLog(
-    <SpinnerLog message={`waiting for DNS records to generate (up to ${maxWaitSeconds}s)...`} />
-  );
-
-  let dnsRecords: DnsRecord[] = [];
-  let recordsReady = false;
-  try {
-    for (let attempt = 0; attempt < DNS_POLL_MAX_ATTEMPTS; attempt++) {
-      const checkRes = await authenticatedFetch(
-        `${API_URL}/api/cli/deployment/custom-domain/${subdomain}/${domain}`
-      );
-
-      if (checkRes.ok) {
-        const body = (await checkRes.json()) as CustomDomainCheckResponse;
-        dnsRecords = body.cloudflare?.dnsRecords ?? [];
-
-        const stillGenerating = dnsRecords.some((record) => record.value === 'loading');
-        if (dnsRecords.length > 0 && !stillGenerating) {
-          recordsReady = true;
-          break;
-        }
-      }
-
-      if (attempt < DNS_POLL_MAX_ATTEMPTS - 1) {
-        await new Promise((resolve) => setTimeout(resolve, DNS_POLL_INTERVAL_MS));
-      }
-    }
-  } catch {
-    removeLastLog();
-    addLog(<ErrorLog message="domain added, but could not fetch DNS records" />);
-    return;
-  }
-
-  removeLastLog();
-
-  const readyTxtRecords = dnsRecords.filter(
-    (record) => record.type === 'TXT' && record.value !== 'loading'
-  );
-
-  const successMessage = basePathPending
-    ? `domain ${domain} added; base path ${normalizedBasePath} queued for the next deploy`
-    : basePathSaved
-      ? `domain ${domain} added (serving at ${normalizedBasePath})`
-      : `domain ${domain} added`;
-
-  addLog(<SuccessLog message={successMessage} />);
-  addLog(
-    <Box flexDirection="column" gap={1} paddingY={1}>
-      <Text bold>Add these DNS records with your domain provider:</Text>
-      <Box flexDirection="column" paddingLeft={3}>
-        {readyTxtRecords.map((record) => (
-          <Text key={record.domain}>
-            TXT {getRelativeRecordName(record.domain, domain)} → {record.value}
-          </Text>
-        ))}
-        <Text>
-          CNAME {getRelativeRecordName(domain, domain)} → {CUSTOM_DOMAIN_CNAME_TARGET}
-        </Text>
-      </Box>
-      <Text dimColor>Add the TXT records first; add the CNAME once they're validated.</Text>
-      {basePathPending && (
-        <Text dimColor>
-          The base path takes effect when that deploy finishes; the current path stays up until
-          then.
-        </Text>
-      )}
-      {basePathSaved && (
-        <Text dimColor>
-          The CNAME sends all paths on {domain} to Mintlify. Only add it if this domain hosts
-          nothing else. Otherwise, set up a reverse proxy for {normalizedBasePath}:
-          https://www.mintlify.com/docs/deploy/docs-subpath
-        </Text>
-      )}
-      {!recordsReady && (
-        <Text dimColor>
-          Some TXT records are still being generated. Check the dashboard in a moment for the rest.
-        </Text>
-      )}
-    </Box>
-  );
-}

package/src/agent-auth.ts

@@ -1,119 +0,0 @@
-import { z } from 'zod';
-
-import type { AgentCredentials } from './agent-credentials.js';
-import { agentRequest, agentResponse } from './agent-http.js';
-
-const resourceSchema = z.object({ authorization_servers: z.array(z.url()).min(1) });
-const discoverySchema = z.object({
-  issuer: z.url(),
-  token_endpoint: z.url(),
-  agent_auth: z.object({
-    identity_endpoint: z.url(),
-    claim_endpoint: z.url(),
-    identity_types_supported: z.array(z.string()),
-  }),
-});
-export const agentIdentityAssertionSchema = z.object({ assertion: z.string().min(1) });
-const registrationSchema = z.object({
-  id: z.string().min(1),
-  identity: agentIdentityAssertionSchema,
-  claim: z.object({ token: z.string().min(1) }),
-});
-const tokenSchema = z.object({
-  access_token: z.string().min(1),
-  expires_in: z.number().positive(),
-  token_type: z.string().regex(/^bearer$/i),
-});
-const identitySchema = z.discriminatedUnion('identityType', [
-  z.object({ registrationId: z.string(), identityType: z.literal('anonymous') }),
-  z.object({
-    registrationId: z.string(),
-    identityType: z.literal('user_bound'),
-    userId: z.string(),
-    orgId: z.string(),
-  }),
-]);
-
-export type AgentDiscovery = z.infer<typeof discoverySchema>;
-
-export async function discoverAgentAuth(apiUrl: string): Promise<AgentDiscovery> {
-  const resource = await agentResponse(
-    await agentRequest(`${apiUrl}/api/agent/.well-known/oauth-protected-resource`),
-    resourceSchema
-  );
-  const issuer = resource.authorization_servers[0];
-  if (!issuer || new URL(issuer).protocol !== 'https:')
-    throw new Error('Agent authentication requires an HTTPS issuer.');
-  const discovery = await agentResponse(
-    await agentRequest(`${issuer.replace(/\/$/, '')}/.well-known/oauth-authorization-server`),
-    discoverySchema
-  );
-  const origin = new URL(issuer).origin;
-  if (
-    [
-      discovery.issuer,
-      discovery.token_endpoint,
-      discovery.agent_auth.identity_endpoint,
-      discovery.agent_auth.claim_endpoint,
-    ].some((url) => new URL(url).origin !== origin)
-  ) {
-    throw new Error('Agent authentication endpoints do not match the configured issuer.');
-  }
-  return discovery;
-}
-
-export async function registerAgent(discovery: AgentDiscovery): Promise<AgentCredentials> {
-  if (!discovery.agent_auth.identity_types_supported.includes('anonymous')) {
-    throw new Error('Anonymous registration is not enabled for this environment.');
-  }
-  const result = await agentResponse(
-    await agentRequest(discovery.agent_auth.identity_endpoint, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ type: 'anonymous' }),
-    }),
-    registrationSchema
-  );
-  return {
-    registrationId: result.id,
-    issuer: discovery.issuer,
-    assertion: result.identity.assertion,
-    claimToken: result.claim.token,
-  };
-}
-
-export async function exchangeAgentToken(
-  discovery: AgentDiscovery,
-  credentials: AgentCredentials
-): Promise<AgentCredentials & { accessToken: string }> {
-  if (new URL(credentials.issuer).origin !== new URL(discovery.issuer).origin) {
-    throw new Error('Saved agent credentials belong to another issuer.');
-  }
-  if (credentials.accessToken && (credentials.accessTokenExpiresAt ?? 0) > Date.now() + 30_000) {
-    return { ...credentials, accessToken: credentials.accessToken };
-  }
-  const token = await agentResponse(
-    await agentRequest(discovery.token_endpoint, {
-      method: 'POST',
-      body: new URLSearchParams({
-        grant_type: 'urn:ietf:params:oauth:grant-type:jwt-bearer',
-        assertion: credentials.assertion,
-      }),
-    }),
-    tokenSchema
-  );
-  return {
-    ...credentials,
-    accessToken: token.access_token,
-    accessTokenExpiresAt: Date.now() + token.expires_in * 1000,
-  };
-}
-
-export async function getAgentIdentity(apiUrl: string, accessToken: string) {
-  return agentResponse(
-    await agentRequest(`${apiUrl}/api/agent/identity`, {
-      headers: { Authorization: `Bearer ${accessToken}` },
-    }),
-    identitySchema
-  );
-}