@mintlify/cli 4.0.1466 → 4.0.1467

package/bin/agent-harness/types.js

@@ -2,7 +2,7 @@ import { z } from 'zod';
 const identifier = z.string().trim().min(1).max(120);
 const commandSchema = z
     .object({
-    id: identifier,
+    id: identifier.optional(),
     executable: z.string().trim().min(1).max(512),
     args: z.array(z.string().max(10000)).max(100),
     cwd: z.string().max(1024).optional(),
@@ -14,7 +14,7 @@ const commandSchema = z
         .optional(),
 })
     .strict();
-export const manifestSchema = z
+const manifestFileSchema = z
     .object({
     version: z.literal(1),
     generatedFiles: z.array(z.string().min(1).max(1024)).max(1000),
@@ -22,6 +22,37 @@ export const manifestSchema = z
     testCommands: z.array(commandSchema).max(200),
 })
     .strict();
+/**
+ * Agents often copy the manifest example verbatim and omit command ids. The id only needs to be
+ * unique within the manifest, so assign `setup-N` / `test-N` instead of rejecting the whole page.
+ */
+export function assignCommandIds(manifest) {
+    const taken = new Set([...manifest.setupCommands, ...manifest.testCommands]
+        .map((command) => command.id)
+        .filter((id) => id !== undefined));
+    const withIds = (commands, phase) => {
+        let next = 1;
+        return commands.map((command) => {
+            if (command.id !== undefined)
+                return Object.assign(Object.assign({}, command), { id: command.id });
+            let id = `${phase}-${next}`;
+            while (taken.has(id)) {
+                next += 1;
+                id = `${phase}-${next}`;
+            }
+            taken.add(id);
+            next += 1;
+            return Object.assign(Object.assign({}, command), { id });
+        });
+    };
+    return {
+        version: manifest.version,
+        generatedFiles: manifest.generatedFiles,
+        setupCommands: withIds(manifest.setupCommands, 'setup'),
+        testCommands: withIds(manifest.testCommands, 'test'),
+    };
+}
+export const manifestSchema = manifestFileSchema.transform(assignCommandIds);
 export const testCheckSchema = z
     .object({
     version: z.literal(1),

package/bin/constants.js

@@ -1,4 +1,4 @@
-var _a, _b;
+var _a, _b, _c, _d;
 import { LOCAL_LINKED_CLI_VERSION } from '@mintlify/previewing';
 import os from 'os';
 import path from 'path';
@@ -15,6 +15,6 @@ const DEV_TOKEN_ENDPOINT = 'https://test.stytch.com/v1/public/project-test-2d863
 const DEV_STYTCH_CLIENT_ID = 'connected-app-test-b597afb3-304a-420f-bc13-dacca566c59f';
 const PROD_TOKEN_ENDPOINT = 'https://api.stytch.com/v1/public/project-live-731b7a04-9ac3-4923-90b8-0806d4aa29d4/oauth2/token';
 const PROD_STYTCH_CLIENT_ID = 'connected-app-live-d813eedd-dbb0-434b-a1f9-2ce69e5efc49';
-export const TOKEN_ENDPOINT = IS_LOCAL_BUILD ? DEV_TOKEN_ENDPOINT : PROD_TOKEN_ENDPOINT;
-export const STYTCH_CLIENT_ID = IS_LOCAL_BUILD ? DEV_STYTCH_CLIENT_ID : PROD_STYTCH_CLIENT_ID;
+export const TOKEN_ENDPOINT = (_c = process.env.MINTLIFY_TOKEN_ENDPOINT) !== null && _c !== void 0 ? _c : (IS_LOCAL_BUILD ? DEV_TOKEN_ENDPOINT : PROD_TOKEN_ENDPOINT);
+export const STYTCH_CLIENT_ID = (_d = process.env.MINTLIFY_STYTCH_CLIENT_ID) !== null && _d !== void 0 ? _d : (IS_LOCAL_BUILD ? DEV_STYTCH_CLIENT_ID : PROD_STYTCH_CLIENT_ID);
 export const CUSTOM_DOMAIN_CNAME_TARGET = 'cname.mintlify.builders';

package/bin/mintTest.js

@@ -8,12 +8,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import path from 'node:path';
-import { DEFAULT_COMMAND_TIMEOUT_MS, DEFAULT_CONCURRENCY, clearRunSave, discoverCodeBlocks, loadRunSave, runCodeTests, } from './agent-harness/index.js';
+import { DEFAULT_COMMAND_TIMEOUT_MS, DEFAULT_CONCURRENCY, clearRunSave, countReport, discoverCodeBlocks, loadLatestTestRun, loadRunSave, runCodeTests, } from './agent-harness/index.js';
+import { API_URL } from './constants.js';
 import { CMD_EXEC_PATH, findDocsRoot, isAI, terminate } from './helpers.js';
 import { getAccessToken } from './keyring.js';
 import { fileInNavPaths, loadDocsNavScope } from './mintTestNav.js';
-import { countReport, formatDuration, runMintTestUi } from './mintTestUi.js';
-import { getCliStatus } from './status.js';
+import { firstLine, taskProblemLabel } from './mintTestText.js';
+import { formatDuration, runMintTestUi } from './mintTestUi.js';
+import { fetchCliStatus } from './status.js';
+const ALLOWED_ORGS = new Set(['mintlify', 'mintlify internal']);
 export function mintTestHandler() {
     return __awaiter(this, void 0, void 0, function* () {
         var _a, _b, _c, _d;
@@ -24,10 +27,20 @@ export function mintTestHandler() {
                 yield terminate(1);
                 return;
             }
-            const cliStatus = yield getCliStatus(accessToken);
-            const orgName = cliStatus === null || cliStatus === void 0 ? void 0 : cliStatus.org.name.toLowerCase();
-            if (orgName !== 'mintlify' && orgName !== 'mintlify internal') {
-                process.stderr.write('mint test is not available for your organization.\n');
+            const cliStatus = yield fetchCliStatus();
+            if (!cliStatus.ok) {
+                const message = cliStatus.reason === 'unauthenticated'
+                    ? 'your session has expired. Run `mint login` to authenticate.'
+                    : cliStatus.reason === 'unreachable'
+                        ? `could not reach Mintlify at ${API_URL}${cliStatus.detail ? ` (${cliStatus.detail})` : ''}.`
+                        : 'unexpected response from Mintlify. Please try again.';
+                process.stderr.write(`${message}\n`);
+                yield terminate(1);
+                return;
+            }
+            const orgName = cliStatus.status.org.name;
+            if (!ALLOWED_ORGS.has(orgName.toLowerCase())) {
+                process.stderr.write(`mint test is not available for your organization (${orgName}).\n`);
                 yield terminate(1);
                 return;
             }
@@ -43,7 +56,6 @@ export function mintTestHandler() {
                 ? discoveredPages.filter((page) => fileInNavPaths(page.file, scope.navPaths))
                 : discoveredPages;
             const autoSelectedFiles = (scope ? pages.filter((page) => fileInNavPaths(page.file, scope.autoSelectedPaths)) : pages).map((page) => page.file);
-            const totalPages = scope ? scope.navPaths.size : pages.length;
             const outputDirectory = path.join(docsRoot, 'tests', 'mint-test');
             let save = yield loadRunSave(outputDirectory);
             if (save) {
@@ -57,14 +69,15 @@ export function mintTestHandler() {
                     save = Object.assign(Object.assign({}, save), { selectedFiles });
                 }
             }
+            const lastReport = yield loadLatestTestRun(docsRoot);
             if (interactive) {
                 const exitCode = yield runMintTestUi({
                     targetPath,
                     docsRoot,
                     pages,
                     autoSelectedFiles,
-                    totalPages,
                     save,
+                    lastReport,
                 });
                 yield terminate(exitCode);
                 return;
@@ -87,6 +100,15 @@ export function mintTestHandler() {
             process.stdout.write(`mint test ${report.status}: ${counts.passed} passed, ${counts.failed} failed, ${counts.agentErrors} agent errors\n`);
             process.stdout.write(`finished in ${formatDuration(report.durationMs)}\n`);
             process.stdout.write(`report: ${report.reportPath}\n`);
+            for (const task of report.tasks) {
+                if (task.status !== 'failed' && task.status !== 'agent_error')
+                    continue;
+                const reason = firstLine(task.error);
+                process.stdout.write(`  ✗ ${task.file}: ${taskProblemLabel(task.status)}${reason ? ` (${reason})` : ''}\n`);
+                process.stdout.write(`    output: ${task.directory}\n`);
+            }
+            if (report.historyError)
+                process.stderr.write(`warning: ${report.historyError}\n`);
             yield terminate(report.status === 'passed' ? 0 : 1);
         }
         catch (error) {

package/bin/mintTestFilePreview.js

@@ -0,0 +1,39 @@
+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 'node:fs/promises';
+export const PREVIEW_BYTE_LIMIT = 64 * 1024;
+export function readFilePreview(filePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const buffer = new Uint8Array(PREVIEW_BYTE_LIMIT + 1);
+        const file = yield fs.open(filePath, 'r');
+        let bytesRead = 0;
+        try {
+            while (bytesRead < buffer.length) {
+                const result = yield file.read(buffer, bytesRead, buffer.length - bytesRead, bytesRead);
+                if (result.bytesRead === 0)
+                    break;
+                bytesRead += result.bytesRead;
+            }
+        }
+        finally {
+            yield file.close();
+        }
+        const contents = buffer.subarray(0, bytesRead);
+        if (contents.includes(0))
+            return { binary: true };
+        return {
+            binary: false,
+            text: new TextDecoder()
+                .decode(contents.subarray(0, PREVIEW_BYTE_LIMIT))
+                .replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, '�'),
+            truncated: bytesRead > PREVIEW_BYTE_LIMIT,
+        };
+    });
+}

package/bin/mintTestText.js

@@ -0,0 +1,31 @@
+/**
+ * Split a footer hint such as `↑/↓/j/k move · Enter exit` into key/action pairs so the key can
+ * be rendered bold and the action plain.
+ */
+export function footerSegments(text) {
+    return text
+        .split(' · ')
+        .map((segment) => segment.trim())
+        .filter((segment) => segment.length > 0)
+        .map((segment) => {
+        const split = segment.indexOf(' ');
+        if (split === -1)
+            return { key: segment, action: '' };
+        return { key: segment.slice(0, split), action: segment.slice(split + 1).trim() };
+    });
+}
+/** First non-empty line of a multi-line message, trimmed to fit a terminal row. */
+export function firstLine(text, maxLength = 160) {
+    if (!text)
+        return '';
+    const line = text
+        .split(/\r?\n/)
+        .map((candidate) => candidate.trim())
+        .find((candidate) => candidate.length > 0);
+    if (!line)
+        return '';
+    return line.length > maxLength ? `${line.slice(0, maxLength - 1)}…` : line;
+}
+export function taskProblemLabel(status) {
+    return status === 'agent_error' ? 'test could not be generated' : 'tests failed';
+}