@mintlify/cli 4.0.1813 → 4.1.1

package/src/comingSoon.tsx

@@ -1,29 +0,0 @@
-import { addLog, SuccessLog, WarningLog } from '@mintlify/previewing';
-import { Text } from 'ink';
-
-import { isTelemetryEnabled } from './config.js';
-import { terminate } from './helpers.js';
-
-export function comingSoon(command: string, packageName: string) {
-  return async () => {
-    if (!isTelemetryEnabled()) {
-      addLog(
-        <WarningLog
-          message={`Telemetry is disabled, so your vote won't be counted. Enable it with: ${packageName} --telemetry=true`}
-        />
-      );
-    } else {
-      addLog(
-        <SuccessLog
-          message={`Thanks for your interest in "${packageName} ${command}"! Your vote has been counted.`}
-        />
-      );
-    }
-    addLog(
-      <Text dimColor>
-        This feature is currently in development. Learn more at https://mintlify.com/docs
-      </Text>
-    );
-    await terminate(0);
-  };
-}

package/src/config.ts

@@ -1,75 +0,0 @@
-import fs from 'fs';
-import { ensureDir } from 'fs-extra';
-import { z } from 'zod';
-
-import { CLI_CONFIG_FILE, CONFIG_DIR } from './constants.js';
-
-interface MintlifyConfig {
-  telemetryEnabled?: boolean;
-  subdomain?: string;
-  dateFrom?: string;
-  dateTo?: string;
-  publishPromptShown?: string[];
-  agentSites?: Record<string, { registrationId: string; subdomain: string }>;
-}
-
-const agentSiteMetadataSchema = z.object({ registrationId: z.string(), subdomain: z.string() });
-
-export function getAgentSiteMetadata(key: string) {
-  const parsed = agentSiteMetadataSchema.safeParse(readConfig().agentSites?.[key]);
-  return parsed.success ? parsed.data : undefined;
-}
-
-export async function setAgentSiteMetadata(
-  key: string,
-  site: z.infer<typeof agentSiteMetadataSchema>
-) {
-  await writeConfig({ agentSites: { ...readConfig().agentSites, [key]: site } });
-}
-
-function readConfig(): MintlifyConfig {
-  try {
-    const raw = fs.readFileSync(CLI_CONFIG_FILE, 'utf-8');
-    return JSON.parse(raw) as MintlifyConfig;
-  } catch {
-    return {};
-  }
-}
-
-async function writeConfig(updates: Partial<MintlifyConfig>): Promise<void> {
-  await ensureDir(CONFIG_DIR);
-  const existing = readConfig();
-  fs.writeFileSync(CLI_CONFIG_FILE, JSON.stringify({ ...existing, ...updates }, null, 2));
-}
-
-export function isTelemetryEnabled(): boolean {
-  if (process.env.CLI_TEST_MODE === 'true') return false;
-  if (process.env.MINTLIFY_TELEMETRY_DISABLED === '1') return false;
-  if (process.env.DO_NOT_TRACK === '1') return false;
-  return readConfig().telemetryEnabled !== false;
-}
-
-export async function setTelemetryEnabled(enabled: boolean): Promise<void> {
-  await writeConfig({ telemetryEnabled: enabled });
-}
-
-export function getConfigValue(key: string): string | undefined {
-  const config = readConfig();
-  return config[key as keyof MintlifyConfig] as string | undefined;
-}
-
-export async function setConfigValue(key: string, value: string): Promise<void> {
-  await writeConfig({ [key]: value });
-}
-
-export async function clearConfigValue(key: string): Promise<void> {
-  await writeConfig({ [key]: undefined });
-}
-
-export function hasShownPublishPrompt(dir: string): boolean {
-  return readConfig().publishPromptShown?.includes(dir) ?? false;
-}
-
-export async function markPublishPromptShown(dir: string): Promise<void> {
-  await writeConfig({ publishPromptShown: [...(readConfig().publishPromptShown ?? []), dir] });
-}

package/src/constants.ts

@@ -1,28 +0,0 @@
-import { LOCAL_LINKED_CLI_VERSION } from '@mintlify/previewing';
-import os from 'os';
-import path from 'path';
-
-import { getCliVersion } from './helpers.js';
-
-export const HOME_DIR = os.homedir();
-
-export const CONFIG_DIR = path.join(HOME_DIR, '.config', 'mintlify');
-export const CLI_CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
-export const TELEMETRY_ASYNC_TIMEOUT_MS = 10_000;
-export const TELEMETRY_IDENTITY_TIMEOUT_MS = 3_000;
-
-export const CALLBACK_PORT = 11582;
-
-const IS_LOCAL_BUILD =
-  process.env.CLI_TEST_MODE === 'true' ? true : getCliVersion() == LOCAL_LINKED_CLI_VERSION;
-
-export const API_URL =
-  process.env.MINTLIFY_API_URL ??
-  (IS_LOCAL_BUILD ? 'http://localhost:5000' : 'https://leaves.mintlify.com');
-export const DASHBOARD_URL =
-  process.env.MINTLIFY_DASHBOARD_URL ??
-  (IS_LOCAL_BUILD ? 'http://localhost:3000' : 'https://app.mintlify.com');
-
-export const TOKEN_ENDPOINT = `${API_URL}/api/oauth-token/cli`;
-
-export const CUSTOM_DOMAIN_CNAME_TARGET = 'cname.mintlify.builders';

package/src/deploy-base.ts

@@ -1,18 +0,0 @@
-import type { AgentWriteToken } from './agent-deployment.js';
-import { git } from './deploy-github-actions.js';
-
-export async function pushBaseCheckout(checkout: string, write: AgentWriteToken): Promise<void> {
-  const env = {
-    ...process.env,
-    GIT_CONFIG_COUNT: '1',
-    GIT_CONFIG_KEY_0: `http.${write.remote}.extraHeader`,
-    GIT_CONFIG_VALUE_0: `Authorization: Bearer ${write.token}`,
-  };
-  await git(['fetch', write.remote, write.branch], checkout, env);
-  await git(['rebase', 'FETCH_HEAD'], checkout, env).catch(() => {
-    throw new Error(
-      `Could not rebase ${checkout} onto the latest ${write.branch}. Resolve the conflicts, run git rebase --continue, then rerun mint deploy --base --push ${checkout}.`
-    );
-  });
-  await git(['push', write.remote, `HEAD:refs/heads/${write.branch}`], checkout, env);
-}

package/src/deploy-github-actions.ts

@@ -1,139 +0,0 @@
-import { spawn } from 'node:child_process';
-import path from 'node:path';
-import { z } from 'zod';
-
-import { getGithubActionsWriteToken, type AgentWriteToken } from './agent-deployment.js';
-import { AgentApiError } from './agent-http.js';
-import { agentSiteUrl } from './deploy.js';
-
-const oidcSchema = z.object({ value: z.string().min(1) });
-
-export type GithubActionsDeployOptions = {
-  apiUrl: string;
-  directory: string;
-  subdomain?: string;
-};
-
-export function isGithubActions(env: NodeJS.ProcessEnv = process.env): boolean {
-  return env.GITHUB_ACTIONS === 'true';
-}
-
-async function getGithubOidcToken(env: NodeJS.ProcessEnv, audience: string): Promise<string> {
-  const requestUrl = env.ACTIONS_ID_TOKEN_REQUEST_URL;
-  const requestToken = env.ACTIONS_ID_TOKEN_REQUEST_TOKEN;
-  if (!requestUrl || !requestToken) {
-    throw new Error(
-      'GitHub Actions did not provide an OIDC token. Add `permissions: id-token: write` to the workflow or job.'
-    );
-  }
-  let response: Response;
-  try {
-    response = await fetch(`${requestUrl}&audience=${encodeURIComponent(audience)}`, {
-      headers: { Authorization: `Bearer ${requestToken}` },
-      signal: AbortSignal.timeout(30_000),
-    });
-  } catch {
-    throw new Error('Could not request a GitHub Actions OIDC token. Retry the workflow.');
-  }
-  const parsed = oidcSchema.safeParse(await response.json().catch(() => null));
-  if (!response.ok || !parsed.success) {
-    throw new Error(
-      `Could not get a GitHub Actions OIDC token (HTTP ${response.status}). Check that the workflow has \`permissions: id-token: write\`.`
-    );
-  }
-  return parsed.data.value;
-}
-
-export function git(args: string[], cwd: string, env: NodeJS.ProcessEnv): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const child = spawn('git', args, { cwd, env, stdio: ['ignore', 'pipe', 'inherit'] });
-    let out = '';
-    child.stdout.on('data', (chunk: Buffer) => (out += chunk.toString()));
-    child.on('error', reject);
-    child.on('close', (code) =>
-      code === 0 ? resolve(out.trim()) : reject(new Error(`git ${args[0]} failed`))
-    );
-  });
-}
-
-async function commitDirectory(directory: string, env: NodeJS.ProcessEnv): Promise<string> {
-  const prefix = await git(['rev-parse', '--show-prefix'], directory, env);
-  const tree = await git(['rev-parse', `HEAD:${prefix}`], directory, env);
-  const [name = '', email = '', date = '', sha = '', subject = ''] = (
-    await git(['log', '-1', '--format=%an%n%ae%n%aI%n%H%n%s'], directory, env)
-  ).split('\n');
-  const repository = env.GITHUB_REPOSITORY ? `${env.GITHUB_REPOSITORY}@` : '';
-  return git(
-    ['commit-tree', tree, '-m', subject, '-m', `Deployed from ${repository}${sha}`],
-    directory,
-    {
-      ...env,
-      GIT_AUTHOR_NAME: name,
-      GIT_AUTHOR_EMAIL: email,
-      GIT_AUTHOR_DATE: date,
-      GIT_COMMITTER_NAME: name,
-      GIT_COMMITTER_EMAIL: email,
-    }
-  );
-}
-
-function pushCommit(
-  directory: string,
-  commit: string,
-  write: AgentWriteToken,
-  env: NodeJS.ProcessEnv
-): Promise<void> {
-  const index = Number(env.GIT_CONFIG_COUNT) || 0;
-  const credentials = Buffer.from(`x-access-token:${write.token}`).toString('base64');
-  return new Promise((resolve, reject) => {
-    const child = spawn(
-      'git',
-      ['push', '--force', write.remote, `${commit}:refs/heads/${write.branch}`],
-      {
-        cwd: directory,
-        stdio: ['ignore', 'inherit', 'inherit'],
-        env: {
-          ...env,
-          GIT_CONFIG_COUNT: String(index + 1),
-          [`GIT_CONFIG_KEY_${index}`]: `http.${write.remote}.extraHeader`,
-          [`GIT_CONFIG_VALUE_${index}`]: `Authorization: Basic ${credentials}`,
-        },
-      }
-    );
-    const failed = () => reject(new Error('git push to the site repository failed.'));
-    child.on('error', failed);
-    child.on('close', (code) => (code === 0 ? resolve() : failed()));
-  });
-}
-
-export async function deployFromGithubActions(
-  options: GithubActionsDeployOptions,
-  progress: (message: string) => void = () => {},
-  env: NodeJS.ProcessEnv = process.env
-): Promise<string> {
-  const { apiUrl, subdomain } = options;
-  if (!subdomain) throw new Error('Pass the site name with --subdomain <name>.');
-  const directory = path.resolve(options.directory);
-  const commit = await commitDirectory(directory, env).catch(() => {
-    throw new Error(
-      `Could not read ${options.directory} from the checked-out commit. Run mint deploy after actions/checkout, with --directory inside the repository.`
-    );
-  });
-  progress('Requesting a GitHub Actions identity token...');
-  const oidcToken = await getGithubOidcToken(env, apiUrl);
-  progress('Getting repository write access...');
-  let write: AgentWriteToken;
-  try {
-    write = await getGithubActionsWriteToken(apiUrl, oidcToken, subdomain);
-  } catch (error) {
-    if (error instanceof AgentApiError && error.status === 403) {
-      throw new Error(
-        `This repository/branch isn't trusted to deploy ${subdomain}. Run \`mint deploy --github\` locally from this repository to trust it.`
-      );
-    }
-    throw error;
-  }
-  progress('Pushing to the site repository...');
-  await pushCommit(directory, commit, write, env);
-  return agentSiteUrl(apiUrl, subdomain);
-}

package/src/deploy-github-setup.ts

@@ -1,189 +0,0 @@
-import { execFile } from 'node:child_process';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { z } from 'zod';
-
-import { trustGithubRepo } from './agent-deployment.js';
-import { CLAIM_INSTRUCTIONS } from './deploy-instructions.js';
-import { agentSiteUrl, prepareAgentDeployment, type DeployOptions } from './deploy.js';
-
-const githubRepoSchema = z.object({
-  id: z.number().int().positive(),
-  full_name: z.string().regex(/^[\w.-]+\/[\w.-]+$/),
-  default_branch: z.string().min(1),
-});
-
-export type GithubRepo = z.infer<typeof githubRepoSchema>;
-
-export const GITHUB_WORKFLOW_PATH = path.join('.github', 'workflows', 'mintlify.yml');
-
-function run(command: string, args: string[], cwd: string): Promise<string> {
-  return new Promise((resolve, reject) => {
-    execFile(command, args, { cwd }, (error, stdout) =>
-      error ? reject(error) : resolve(String(stdout).trim())
-    );
-  });
-}
-
-export function parseGithubRemote(remote: string): { owner: string; repo: string } | null {
-  const match = remote
-    .trim()
-    .match(
-      /^(?:https:\/\/(?:[^@/]+@)?github\.com\/|ssh:\/\/git@github\.com(?::\d+)?\/|git@github\.com:)([\w.-]+)\/([\w.-]+?)(?:\.git)?\/?$/
-    );
-  return match?.[1] && match[2] ? { owner: match[1], repo: match[2] } : null;
-}
-
-export function githubWorkflow(branch: string, subdomain: string, docsPath = ''): string {
-  const directory = /^[\w./-]+$/.test(docsPath) ? docsPath : JSON.stringify(docsPath);
-  return [
-    'name: Deploy to Mintlify',
-    'on:',
-    '  push:',
-    `    branches: [${JSON.stringify(branch)}]`,
-    ...(docsPath
-      ? [`    paths: [${JSON.stringify(`${docsPath}/**`)}, ".github/workflows/mintlify.yml"]`]
-      : []),
-    'permissions:',
-    '  id-token: write',
-    '  contents: read',
-    'concurrency:',
-    '  group: mintlify-deploy',
-    '  cancel-in-progress: true',
-    'jobs:',
-    '  deploy:',
-    '    runs-on: ubuntu-latest',
-    '    steps:',
-    '      - uses: actions/checkout@v4',
-    `      - run: npx mint@latest deploy --subdomain ${subdomain}${docsPath ? ` --directory ${directory}` : ''}`,
-    '',
-  ].join('\n');
-}
-
-async function readFileIfExists(file: string): Promise<string | undefined> {
-  return fs.readFile(file, 'utf8').catch((error: NodeJS.ErrnoException) => {
-    if (error.code === 'ENOENT') return undefined;
-    throw error;
-  });
-}
-
-export async function writeGithubWorkflow(
-  root: string,
-  contents: string,
-  force = false
-): Promise<'created' | 'unchanged' | 'updated'> {
-  const file = path.join(root, GITHUB_WORKFLOW_PATH);
-  const existing = await readFileIfExists(file);
-  if (existing === contents) return 'unchanged';
-  if (existing !== undefined && !force) {
-    throw new Error(
-      `${GITHUB_WORKFLOW_PATH} already exists with different contents. Pass --force to overwrite it.`
-    );
-  }
-  await fs.mkdir(path.dirname(file), { recursive: true });
-  await fs.writeFile(file, contents);
-  return existing === undefined ? 'created' : 'updated';
-}
-
-export async function findGitRoot(directory: string): Promise<string> {
-  try {
-    return await run('git', ['rev-parse', '--show-toplevel'], directory);
-  } catch {
-    throw new Error('--github requires a Git repository. Run it inside your docs repository.');
-  }
-}
-
-export async function resolveGithubRepo(root: string): Promise<GithubRepo> {
-  const remote = await run('git', ['remote', 'get-url', 'origin'], root).catch(() => {
-    throw new Error('This repository has no origin remote. Add a github.com origin and retry.');
-  });
-  const parsed = parseGithubRemote(remote);
-  if (!parsed) throw new Error(`The origin remote (${remote}) is not a github.com repository.`);
-  const output = await run(
-    'gh',
-    [
-      'api',
-      `repos/${parsed.owner}/${parsed.repo}`,
-      '--jq',
-      '{id: .id, full_name: .full_name, default_branch: .default_branch}',
-    ],
-    root
-  ).catch((error: NodeJS.ErrnoException) => {
-    if (error.code === 'ENOENT')
-      throw new Error('The GitHub CLI (gh) is required. Install it and run `gh auth login`.');
-    throw new Error(
-      `Could not read ${parsed.owner}/${parsed.repo} with gh. Run \`gh auth login\` with access to the repository and retry.`
-    );
-  });
-  try {
-    return githubRepoSchema.parse(JSON.parse(output));
-  } catch {
-    throw new Error('gh returned an unexpected repository response.');
-  }
-}
-
-export type GithubSetupResult = {
-  siteUrl: string;
-  subdomain: string;
-  repository: string;
-  branch: string;
-  workflowPath: string;
-  workflow: 'created' | 'unchanged' | 'updated';
-};
-
-export async function setupGithubDeployment(
-  options: DeployOptions & { force?: boolean },
-  warn: (message: string) => void,
-  progress: (message: string) => void = () => {}
-): Promise<GithubSetupResult> {
-  const directory = path.resolve(options.directory);
-  const root = await findGitRoot(directory);
-  const [realRoot, realDirectory] = await Promise.all([fs.realpath(root), fs.realpath(directory)]);
-  const docsPath = path.relative(realRoot, realDirectory).split(path.sep).join('/');
-  if (!(await readFileIfExists(path.join(directory, 'docs.json')))) {
-    throw new Error(`No docs.json in ${directory}. Pass the docs folder with --directory.`);
-  }
-  progress('Resolving the GitHub repository...');
-  const repo = await resolveGithubRepo(root);
-  const result = await prepareAgentDeployment(options, warn, progress);
-  if (result.status === 'claimed') {
-    throw new Error(
-      'This site has been claimed. Setting up GitHub deploys for claimed sites is not supported yet; connect the repository from the Mintlify dashboard.'
-    );
-  }
-  const accessToken = result.credentials.accessToken;
-  if (!accessToken) throw new Error('Agent authentication did not return an access token.');
-  progress(`Trusting ${repo.full_name}@${repo.default_branch} to deploy...`);
-  await trustGithubRepo(options.apiUrl, accessToken, {
-    repositoryId: String(repo.id),
-    repository: repo.full_name,
-    branch: repo.default_branch,
-  });
-  const workflow = await writeGithubWorkflow(
-    root,
-    githubWorkflow(repo.default_branch, result.site.subdomain, docsPath),
-    options.force
-  );
-  return {
-    siteUrl: agentSiteUrl(options.apiUrl, result.site.subdomain),
-    subdomain: result.site.subdomain,
-    repository: repo.full_name,
-    branch: repo.default_branch,
-    workflowPath: GITHUB_WORKFLOW_PATH,
-    workflow,
-  };
-}
-
-export function formatGithubSetup(result: GithubSetupResult): string {
-  return [
-    `Site: ${result.siteUrl}`,
-    `Trusted repository: ${result.repository} (branch ${result.branch})`,
-    `Workflow: ${result.workflowPath} (${result.workflow})`,
-    '',
-    'Next steps:',
-    `1. Commit and push ${result.workflowPath} to ${result.branch}.`,
-    `2. Every push to ${result.branch} then deploys ${result.subdomain} through GitHub Actions. No secrets are stored in the repository.`,
-    '',
-    ...CLAIM_INSTRUCTIONS,
-  ].join('\n');
-}

package/src/deploy-instructions.ts

@@ -1,76 +0,0 @@
-import type { DeployResult } from './deploy.js';
-
-export const DEPLOY_HELP = [
-  'No login is required. This command provisions a temporary site and returns repository access. Commit and push the documentation yourself; the CLI does not upload files.',
-  'Run from your documentation directory, or pass --directory. Put docs.json, pages, and assets at the hosted repository root.',
-  'Run again from the same documentation directory for the current anonymous site and a fresh write token. Use --new --subdomain <name> to create another site.',
-  'Claimed sites are managed in the dashboard. Confirmed expired sites start a new anonymous registration.',
-  'Pass --email to obtain a claim link for the user. If it is absent, ask the user for their email and rerun with --email from the same directory. Never invent an email address.',
-  'To claim an existing site without provisioning, run mint claim --email <email>. Show the link to the user and ask them to return the displayed code. Then run mint claim --code <code>. Use the original documentation directory for both commands, or pass --directory.',
-  'The output contains a short-lived write token. Do not paste it into public logs or save it in a Git remote.',
-  'Pass --github from the root of a GitHub repository to deploy on every push: it trusts the repository (via the gh CLI and the origin remote) to deploy the site and writes .github/workflows/mintlify.yml. Commit and push that workflow. Pass --directory to deploy a docs subdirectory of the repository as the site root. Use --force to overwrite a different existing workflow.',
-  'Pass --base to provision a base instead of a docs site. The output has the claim steps, a clone command, and the editor link; there is no site URL. Commit in the clone, then run mint deploy --base --push <clone-directory> to publish. --base cannot be combined with --github.',
-  'In GitHub Actions (GITHUB_ACTIONS=true), no agent credentials are used: the workflow needs `permissions: id-token: write`, --subdomain is required, and the current commit is force-pushed to the site from a trusted repository and branch.',
-].join('\n\n');
-
-export const CLAIM_INSTRUCTIONS = [
-  'Ask the user for the email address they want to use to claim this site. Never invent an email address.',
-  'After they provide it, run mint deploy --email <their-email> from the same documentation directory (or repeat --directory). This reuses the site and returns its claim link.',
-];
-
-const baseClaimStep = (claimUrl?: string) =>
-  claimUrl
-    ? [
-        `3. Claim the base last. Send the user this link: ${claimUrl}`,
-        '   They sign in and get a code. When they give it to you, run: mint claim --code <code>',
-      ]
-    : [
-        '3. Claim the base last. Ask the user for their email (never invent one), then run:',
-        '   mint deploy --base --email <their-email>',
-        '   Send the user the claim link it prints. They sign in and get a code. When they give it to you, run: mint claim --code <code>',
-      ];
-
-function baseInstructions(result: Extract<DeployResult, { status: 'ready' }>, claimUrl?: string) {
-  const { site, write } = result;
-  const checkout = site.subdomain;
-  return [
-    '\nNext steps:',
-    `1. Clone the base into ./${checkout}:`,
-    `   git -c http.${write.remote}.extraHeader="Authorization: Bearer ${write.token}" clone ${write.remote} ${checkout}`,
-    `   The clone command works until ${write.tokenExpiresAt}. Run mint deploy --base again for a fresh one.`,
-    `2. Commit your changes in ./${checkout}, then publish them:`,
-    `   mint deploy --base --push ${checkout}`,
-    '   This rebases onto the latest main and pushes. Do not run git push yourself.',
-    ...baseClaimStep(claimUrl),
-    '   After the claim, the user opens the base at the editor link above and edits it there. The CLI can no longer push to it.',
-    'Run every mint command from this directory (or repeat --directory).',
-  ].join('\n');
-}
-
-export function deploymentInstructions(result: DeployResult, claimUrl?: string): string {
-  if (result.status !== 'ready') return '';
-  if (result.projectType === 'workspace') return baseInstructions(result, claimUrl);
-  return [
-    '\nNext steps:',
-    '1. Clone the hosted repository into a separate directory. Do not replace the user’s existing Git remote.',
-    '2. Copy the selected documentation into its root, including docs.json, .md/.mdx pages, images, and other required assets. Exclude credentials, .env files, node_modules, and .git.',
-    '3. Commit the documentation. For subsequent updates, fetch the hosted main branch and commit on top of it. Do not force-push.',
-    '4. Push to main. Supply the write token as an HTTP Authorization: Bearer header for this Git operation only; never embed it in the remote URL or persist it in Git config.',
-    '5. If the write token expires, run mint deploy again from the same documentation directory to obtain a fresh token.',
-    'A successful push starts the normal build. Provisioning and Git success do not confirm build success.',
-    '',
-    'Git examples (POSIX shell): set REPOSITORY_URL and WRITE_TOKEN from the output above. Set CHECKOUT_DIR to a new directory outside the source documentation directory. Keep the token private and do not enable shell tracing.',
-    'GIT_CONFIG_COUNT=1 GIT_CONFIG_KEY_0="http.${REPOSITORY_URL}.extraHeader" GIT_CONFIG_VALUE_0="Authorization: Bearer ${WRITE_TOKEN}" git clone "$REPOSITORY_URL" "$CHECKOUT_DIR"',
-    'After copying and committing the documentation:',
-    'GIT_CONFIG_COUNT=1 GIT_CONFIG_KEY_0="http.${REPOSITORY_URL}.extraHeader" GIT_CONFIG_VALUE_0="Authorization: Bearer ${WRITE_TOKEN}" git -C "$CHECKOUT_DIR" push origin HEAD:main',
-    'These settings apply only to that Git process. Use the same authentication settings for later fetches.',
-    '',
-    ...(claimUrl
-      ? [
-          `Claim link for the user: ${claimUrl}`,
-          'Show this link to the user. Ask them to open it, sign in, and return the displayed code. Do not sign in on their behalf.',
-          'After the user returns the code, run mint claim --code <code> from the same documentation directory (or repeat --directory). The CLI completes the claim using its saved credentials.',
-        ]
-      : CLAIM_INSTRUCTIONS),
-  ].join('\n');
-}