@mintlify/cli 4.0.1813 → 4.1.1

package/bin/instructions.js

@@ -1,101 +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());
-    });
-};
-export const INSTRUCTIONS_URL = 'https://www.mintlify.com/docs/mint-instructions';
-export const TOPICS = [
-    {
-        name: 'overview',
-        when: 'Start here: how Mintlify works and facts agents most often get wrong',
-    },
-    {
-        name: 'new-site',
-        when: 'New docs site, first publish, no account, claim a site, login, no docs.json yet',
-    },
-    {
-        name: 'write',
-        when: 'Before creating a page or writing more than a sentence or two; changelogs',
-    },
-    {
-        name: 'write components',
-        when: 'Adding or changing components: callouts, cards, steps, tabs, accordions, fields',
-    },
-    { name: 'configure', when: 'Changing docs.json: theme, colors, logo, favicon, required fields' },
-    {
-        name: 'configure navigation',
-        when: 'Changing navigation: groups, tabs, anchors, dropdowns, products, versions, languages',
-    },
-    {
-        name: 'configure settings',
-        when: 'navbar, footer, banner, SEO, search, integrations, contextual menu, redirects, 404',
-    },
-    {
-        name: 'configure customization',
-        when: 'Themes, fonts, CSS, JavaScript, or React snippets',
-    },
-    { name: 'api-docs', when: 'API documentation: OpenAPI, AsyncAPI, GraphQL, playground' },
-    {
-        name: 'api-docs sdk',
-        when: 'SDK reference pages, x-codeSamples, oneOf/anyOf, multiple responses, hiding endpoints',
-    },
-    {
-        name: 'publish',
-        when: 'Deploying, "is it live", previews, rollbacks, MCP, llms.txt, skill.md, Markdown export',
-    },
-    {
-        name: 'publish domain',
-        when: 'Custom domain (mint add-domain), /docs subpath, reverse proxy, CSP',
-    },
-    {
-        name: 'publish repo',
-        when: 'Monorepo, multi-repo, GitHub/GitLab/Bitbucket, offline export, self-host',
-    },
-    {
-        name: 'publish analytics',
-        when: 'mint analytics, feedback, search data, analytics integrations',
-    },
-    {
-        name: 'publish assistant',
-        when: 'AI assistant, widget, Assistant.md, skills, narration, own model',
-    },
-    { name: 'access', when: 'Private docs, reader login, user groups, personalization' },
-    { name: 'access team', when: 'Team members, roles, SSO, SCIM, audit logs, session security' },
-    {
-        name: 'automate',
-        when: 'Keep docs in sync with code: agent, Autopilot, automations, Slack, CI',
-    },
-    {
-        name: 'migrate',
-        when: 'Moving docs from Docusaurus, GitBook, ReadMe, Fern, Document360, Confluence, Markdown',
-    },
-    { name: 'troubleshoot', when: 'An error, a failed build or deploy, or the site looks wrong' },
-];
-export const formatTopics = () => {
-    const width = Math.max(...TOPICS.map(({ name }) => name.length)) + 2;
-    return [
-        'Usage: mint instructions <topic> [subtopic]',
-        '',
-        ...TOPICS.map(({ name, when }) => `  ${name.padEnd(width)}${when}`),
-        '',
-    ].join('\n');
-};
-export const instructionsUrl = (topics) => `${INSTRUCTIONS_URL}/${topics.map(encodeURIComponent).join('/')}.md`;
-export const stripDocsPreamble = (markdown) => markdown.replace(/^(?:>.*\n|\s*\n)*/, '');
-export function fetchInstructions(topics) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const url = instructionsUrl(topics);
-        const response = yield fetch(url);
-        if (response.status === 404) {
-            throw new Error(`no instructions for "${topics.join(' ')}". Run \`mint instructions\` to list topics.`);
-        }
-        if (!response.ok) {
-            throw new Error(`failed to fetch ${url}: ${response.status} ${response.statusText}`);
-        }
-        return stripDocsPreamble(yield response.text());
-    });
-}

package/bin/keyring.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());
-    });
-};
-const SERVICE = 'mintlify';
-const ACCESS_TOKEN_ACCOUNT = 'access_token';
-const REFRESH_TOKEN_ACCOUNT = 'refresh_token';
-const USER_EMAIL_ACCOUNT = 'user_email';
-export function getKeytar() {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        try {
-            const mod = yield import('keytar');
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- ESM wraps CJS in { default: ... } at runtime despite types
-            return (_a = mod.default) !== null && _a !== void 0 ? _a : mod;
-        }
-        catch (_b) {
-            throw new Error('keytar is required for credential storage but is not installed. Install it with: npm install keytar');
-        }
-    });
-}
-export function storeCredentials(accessToken, refreshToken, userEmail) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const keytar = yield getKeytar();
-        yield Promise.all([
-            keytar.setPassword(SERVICE, ACCESS_TOKEN_ACCOUNT, accessToken),
-            keytar.setPassword(SERVICE, REFRESH_TOKEN_ACCOUNT, refreshToken),
-        ]);
-        try {
-            if (userEmail === null) {
-                yield keytar.deletePassword(SERVICE, USER_EMAIL_ACCOUNT);
-            }
-            else if (userEmail !== undefined) {
-                yield keytar.setPassword(SERVICE, USER_EMAIL_ACCOUNT, userEmail);
-            }
-        }
-        catch (_a) { }
-    });
-}
-export function getAccessToken() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const keytar = yield getKeytar();
-        return keytar.getPassword(SERVICE, ACCESS_TOKEN_ACCOUNT);
-    });
-}
-export function getRefreshToken() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const keytar = yield getKeytar();
-        return keytar.getPassword(SERVICE, REFRESH_TOKEN_ACCOUNT);
-    });
-}
-export function getUserEmail() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const keytar = yield getKeytar();
-        return keytar.getPassword(SERVICE, USER_EMAIL_ACCOUNT);
-    });
-}
-export function storeUserEmail(userEmail) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const keytar = yield getKeytar();
-        yield keytar.setPassword(SERVICE, USER_EMAIL_ACCOUNT, userEmail);
-    });
-}
-export function clearCredentials() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const keytar = yield getKeytar();
-        yield Promise.all([
-            keytar.deletePassword(SERVICE, ACCESS_TOKEN_ACCOUNT),
-            keytar.deletePassword(SERVICE, REFRESH_TOKEN_ACCOUNT),
-            keytar.deletePassword(SERVICE, USER_EMAIL_ACCOUNT).catch(() => false),
-        ]);
-    });
-}

package/bin/login.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 { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { input, search } from '@inquirer/prompts';
-import { addLog, ErrorLog, InfoLog, SuccessLog } from '@mintlify/previewing';
-import chalk from 'chalk';
-import { Box, Text } from 'ink';
-import open from 'open';
-import { calculatePKCECodeChallenge, randomNonce, randomPKCECodeVerifier, randomState, } from 'openid-client';
-import { startCallbackServer } from './callbackServer.js';
-import { setConfigValue } from './config.js';
-import { DASHBOARD_URL, TOKEN_ENDPOINT } from './constants.js';
-import { getEmailFromIdToken } from './idToken.js';
-import { storeCredentials } from './keyring.js';
-import { getCliSubdomains } from './status.js';
-import { trackLoginAttempt, trackLoginFailed, trackLoginSuccess } from './telemetry/track.js';
-export function login() {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c;
-        const codeVerifier = randomPKCECodeVerifier();
-        const codeChallenge = yield calculatePKCECodeChallenge(codeVerifier);
-        const nonce = randomNonce();
-        const clientState = randomState();
-        const state = Buffer.from(JSON.stringify({ nonce, clientState })).toString('base64url');
-        const authorizeUrl = new URL('/api/cli/oauth/authorize', DASHBOARD_URL);
-        authorizeUrl.searchParams.set('state', state);
-        authorizeUrl.searchParams.set('code_challenge', codeChallenge);
-        const url = authorizeUrl.toString();
-        void trackLoginAttempt();
-        const { codePromise, close: closeServer } = yield startCallbackServer();
-        addLog(_jsxs(Box, { flexDirection: "column", gap: 1, paddingY: 1, children: [_jsxs(Text, { bold: true, children: [_jsx(Text, { color: "green", children: "\u25C6 " }), "A browser window will open for Mintlify authentication"] }), _jsxs(Box, { flexDirection: "column", paddingLeft: 3, gap: 1, children: [_jsx(Text, { dimColor: true, children: "If your browser doesn't open automatically, copy this URL:" }), _jsx(Text, { dimColor: true, children: url })] })] }));
-        open(url).catch(() => { });
-        addLog(_jsxs(Box, { flexDirection: "column", paddingLeft: 1, marginTop: 1, children: [_jsx(Text, { dimColor: true, children: "\u256D\u2500 Paste the authorization code from your browser" }), _jsx(Text, { dimColor: true, children: "\u2502" })] }));
-        // Let ink finish rendering before inquirer takes over stdout
-        yield new Promise((resolve) => setTimeout(resolve, 50));
-        const inputPromise = input({
-            message: '█',
-            theme: {
-                prefix: chalk.dim(' │'),
-                style: {
-                    answer: (text) => chalk.cyan(text),
-                },
-            },
-        });
-        let code;
-        try {
-            code = yield Promise.race([codePromise, inputPromise]);
-        }
-        catch (_d) {
-            closeServer();
-            inputPromise.cancel();
-            addLog(_jsx(ErrorLog, { message: "login cancelled" }));
-            return;
-        }
-        closeServer();
-        inputPromise.cancel();
-        const res = yield fetch(TOKEN_ENDPOINT, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                grant_type: 'authorization_code',
-                code,
-                code_verifier: codeVerifier,
-            }),
-        });
-        const body = yield res.json().catch(() => ({}));
-        if (!res.ok) {
-            const reason = (_b = (_a = body.error_message) !== null && _a !== void 0 ? _a : body.error) !== null && _b !== void 0 ? _b : 'unknown error';
-            void trackLoginFailed(reason);
-            addLog(_jsx(ErrorLog, { message: `login failed: ${reason}` }));
-            return;
-        }
-        const token = body;
-        yield storeCredentials(token.access_token, token.refresh_token, (_c = getEmailFromIdToken(token.id_token)) !== null && _c !== void 0 ? _c : null);
-        void trackLoginSuccess();
-        addLog(_jsx(SuccessLog, { message: "logged in successfully" }));
-        yield promptSubdomainSelection(token.access_token);
-    });
-}
-function isPromptCancellationError(error) {
-    return error instanceof Error && error.name === 'ExitPromptError';
-}
-function promptSubdomainSelection(accessToken) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const subdomains = yield getCliSubdomains(accessToken);
-        if (subdomains.length === 0)
-            return;
-        if (subdomains.length === 1) {
-            yield setConfigValue('subdomain', subdomains[0]);
-            addLog(_jsx(InfoLog, { message: `default project set to ${subdomains[0]}` }));
-            return;
-        }
-        yield new Promise((resolve) => setTimeout(resolve, 50));
-        let chosen;
-        try {
-            chosen = yield search({
-                message: 'Select a default project',
-                source: (term) => {
-                    const results = term
-                        ? subdomains.filter((s) => s.toLowerCase().includes(term.toLowerCase()))
-                        : subdomains;
-                    return results.map((s) => ({ name: s, value: s }));
-                },
-            });
-        }
-        catch (error) {
-            if (isPromptCancellationError(error)) {
-                addLog(_jsx(InfoLog, { message: `No project set. To set a default project, run ${chalk.bold('mintlify config set subdomain <subdomain>')}` }));
-                return;
-            }
-            throw error;
-        }
-        yield setConfigValue('subdomain', chosen);
-        addLog(_jsx(InfoLog, { message: `default project set to ${chosen}` }));
-    });
-}

package/bin/logout.js

@@ -1,18 +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 } from '@mintlify/previewing';
-import { clearCredentials } from './keyring.js';
-export function logout() {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield clearCredentials();
-        addLog(_jsx(SuccessLog, { message: "logged out successfully" }));
-    });
-}

package/bin/mdxAccessibility.js

@@ -1,113 +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 { coreRemark } from '@mintlify/common';
-import { categorizeFilePaths, getMintIgnore } from '@mintlify/prebuild';
-import fs from 'fs';
-import path from 'path';
-import { visit } from 'unist-util-visit';
-const checkAltAttributes = (filePath, content) => {
-    const issues = [];
-    const visitElements = () => {
-        return (tree) => {
-            visit(tree, (node) => {
-                var _a, _b, _c, _d, _e, _f;
-                if (node.type === 'image') {
-                    if (!node.alt || node.alt.trim() === '') {
-                        issues.push({
-                            filePath,
-                            line: (_a = node.position) === null || _a === void 0 ? void 0 : _a.start.line,
-                            column: (_b = node.position) === null || _b === void 0 ? void 0 : _b.start.column,
-                            element: 'img',
-                            tagName: 'image (markdown)',
-                        });
-                    }
-                    return;
-                }
-                const mdxJsxElement = node;
-                if (mdxJsxElement.name === 'img' || mdxJsxElement.name === 'video') {
-                    const altAttrIndex = mdxJsxElement.attributes.findIndex((attr) => attr.type === 'mdxJsxAttribute' && attr.name === 'alt');
-                    const altAttribute = mdxJsxElement.attributes[altAttrIndex];
-                    const hasValidAlt = altAttribute &&
-                        typeof altAttribute.value === 'string' &&
-                        altAttribute.value.trim() !== '';
-                    if (!hasValidAlt) {
-                        issues.push({
-                            filePath,
-                            line: (_c = node.position) === null || _c === void 0 ? void 0 : _c.start.line,
-                            column: (_d = node.position) === null || _d === void 0 ? void 0 : _d.start.column,
-                            element: mdxJsxElement.name,
-                            tagName: mdxJsxElement.name,
-                        });
-                    }
-                }
-                else if (mdxJsxElement.name === 'a') {
-                    const hasTextContent = (children) => {
-                        return children.some((child) => {
-                            if (child.type === 'text') {
-                                const textNode = child;
-                                return textNode.value.trim() !== '';
-                            }
-                            if ('children' in child && Array.isArray(child.children)) {
-                                return hasTextContent(child.children);
-                            }
-                            return false;
-                        });
-                    };
-                    if (!hasTextContent(mdxJsxElement.children)) {
-                        issues.push({
-                            filePath,
-                            line: (_e = node.position) === null || _e === void 0 ? void 0 : _e.start.line,
-                            column: (_f = node.position) === null || _f === void 0 ? void 0 : _f.start.column,
-                            element: 'a',
-                            tagName: '<a>',
-                        });
-                    }
-                }
-            });
-            return tree;
-        };
-    };
-    try {
-        const stripped = content.replace(/^( {0,3}#{1,6}\s+.+?)\s*\{#[^}]+\}\s*$/gm, '$1');
-        coreRemark().use(visitElements).processSync(stripped);
-    }
-    catch (error) {
-        console.warn(`Warning: Could not parse ${filePath}: ${error}`);
-    }
-    return issues;
-};
-export const checkMdxAccessibility = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (baseDir = process.cwd()) {
-    const mintIgnore = yield getMintIgnore(baseDir);
-    const { contentFilenames } = yield categorizeFilePaths(baseDir, mintIgnore);
-    const mdxFiles = [];
-    for (const file of contentFilenames) {
-        mdxFiles.push(path.join(baseDir, file));
-    }
-    const allIssues = [];
-    const filesWithIssues = new Set();
-    for (const filePath of mdxFiles) {
-        try {
-            const content = fs.readFileSync(filePath, 'utf-8');
-            const issues = checkAltAttributes(filePath, content);
-            if (issues.length > 0) {
-                allIssues.push(...issues);
-                filesWithIssues.add(filePath);
-            }
-        }
-        catch (error) {
-            console.warn(`Warning: Could not read file ${filePath}: ${error}`);
-        }
-    }
-    return {
-        missingAltAttributes: allIssues,
-        totalFiles: mdxFiles.length,
-        filesWithIssues: filesWithIssues.size,
-    };
-});

package/bin/mdxLinter.js

@@ -1,55 +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, jsxs as _jsxs } from "react/jsx-runtime";
-import { addLog, ErrorLog, SuccessLog } from '@mintlify/previewing';
-import { Text } from 'ink';
-import path from 'path';
-import { checkMdxAccessibility } from './mdxAccessibility.js';
-export const mdxLinter = () => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        addLog(_jsx(Text, { bold: true, color: "cyan", children: "Checking mdx files for accessibility issues..." }));
-        const results = yield checkMdxAccessibility();
-        if (results.missingAltAttributes.length === 0) {
-            addLog(_jsx(SuccessLog, { message: "no accessibility issues found" }));
-            addLog(_jsxs(Text, { children: ["Checked ", results.totalFiles, " MDX files - all images and videos have alt attributes."] }));
-            return 0;
-        }
-        const issuesByFile = {};
-        results.missingAltAttributes.forEach((issue) => {
-            var _a;
-            if (!issuesByFile[issue.filePath]) {
-                issuesByFile[issue.filePath] = [];
-            }
-            (_a = issuesByFile[issue.filePath]) === null || _a === void 0 ? void 0 : _a.push(issue);
-        });
-        addLog(_jsxs(Text, { bold: true, color: "red", children: ["Found ", results.missingAltAttributes.length, " accessibility issues in", ' ', results.filesWithIssues, " files:"] }));
-        addLog(_jsx(Text, {}));
-        for (const [filePath, issues] of Object.entries(issuesByFile)) {
-            const relativePath = path.relative(process.cwd(), filePath);
-            addLog(_jsxs(Text, { bold: true, children: [relativePath, ":"] }));
-            for (const issue of issues) {
-                const location = issue.line && issue.column ? ` (line ${issue.line}, col ${issue.column})` : '';
-                if (issue.element === 'a') {
-                    addLog(_jsxs(Text, { children: [_jsx(Text, { color: "red", children: " \u2717" }), " Missing text attribute ", _jsx(Text, { bold: true, children: issue.tagName }), ' ', "element", location] }));
-                }
-                else {
-                    addLog(_jsxs(Text, { children: [_jsx(Text, { color: "red", children: " \u2717" }), " Missing alt attribute on ", _jsx(Text, { bold: true, children: issue.tagName }), ' ', "element", location] }));
-                }
-            }
-            addLog(_jsx(Text, {}));
-        }
-        addLog(_jsxs(Text, { color: "yellow", children: [_jsx(Text, { bold: true, children: "Recommendation:" }), " Add alt attributes to all images and videos for better accessibility."] }));
-        return 1;
-    }
-    catch (error) {
-        addLog(_jsx(ErrorLog, { message: `MDX accessibility check failed: ${error instanceof Error ? error.message : 'Unknown error'}` }));
-        return 1;
-    }
-});

package/bin/middlewares/subdomainMiddleware.js

@@ -1,28 +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 { getConfigValue } from '../config.js';
-import { getAccessToken } from '../keyring.js';
-import { getCliSubdomains } from '../status.js';
-export function subdomainMiddleware(argv) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (typeof argv.subdomain === 'string' && argv.subdomain.length > 0)
-            return;
-        const fromConfig = getConfigValue('subdomain');
-        if (fromConfig) {
-            argv.subdomain = fromConfig;
-            return;
-        }
-        const accessToken = yield getAccessToken();
-        if (!accessToken)
-            return;
-        const subdomains = yield getCliSubdomains(accessToken);
-        argv.subdomain = subdomains[0];
-    });
-}

package/bin/middlewares/telemetryMiddleware.js

@@ -1,61 +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 { getConfigValue } from '../config.js';
-import { getVersions } from '../helpers.js';
-import { trackCommand } from '../telemetry/track.js';
-const SCRAPE_SUBCOMMANDS = new Set(['page', 'site', 'openapi']);
-const ANALYTICS_SUBCOMMANDS = new Set(['stats', 'search', 'feedback', 'conversation']);
-const CONFIG_SUBCOMMANDS = new Set(['set', 'get', 'clear']);
-const CONVERSATION_SUBCOMMANDS = new Set(['list', 'view', 'buckets']);
-const BUCKETS_SUBCOMMANDS = new Set(['list', 'view']);
-export function getSanitizedCommandForTelemetry(_) {
-    const parts = _.filter((p) => typeof p === 'string');
-    if (parts.length === 0)
-        return '';
-    const first = parts[0];
-    const second = parts[1];
-    const third = parts[2];
-    if (first === 'scrape' && second !== undefined && SCRAPE_SUBCOMMANDS.has(second)) {
-        return `scrape ${second}`;
-    }
-    if (first === 'config' && second !== undefined && CONFIG_SUBCOMMANDS.has(second)) {
-        return `config ${second}`;
-    }
-    if (first === 'analytics' && second !== undefined && ANALYTICS_SUBCOMMANDS.has(second)) {
-        if (second === 'conversation' && third !== undefined) {
-            if (CONVERSATION_SUBCOMMANDS.has(third)) {
-                const fourth = parts[3];
-                if (third === 'buckets' && fourth !== undefined && BUCKETS_SUBCOMMANDS.has(fourth)) {
-                    return `analytics conversation buckets ${fourth}`;
-                }
-                return `analytics conversation ${third}`;
-            }
-        }
-        return `analytics ${second}`;
-    }
-    return first;
-}
-export function createTelemetryMiddleware() {
-    let tracked = false;
-    return function telemetryMiddleware(argv) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const command = argv._[0];
-            if (typeof command === 'string') {
-                if (tracked)
-                    return;
-                tracked = true;
-                const sanitizedCommand = getSanitizedCommandForTelemetry(argv._);
-                const { cli: cliVersion } = getVersions();
-                const subdomain = getConfigValue('subdomain');
-                void trackCommand({ command: sanitizedCommand, cliVersion, subdomain });
-            }
-        });
-    };
-}

package/bin/migrate.js

@@ -1,54 +0,0 @@
-import { spawn } from 'node:child_process';
-import { readdirSync, readFileSync } from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { windowsCompatibleSpawnOptions } from './helpers.js';
-const root = fileURLToPath(new URL('../migrate', import.meta.url));
-const read = (...segments) => readFileSync(path.join(root, ...segments), 'utf8');
-export const listMigrationDocs = (section) => readdirSync(path.join(root, section))
-    .filter((file) => file.endsWith('.md'))
-    .map((file) => file.slice(0, -3))
-    .sort();
-const overview = () => [
-    read('index.md').trimEnd(),
-    `Topics: ${listMigrationDocs('topics').join(', ')}. Run \`mint migrate --topic <name>\`.`,
-    `Sources: ${listMigrationDocs('sources').join(', ')}. Run \`mint migrate --from <name>\`.`,
-].join('\n\n');
-export const migrationInstructions = ({ from, topic }) => {
-    if (topic)
-        return read('topics', `${topic}.md`);
-    if (from)
-        return `${overview()}\n\n${read('sources', `${from}.md`)}`;
-    return `${overview()}\n`;
-};
-const prompt = (from) => `Migrate a documentation site to Mintlify in the current directory. Run \`mint migrate${from ? ` --from ${from}` : ''}\` and follow the instructions it prints.`;
-export const agents = {
-    claude: {
-        bin: 'claude',
-        args: (prompt) => [prompt],
-        install: 'npm install -g @anthropic-ai/claude-code',
-    },
-    codex: {
-        bin: 'codex',
-        args: (prompt) => [prompt],
-        install: 'npm install -g @openai/codex',
-    },
-    cursor: {
-        bin: 'cursor-agent',
-        args: (prompt) => [prompt],
-        install: 'curl https://cursor.com/install -fsS | bash',
-    },
-    gemini: {
-        bin: 'gemini',
-        args: (prompt) => ['-i', prompt],
-        install: 'npm install -g @google/gemini-cli',
-    },
-};
-export const agentArgs = (name, from) => agents[name].args(prompt(from));
-export const migrateWithAgent = (name, from) => new Promise((resolve, reject) => {
-    const { bin, install } = agents[name];
-    const args = agentArgs(name, from).map((arg) => windowsCompatibleSpawnOptions.shell ? `"${arg}"` : arg);
-    const child = spawn(bin, args, Object.assign({ stdio: 'inherit' }, windowsCompatibleSpawnOptions));
-    child.on('error', (error) => reject(error.code === 'ENOENT' ? new Error(`${bin} not found. Install it with: ${install}`) : error));
-    child.on('close', (code) => resolve(code !== null && code !== void 0 ? code : 1));
-});