@mintlify/cli 4.0.1812 → 4.1.1

package/bin/comingSoon.js

@@ -1,26 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { jsx as _jsx } from "react/jsx-runtime";
-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, packageName) {
-    return () => __awaiter(this, void 0, void 0, function* () {
-        if (!isTelemetryEnabled()) {
-            addLog(_jsx(WarningLog, { message: `Telemetry is disabled, so your vote won't be counted. Enable it with: ${packageName} --telemetry=true` }));
-        }
-        else {
-            addLog(_jsx(SuccessLog, { message: `Thanks for your interest in "${packageName} ${command}"! Your vote has been counted.` }));
-        }
-        addLog(_jsx(Text, { dimColor: true, children: "This feature is currently in development. Learn more at https://mintlify.com/docs" }));
-        yield terminate(0);
-    });
-}

package/bin/config.js

@@ -1,78 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import fs from 'fs';
-import { ensureDir } from 'fs-extra';
-import { z } from 'zod';
-import { CLI_CONFIG_FILE, CONFIG_DIR } from './constants.js';
-const agentSiteMetadataSchema = z.object({ registrationId: z.string(), subdomain: z.string() });
-export function getAgentSiteMetadata(key) {
-    var _a;
-    const parsed = agentSiteMetadataSchema.safeParse((_a = readConfig().agentSites) === null || _a === void 0 ? void 0 : _a[key]);
-    return parsed.success ? parsed.data : undefined;
-}
-export function setAgentSiteMetadata(key, site) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield writeConfig({ agentSites: Object.assign(Object.assign({}, readConfig().agentSites), { [key]: site }) });
-    });
-}
-function readConfig() {
-    try {
-        const raw = fs.readFileSync(CLI_CONFIG_FILE, 'utf-8');
-        return JSON.parse(raw);
-    }
-    catch (_a) {
-        return {};
-    }
-}
-function writeConfig(updates) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield ensureDir(CONFIG_DIR);
-        const existing = readConfig();
-        fs.writeFileSync(CLI_CONFIG_FILE, JSON.stringify(Object.assign(Object.assign({}, existing), updates), null, 2));
-    });
-}
-export function isTelemetryEnabled() {
-    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 function setTelemetryEnabled(enabled) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield writeConfig({ telemetryEnabled: enabled });
-    });
-}
-export function getConfigValue(key) {
-    const config = readConfig();
-    return config[key];
-}
-export function setConfigValue(key, value) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield writeConfig({ [key]: value });
-    });
-}
-export function clearConfigValue(key) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield writeConfig({ [key]: undefined });
-    });
-}
-export function hasShownPublishPrompt(dir) {
-    var _a, _b;
-    return (_b = (_a = readConfig().publishPromptShown) === null || _a === void 0 ? void 0 : _a.includes(dir)) !== null && _b !== void 0 ? _b : false;
-}
-export function markPublishPromptShown(dir) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        yield writeConfig({ publishPromptShown: [...((_a = readConfig().publishPromptShown) !== null && _a !== void 0 ? _a : []), dir] });
-    });
-}

package/bin/constants.js

@@ -1,16 +0,0 @@
-var _a, _b;
-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 = 10000;
-export const TELEMETRY_IDENTITY_TIMEOUT_MS = 3000;
-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 = (_a = process.env.MINTLIFY_API_URL) !== null && _a !== void 0 ? _a : (IS_LOCAL_BUILD ? 'http://localhost:5000' : 'https://leaves.mintlify.com');
-export const DASHBOARD_URL = (_b = process.env.MINTLIFY_DASHBOARD_URL) !== null && _b !== void 0 ? _b : (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/bin/deploy-base.js

@@ -1,20 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { git } from './deploy-github-actions.js';
-export function pushBaseCheckout(checkout, write) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const env = Object.assign(Object.assign({}, process.env), { GIT_CONFIG_COUNT: '1', GIT_CONFIG_KEY_0: `http.${write.remote}.extraHeader`, GIT_CONFIG_VALUE_0: `Authorization: Bearer ${write.token}` });
-        yield git(['fetch', write.remote, write.branch], checkout, env);
-        yield 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}.`);
-        });
-        yield git(['push', write.remote, `HEAD:refs/heads/${write.branch}`], checkout, env);
-    });
-}

package/bin/deploy-github-actions.js

@@ -1,102 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { spawn } from 'node:child_process';
-import path from 'node:path';
-import { z } from 'zod';
-import { getGithubActionsWriteToken } 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 function isGithubActions(env = process.env) {
-    return env.GITHUB_ACTIONS === 'true';
-}
-function getGithubOidcToken(env, audience) {
-    return __awaiter(this, void 0, void 0, function* () {
-        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;
-        try {
-            response = yield fetch(`${requestUrl}&audience=${encodeURIComponent(audience)}`, {
-                headers: { Authorization: `Bearer ${requestToken}` },
-                signal: AbortSignal.timeout(30000),
-            });
-        }
-        catch (_a) {
-            throw new Error('Could not request a GitHub Actions OIDC token. Retry the workflow.');
-        }
-        const parsed = oidcSchema.safeParse(yield 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, cwd, env) {
-    return new Promise((resolve, reject) => {
-        const child = spawn('git', args, { cwd, env, stdio: ['ignore', 'pipe', 'inherit'] });
-        let out = '';
-        child.stdout.on('data', (chunk) => (out += chunk.toString()));
-        child.on('error', reject);
-        child.on('close', (code) => code === 0 ? resolve(out.trim()) : reject(new Error(`git ${args[0]} failed`)));
-    });
-}
-function commitDirectory(directory, env) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const prefix = yield git(['rev-parse', '--show-prefix'], directory, env);
-        const tree = yield git(['rev-parse', `HEAD:${prefix}`], directory, env);
-        const [name = '', email = '', date = '', sha = '', subject = ''] = (yield 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, Object.assign(Object.assign({}, env), { GIT_AUTHOR_NAME: name, GIT_AUTHOR_EMAIL: email, GIT_AUTHOR_DATE: date, GIT_COMMITTER_NAME: name, GIT_COMMITTER_EMAIL: email }));
-    });
-}
-function pushCommit(directory, commit, write, env) {
-    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: Object.assign(Object.assign({}, 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 function deployFromGithubActions(options_1) {
-    return __awaiter(this, arguments, void 0, function* (options, progress = () => { }, env = process.env) {
-        const { apiUrl, subdomain } = options;
-        if (!subdomain)
-            throw new Error('Pass the site name with --subdomain <name>.');
-        const directory = path.resolve(options.directory);
-        const commit = yield 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 = yield getGithubOidcToken(env, apiUrl);
-        progress('Getting repository write access...');
-        let write;
-        try {
-            write = yield 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...');
-        yield pushCommit(directory, commit, write, env);
-        return agentSiteUrl(apiUrl, subdomain);
-    });
-}

package/bin/deploy-github-setup.js

@@ -1,165 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { 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 } 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 const GITHUB_WORKFLOW_PATH = path.join('.github', 'workflows', 'mintlify.yml');
-function run(command, args, cwd) {
-    return new Promise((resolve, reject) => {
-        execFile(command, args, { cwd }, (error, stdout) => error ? reject(error) : resolve(String(stdout).trim()));
-    });
-}
-export function parseGithubRemote(remote) {
-    const match = remote
-        .trim()
-        .match(/^(?:https:\/\/(?:[^@/]+@)?github\.com\/|ssh:\/\/git@github\.com(?::\d+)?\/|git@github\.com:)([\w.-]+)\/([\w.-]+?)(?:\.git)?\/?$/);
-    return (match === null || match === void 0 ? void 0 : match[1]) && match[2] ? { owner: match[1], repo: match[2] } : null;
-}
-export function githubWorkflow(branch, subdomain, docsPath = '') {
-    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');
-}
-function readFileIfExists(file) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return fs.readFile(file, 'utf8').catch((error) => {
-            if (error.code === 'ENOENT')
-                return undefined;
-            throw error;
-        });
-    });
-}
-export function writeGithubWorkflow(root_1, contents_1) {
-    return __awaiter(this, arguments, void 0, function* (root, contents, force = false) {
-        const file = path.join(root, GITHUB_WORKFLOW_PATH);
-        const existing = yield 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.`);
-        }
-        yield fs.mkdir(path.dirname(file), { recursive: true });
-        yield fs.writeFile(file, contents);
-        return existing === undefined ? 'created' : 'updated';
-    });
-}
-export function findGitRoot(directory) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            return yield run('git', ['rev-parse', '--show-toplevel'], directory);
-        }
-        catch (_a) {
-            throw new Error('--github requires a Git repository. Run it inside your docs repository.');
-        }
-    });
-}
-export function resolveGithubRepo(root) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const remote = yield 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 = yield run('gh', [
-            'api',
-            `repos/${parsed.owner}/${parsed.repo}`,
-            '--jq',
-            '{id: .id, full_name: .full_name, default_branch: .default_branch}',
-        ], root).catch((error) => {
-            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 (_a) {
-            throw new Error('gh returned an unexpected repository response.');
-        }
-    });
-}
-export function setupGithubDeployment(options_1, warn_1) {
-    return __awaiter(this, arguments, void 0, function* (options, warn, progress = () => { }) {
-        const directory = path.resolve(options.directory);
-        const root = yield findGitRoot(directory);
-        const [realRoot, realDirectory] = yield Promise.all([fs.realpath(root), fs.realpath(directory)]);
-        const docsPath = path.relative(realRoot, realDirectory).split(path.sep).join('/');
-        if (!(yield 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 = yield resolveGithubRepo(root);
-        const result = yield 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...`);
-        yield trustGithubRepo(options.apiUrl, accessToken, {
-            repositoryId: String(repo.id),
-            repository: repo.full_name,
-            branch: repo.default_branch,
-        });
-        const workflow = yield 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) {
-    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/bin/deploy-instructions.js

@@ -1,71 +0,0 @@
-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) => 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, claimUrl) {
-    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, claimUrl) {
-    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');
-}

package/bin/deploy.js

@@ -1,123 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import path from 'node:path';
-import { discoverAgentAuth, exchangeAgentToken, getAgentIdentity, registerAgent, } from './agent-auth.js';
-import { loadAgentCredentials, saveAgentCredentials, } from './agent-credentials.js';
-import { getAgentWriteToken, provisionAgentSite, } from './agent-deployment.js';
-import { getAgentSiteMetadata, setAgentSiteMetadata } from './config.js';
-import { DASHBOARD_URL } from './constants.js';
-import { trackEvent } from './telemetry/track.js';
-export function prepareAgentDeployment(options_1, warn_1) {
-    return __awaiter(this, arguments, void 0, function* (options, warn, progress = () => { }) {
-        var _a;
-        const { apiUrl } = options;
-        const directory = path.resolve(options.directory);
-        const metadataKey = JSON.stringify([new URL(apiUrl).origin, directory]);
-        const previous = getAgentSiteMetadata(metadataKey);
-        progress('Authenticating agent...');
-        let saved = options.newSite
-            ? null
-            : yield loadAgentCredentials(apiUrl, directory).catch(() => {
-                if (previous)
-                    throw new Error('Could not read this site’s saved credentials. Unlock your keyring or use --new for another site.');
-                warn('Could not read the keyring. Continuing with a new registration for this run.');
-                return null;
-            });
-        const subdomain = (_a = options.subdomain) !== null && _a !== void 0 ? _a : (options.newSite ? undefined : previous === null || previous === void 0 ? void 0 : previous.subdomain);
-        if (!subdomain)
-            throw new Error('Choose a site name with --subdomain <name>.');
-        const discovery = yield discoverAgentAuth(apiUrl);
-        const projectType = options.base ? 'workspace' : 'site';
-        const save = (credentials) => saveAgentCredentials(apiUrl, directory, credentials);
-        for (let attempt = 0; attempt < 2; attempt++) {
-            const credentials = saved !== null && saved !== void 0 ? saved : (yield registerAgent(discovery));
-            void trackEvent('agent_signup.discovered', { registration_id: credentials.registrationId });
-            if (!saved)
-                void trackEvent('agent_signup.registered', { registration_id: credentials.registrationId });
-            yield save(credentials);
-            const authenticated = yield exchangeAgentToken(discovery, credentials);
-            yield save(authenticated);
-            const identity = yield getAgentIdentity(apiUrl, authenticated.accessToken);
-            if (identity.registrationId !== credentials.registrationId)
-                throw new Error('Agent identity does not match the saved registration.');
-            if (identity.identityType === 'user_bound')
-                return { status: 'claimed' };
-            progress(`Provisioning the ${options.base ? 'base' : 'site'} and repository...`);
-            const site = yield provisionAgentSite(apiUrl, authenticated.accessToken, Object.assign({ subdomain, orgName: options.orgName }, (options.base && { projectType })));
-            if (site.status === 'expired') {
-                warn('The previous anonymous site expired. Creating a new registration and site.');
-                saved = null;
-                continue;
-            }
-            void trackEvent('cli.deploy.provisioned', {
-                registration_id: credentials.registrationId,
-                deployment_id: site.deploymentId,
-                subdomain: site.subdomain,
-                created: site.created,
-            });
-            yield setAgentSiteMetadata(metadataKey, {
-                registrationId: credentials.registrationId,
-                subdomain: site.subdomain,
-            }).catch(() => warn('Could not save the site name locally. Provide --subdomain on your next invocation.'));
-            progress('Getting repository write access...');
-            const write = yield getAgentWriteToken(apiUrl, authenticated.accessToken);
-            if (write.remote !== site.remote)
-                throw new Error('Repository credentials do not match the provisioned site.');
-            return {
-                status: 'ready',
-                projectType,
-                site,
-                write,
-                created: site.created,
-                credentials: authenticated,
-            };
-        }
-        throw new Error('The new anonymous site is already expired. Please retry later.');
-    });
-}
-export function agentSiteUrl(apiUrl, subdomain) {
-    const domain = new URL(apiUrl).hostname === 'leaves-dev.mintlify.com'
-        ? 'mint-dev.mintlify.me'
-        : 'mintlify.site';
-    return new URL(`https://${subdomain}.${domain}`).toString();
-}
-export function agentEditorUrl(site) {
-    return site.orgSlug
-        ? new URL(`/${site.orgSlug}/${site.subdomain}/editor`, DASHBOARD_URL).toString()
-        : new URL(DASHBOARD_URL).toString();
-}
-export function formatDeployment(result, apiUrl) {
-    if (result.status === 'claimed')
-        return 'This site has been claimed. Manage it in the Mintlify dashboard. Use mint deploy --new --subdomain <name> to create another site.';
-    const { site, write } = result;
-    const access = [
-        `Repository: ${site.remote}`,
-        `Branch: ${site.branch}`,
-        `Write token: ${write.token}`,
-        `Write token expires: ${write.tokenExpiresAt}`,
-    ];
-    if (result.projectType === 'workspace')
-        return [
-            result.created ? 'Base provisioned.' : 'Using the existing anonymous base.',
-            `Editor: ${agentEditorUrl(site)}`,
-            `Expires: ${site.expiresAt}. Claim it before then or it is deleted.`,
-        ].join('\n');
-    const siteUrl = agentSiteUrl(apiUrl, site.subdomain);
-    return [
-        result.created
-            ? 'Repository provisioned; push required to build the site.'
-            : 'Using the existing anonymous repository; push any changes to build the site.',
-        `Site: ${siteUrl}`,
-        `Expires: ${site.expiresAt}`,
-        ...access,
-        'Commit and push your documentation to this repository to start the build.',
-        'The site link becomes available after the push and build complete.',
-    ].join('\n');
-}

package/bin/feedback.js

@@ -1,36 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { jsx as _jsx } from "react/jsx-runtime";
-import { addLog, ErrorLog, SuccessLog } from '@mintlify/previewing';
-import { API_URL } from './constants.js';
-export const FEEDBACK_CATEGORIES = ['bug', 'docs', 'idea'];
-export function sendFeedback(input) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let res;
-        try {
-            res = yield fetch(`${API_URL}/api/cli/feedback`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify(Object.assign(Object.assign({}, input), { source: 'cli' })),
-            });
-        }
-        catch (_a) {
-            return 'could not reach the server';
-        }
-        return res.ok ? undefined : `could not send feedback (HTTP ${res.status})`;
-    });
-}
-export function feedback(input) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const error = yield sendFeedback(input);
-        addLog(error ? _jsx(ErrorLog, { message: error }) : _jsx(SuccessLog, { message: "feedback sent" }));
-        return !error;
-    });
-}