@mintlify/cli 4.0.1123 → 4.0.1125

package/__test__/helpers.test.ts

@@ -0,0 +1,30 @@
+import { LOCAL_LINKED_CLI_VERSION } from '@mintlify/previewing';
+
+import { getCliVersion } from '../src/helpers.js';
+
+describe('getCliVersion', () => {
+  const originalTestMode = process.env.CLI_TEST_MODE;
+
+  afterEach(() => {
+    if (originalTestMode === undefined) {
+      delete process.env.CLI_TEST_MODE;
+    } else {
+      process.env.CLI_TEST_MODE = originalTestMode;
+    }
+  });
+
+  it('returns a test marker when CLI_TEST_MODE is enabled', () => {
+    process.env.CLI_TEST_MODE = 'true';
+    expect(getCliVersion()).toBe('test-cli');
+  });
+
+  it(
+    'returns LOCAL_LINKED_CLI_VERSION when running from the monorepo source ' +
+      '(not inside node_modules)',
+    () => {
+      // Source lives outside node_modules, mirroring `npm link` / `yarn dev`. See #7121.
+      delete process.env.CLI_TEST_MODE;
+      expect(getCliVersion()).toBe(LOCAL_LINKED_CLI_VERSION);
+    }
+  );
+});

package/bin/helpers.js

@@ -14,13 +14,14 @@ import { addLog, ErrorLog, getClientVersion, SuccessLog, InfoLog, SpinnerLog, re
 import { upgradeToDocsConfig, validatePathWithinCwd } from '@mintlify/validation';
 import detect from 'detect-port';
 import fse from 'fs-extra';
-import fs from 'fs/promises';
 import inquirer from 'inquirer';
 import yaml from 'js-yaml';
 import { exec, execSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import fs from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
 import { promisify } from 'node:util';
 import path from 'path';
-import yargs from 'yargs';
 import { shutdownPostHog } from './telemetry/client.js';
 export const CMD_EXEC_PATH = process.cwd();
 export const checkPort = (argv) => __awaiter(void 0, void 0, void 0, function* () {
@@ -109,22 +110,41 @@ export const upgradeConfig = () => __awaiter(void 0, void 0, void 0, function* (
         addLog(_jsx(ErrorLog, { message: err instanceof Error ? err.message : 'an unknown error occurred' }));
     }
 });
-export const getCliVersion = () => {
-    const y = yargs();
-    let version = undefined;
-    y.showVersion((s) => {
-        version = s;
+// Resolve the CLI's own package.json via `import.meta.url` so the version is
+// always the one shipped with this package, regardless of cwd. See #7121.
+const CLI_PACKAGE_JSON_PATH = (() => {
+    try {
+        return fileURLToPath(new URL('../package.json', import.meta.url));
+    }
+    catch (_a) {
+        return undefined;
+    }
+})();
+const readCliPackageVersion = () => {
+    if (!CLI_PACKAGE_JSON_PATH)
+        return undefined;
+    try {
+        const pkg = JSON.parse(readFileSync(CLI_PACKAGE_JSON_PATH, 'utf8'));
+        return typeof pkg.version === 'string' ? pkg.version : undefined;
+    }
+    catch (_a) {
+        return undefined;
+    }
+};
+// Outside `node_modules` means `yarn dev` or `npm link`: treat as linked. See #7121.
+const isRunningFromLinkedBuild = () => {
+    if (!CLI_PACKAGE_JSON_PATH)
         return false;
-    });
+    return !CLI_PACKAGE_JSON_PATH.split(path.sep).includes('node_modules');
+};
+export const getCliVersion = () => {
     if (process.env.CLI_TEST_MODE === 'true') {
         return 'test-cli';
     }
-    // when running `npm link` the version is 'unknown'
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    if (version === 'unknown') {
-        version = LOCAL_LINKED_CLI_VERSION;
+    if (isRunningFromLinkedBuild()) {
+        return LOCAL_LINKED_CLI_VERSION;
     }
-    return version;
+    return readCliPackageVersion();
 };
 export const getVersions = () => {
     const cli = getCliVersion();

package/bin/score/client.js

@@ -9,13 +9,28 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { authenticatedFetch } from '../authenticatedFetch.js';
 import { API_URL } from '../constants.js';
-export function getScore(url) {
+export function resolveScoreForUrl(url) {
     return __awaiter(this, void 0, void 0, function* () {
         const endpoint = new URL(`${API_URL}/api/cli/score`);
         endpoint.searchParams.set('url', url);
         const res = yield authenticatedFetch(endpoint.toString(), {
             headers: { Accept: 'application/json' },
         });
+        if (res.status !== 200 && res.status !== 202) {
+            const body = yield res.text().catch(() => '');
+            throw new Error(`API error (${res.status}): ${body || res.statusText}`);
+        }
+        return res.json();
+    });
+}
+export function fetchScoreBySlug(slug) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const endpoint = new URL(`${API_URL}/api/cli/score/${encodeURIComponent(slug)}`);
+        const res = yield authenticatedFetch(endpoint.toString(), {
+            headers: { Accept: 'application/json' },
+        });
+        if (res.status === 202)
+            return null;
         if (!res.ok) {
             const body = yield res.text().catch(() => '');
             throw new Error(`API error (${res.status}): ${body || res.statusText}`);

package/bin/score/index.js

@@ -13,7 +13,9 @@ import chalk from 'chalk';
 import { Text } from 'ink';
 import { terminate } from '../helpers.js';
 import { trackEvent } from '../telemetry/track.js';
-import { getScore } from './client.js';
+import { fetchScoreBySlug, resolveScoreForUrl } from './client.js';
+const POLL_INTERVAL_MS = 3000;
+const POLL_TIMEOUT_MS = 120000;
 function resolveFormat(argv) {
     if (argv.format === 'table' || argv.format === 'plain' || argv.format === 'json')
         return argv.format;
@@ -49,6 +51,18 @@ function renderPlain(checks, prefix = '') {
     }
     return lines;
 }
+function renderTable(score, opts) {
+    const scoreColor = score.overallScore >= 70 ? 'green' : score.overallScore >= 40 ? 'yellow' : 'red';
+    const header = (opts === null || opts === void 0 ? void 0 : opts.stale)
+        ? chalk.bold(`\nAgent Readiness Score — ${score.canonicalUrl}`) +
+            chalk.dim(` (last run ${new Date(score.computedAt).toLocaleString()})\n`)
+        : chalk.bold(`\nAgent Readiness Score — ${score.canonicalUrl}\n`);
+    const lines = [header];
+    lines.push(`  Score: ${chalk[scoreColor].bold(`${score.overallScore}%`)}\n`);
+    lines.push(chalk.bold('  Checks'));
+    lines.push(...renderChecks(score.checks));
+    return lines.join('\n');
+}
 function output(format, text) {
     if (format === 'table') {
         addLog(_jsx(Text, { children: text }));
@@ -57,37 +71,88 @@ function output(format, text) {
         process.stdout.write(text + '\n');
     }
 }
+function sleep(ms) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    });
+}
+function pollForScore(slug, afterIso, onAttempt) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const deadline = Date.now() + POLL_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            yield sleep(POLL_INTERVAL_MS);
+            onAttempt === null || onAttempt === void 0 ? void 0 : onAttempt();
+            const score = yield fetchScoreBySlug(slug);
+            if (!score)
+                continue;
+            if (afterIso === null)
+                return score;
+            if (new Date(score.computedAt).getTime() > new Date(afterIso).getTime())
+                return score;
+        }
+        throw new Error(`Score did not complete within ${POLL_TIMEOUT_MS / 1000}s`);
+    });
+}
 export const scoreHandler = (argv) => __awaiter(void 0, void 0, void 0, function* () {
     const format = resolveFormat(argv);
     try {
         if (format === 'table')
-            addLog(_jsx(SpinnerLog, { message: "Running agent readiness checks..." }));
-        const data = yield getScore(argv.url);
+            addLog(_jsx(SpinnerLog, { message: "Checking agent readiness..." }));
+        const resolved = yield resolveScoreForUrl(argv.url);
+        let final;
+        if (resolved.status === 'ready') {
+            const score = yield fetchScoreBySlug(resolved.slug);
+            if (format === 'table')
+                removeLastLog();
+            if (!score)
+                throw new Error('Score was unexpectedly unavailable');
+            final = score;
+        }
+        else if (resolved.status === 'stale_refresh_queued') {
+            const stale = yield fetchScoreBySlug(resolved.slug);
+            if (format === 'table')
+                removeLastLog();
+            if (!stale)
+                throw new Error('Stale score was unexpectedly unavailable');
+            if (format === 'table') {
+                output('table', renderTable(stale, { stale: true }));
+                addLog(_jsx(SpinnerLog, { message: "Refreshing score in the background..." }));
+            }
+            else {
+                process.stderr.write('Refreshing score in the background...\n');
+            }
+            final = yield pollForScore(resolved.slug, stale.computedAt);
+            if (format === 'table')
+                removeLastLog();
+        }
+        else {
+            if (format === 'table') {
+                removeLastLog();
+                addLog(_jsx(SpinnerLog, { message: "Queued a new scoring run. Waiting for first result..." }));
+            }
+            else {
+                process.stderr.write('Queued a new scoring run. Waiting for first result...\n');
+            }
+            final = yield pollForScore(resolved.slug, null);
+            if (format === 'table')
+                removeLastLog();
+        }
         void trackEvent('cli.score.executed', {
             url: argv.url,
-            score: data.overallScore,
+            score: final.overallScore,
             format,
+            status: resolved.status,
         });
-        if (format === 'table')
-            removeLastLog();
         if (format === 'json') {
-            output(format, JSON.stringify(data, null, 2));
-            yield terminate(0);
-            return;
+            output(format, JSON.stringify(final, null, 2));
         }
-        if (format === 'plain') {
-            const lines = [`SCORE\t${data.overallScore}`, ...renderPlain(data.checks)];
+        else if (format === 'plain') {
+            const lines = [`SCORE\t${final.overallScore}`, ...renderPlain(final.checks)];
             output(format, lines.join('\n'));
-            yield terminate(0);
-            return;
         }
-        const scoreColor = data.overallScore >= 70 ? 'green' : data.overallScore >= 40 ? 'yellow' : 'red';
-        const lines = [];
-        lines.push(chalk.bold(`\nAgent Readiness Score — ${data.url}\n`));
-        lines.push(`  Score: ${chalk[scoreColor].bold(`${data.overallScore}%`)}\n`);
-        lines.push(chalk.bold('  Checks'));
-        lines.push(...renderChecks(data.checks));
-        output(format, lines.join('\n'));
+        else {
+            output(format, renderTable(final));
+        }
         yield terminate(0);
     }
     catch (err) {