@mintlify/cli 4.0.1813 → 4.1.1

package/__test__/welcome.test.ts

@@ -1,15 +0,0 @@
-import { renderWelcome } from '../src/welcome.js';
-
-describe('welcome help menu', () => {
-  it('lists the analytics command under Insights', () => {
-    const output = renderWelcome({
-      packageName: 'mint',
-      version: '1.0.0',
-      signedIn: true,
-    });
-
-    expect(output).toContain('Insights');
-    expect(output).toContain('analytics');
-    expect(output).toContain('View analytics for your site');
-  });
-});

package/__test__/workflows/client.test.ts

@@ -1,126 +0,0 @@
-import { createWorkflow, deleteWorkflow, listWorkflows } from '../../src/workflows/client.js';
-import type { WorkflowBody } from '../../src/workflows/types.js';
-
-vi.mock('../../src/keyring.js', () => ({
-  getAccessToken: vi.fn().mockResolvedValue(null),
-  getRefreshToken: vi.fn().mockResolvedValue(null),
-  storeCredentials: vi.fn().mockResolvedValue(undefined),
-}));
-
-const mockFetch = vi.fn();
-global.fetch = mockFetch;
-
-beforeEach(() => {
-  vi.stubEnv('MINTLIFY_SESSION_TOKEN', 'test-token');
-  vi.stubEnv('MINTLIFY_API_URL', 'http://test-server:5000');
-  mockFetch.mockReset();
-});
-
-afterEach(() => {
-  vi.unstubAllEnvs();
-});
-
-function mockOk(data: unknown, status = 200) {
-  mockFetch.mockResolvedValueOnce({
-    ok: true,
-    status,
-    json: () => Promise.resolve(data),
-  });
-}
-
-function mockError(status: number, body: string) {
-  mockFetch.mockResolvedValueOnce({
-    ok: false,
-    status,
-    statusText: 'Bad Request',
-    text: () => Promise.resolve(body),
-  });
-}
-
-function calledUrl(): string {
-  const arg = mockFetch.mock.calls[0]![0];
-  return typeof arg === 'string' ? arg : String(arg);
-}
-
-function calledInit(): RequestInit {
-  return mockFetch.mock.calls[0]![1] as RequestInit;
-}
-
-const body: WorkflowBody = {
-  name: 'My Workflow',
-  on: { cron: '0 6 * * *' },
-  prompt: 'Translate docs',
-};
-
-describe('workflow client auth', () => {
-  it('throws when no session token is set', async () => {
-    vi.stubEnv('MINTLIFY_SESSION_TOKEN', '');
-    await expect(listWorkflows('docs')).rejects.toThrow('Not authenticated');
-  });
-
-  it('sends bearer token header', async () => {
-    mockOk([]);
-    await listWorkflows('docs');
-    expect(mockFetch).toHaveBeenCalledWith(
-      expect.any(String),
-      expect.objectContaining({
-        headers: expect.objectContaining({ Authorization: 'Bearer test-token' }),
-      })
-    );
-  });
-});
-
-describe('createWorkflow', () => {
-  it('POSTs the body to the subdomain-scoped URL', async () => {
-    mockOk({ _id: 'wf123', name: 'My Workflow' }, 201);
-    const result = await createWorkflow('docs', body);
-
-    expect(new URL(calledUrl()).pathname).toBe('/api/cli/workflows/docs');
-    const init = calledInit();
-    expect(init.method).toBe('POST');
-    expect(init.body).toBe(JSON.stringify(body));
-    expect(init.headers).toMatchObject({ 'Content-Type': 'application/json' });
-    expect(result).toMatchObject({ _id: 'wf123' });
-  });
-
-  it('encodes the subdomain', async () => {
-    mockOk({ _id: 'wf123' }, 201);
-    await createWorkflow('my docs/sub', body);
-    expect(new URL(calledUrl()).pathname).toBe('/api/cli/workflows/my%20docs%2Fsub');
-  });
-
-  it('throws on API error', async () => {
-    mockError(400, 'Invalid request body');
-    await expect(createWorkflow('docs', body)).rejects.toThrow(
-      'API error (400): Invalid request body'
-    );
-  });
-});
-
-describe('listWorkflows', () => {
-  it('GETs the subdomain-scoped URL', async () => {
-    mockOk([{ _id: 'wf1' }, { _id: 'wf2' }]);
-    const result = await listWorkflows('docs');
-
-    expect(new URL(calledUrl()).pathname).toBe('/api/cli/workflows/docs');
-    const init = calledInit();
-    expect(init.method).toBeUndefined();
-    expect(result).toHaveLength(2);
-  });
-});
-
-describe('deleteWorkflow', () => {
-  it('DELETEs by workflow id', async () => {
-    mockOk({ success: true });
-    await deleteWorkflow('docs', 'wf123');
-
-    expect(new URL(calledUrl()).pathname).toBe('/api/cli/workflows/docs/wf123');
-    expect(calledInit().method).toBe('DELETE');
-  });
-
-  it('encodes both segments', async () => {
-    mockOk({ success: true });
-    await deleteWorkflow('my docs', 'wf 123');
-    expect(new URL(calledUrl()).pathname).toBe('/api/cli/workflows/my%20docs/wf%20123');
-  });
-});

package/bin/accessibility.js

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

package/bin/accessibilityCheck.js

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

package/bin/addDomain.js

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

package/bin/agent-auth.js

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

package/bin/agent-claim.js

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