@mintlify/cli 4.0.1733 → 4.0.1735

package/__test__/validateRules.test.ts

@@ -0,0 +1,500 @@
+import { getAST } from '@mintlify/common';
+import fs from 'fs-extra';
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import { checkSite, selectRules, UsageError } from '../src/validate/engine.js';
+import { toParseError } from '../src/validate/files.js';
+import { applyEdits, maskNonMarkup, relocate, unmapEdit } from '../src/validate/mdx.js';
+import type { Diagnostic } from '../src/validate/types.js';
+
+vi.mock('@mintlify/prebuild', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('@mintlify/prebuild')>()),
+  categorizeFilePaths: vi.fn(() => {
+    throw new Error('lint must not categorize every file');
+  }),
+}));
+
+const hasErrors = (diagnostics: Diagnostic[]) =>
+  diagnostics.some(({ severity }) => severity === 'error');
+
+/** Runs the file rules (all defaults, or exactly `rules`) the way mint validate --no-build does. */
+const check = async (dir: string, { rules, files }: { rules?: string[]; files?: string[] }) => {
+  const selected = selectRules({ disable: ['all'], enable: rules ?? ['content'] });
+  const result = await checkSite(dir, selected, {
+    selected: files && new Set(files),
+    localSchema: false,
+  });
+  const issues = result.diagnostics.map((diagnostic) => ({
+    ...diagnostic,
+    fixable: diagnostic.fix !== undefined,
+  }));
+  return {
+    issues,
+    filesChecked: result.site.files.filter(({ file }) => !files || files.includes(file)).length,
+  };
+};
+
+const write = (dir: string, files: Record<string, string>) => {
+  fs.writeJSONSync(path.join(dir, 'docs.json'), {
+    name: 'Test',
+    navigation: { pages: ['index'] },
+  });
+  for (const [file, content] of Object.entries(files)) {
+    fs.outputFileSync(path.join(dir, file), content);
+  }
+};
+
+describe('validate rules', () => {
+  let dir: string;
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'lint-'));
+  });
+
+  afterEach(() => {
+    fs.removeSync(dir);
+  });
+
+  const read = (file: string) => fs.readFileSync(path.join(dir, file), 'utf-8');
+
+  /** The edit each diagnostic carries, as the text it would replace and its replacement. */
+  const previews = (issues: Diagnostic[]) =>
+    issues.map(
+      ({ file, fix }) => fix && { before: read(file).slice(fix.start, fix.end), after: fix.text }
+    );
+
+  it('flags lowercase void tags with edits, skipping code and components', async () => {
+    write(dir, {
+      'index.mdx':
+        '---\ntitle: Home\n---\n\nline<br>\n\n<hr>\n\n<img src="/a.png" alt="a">\n\n<Link>x</Link>\n\n`<br>`\n\n```html\n<br>\n```\n',
+    });
+
+    const result = await check(dir, {});
+
+    expect(result.issues.map(({ rule }) => rule)).toEqual(['void-tags', 'void-tags', 'void-tags']);
+    expect(previews(result.issues)).toEqual([
+      { before: '<br>', after: '<br />' },
+      { before: '<hr>', after: '<hr />' },
+      { before: '<img src="/a.png" alt="a">', after: '<img src="/a.png" alt="a" />' },
+    ]);
+  });
+
+  it('skips void tags inside block-quoted code fences', async () => {
+    write(dir, {
+      'index.mdx': '---\ntitle: Home\n---\n\n> ~~~html\n> <br>\n> ~~~\n\nline<br>\n',
+      'other.mdx': '---\ntitle: Other\n---\n\n> ```\n> <br>\n\nafter<br>\n',
+    });
+
+    const result = await check(dir, {});
+
+    expect(result.issues.map(({ file, line }) => [file, line])).toEqual([
+      ['index.mdx', 9],
+      ['other.mdx', 8],
+    ]);
+    expect(previews(result.issues)).toEqual([
+      { before: '<br>', after: '<br />' },
+      { before: '<br>', after: '<br />' },
+    ]);
+  });
+
+  it('keeps an info-string fence line from closing an open fence', async () => {
+    write(dir, {
+      'index.mdx':
+        '---\ntitle: Home\n---\n\n```bash\n$ one\n\nStep 2\n\n```bash\n$ two <br>\n```\n\nafter<br>\n',
+    });
+
+    const result = await check(dir, {});
+
+    expect(result.issues.map(({ line }) => line)).toEqual([14]);
+    expect(previews(result.issues)).toEqual([{ before: '<br>', after: '<br />' }]);
+  });
+
+  it('does not close a block-quoted fence with an info-string fence line', async () => {
+    write(dir, {
+      'index.mdx':
+        '---\ntitle: Home\n---\n\n> ```\n> <br>\n> ```bash\n> <hr>\n> ```\n\nafter<br>\n',
+    });
+
+    const result = await check(dir, {});
+
+    expect(result.issues.map(({ line }) => line)).toEqual([11]);
+    expect(previews(result.issues)).toEqual([{ before: '<br>', after: '<br />' }]);
+  });
+
+  it('skips custom elements, frontmatter, ESM and attribute strings for void tags', async () => {
+    write(dir, {
+      'index.mdx':
+        '---\ntitle: "a<br>b"\n---\n\nimport { A } from "/snippets/a.jsx";\nexport const html = "<br>";\n\n<img-comparison-slider>x</img-comparison-slider>\n\n<Card title="one<br>two">x</Card>\n\n<img src="/a.png" alt="<hr>">\n\n`` a`<br>`b ``\n',
+    });
+
+    const { issues } = await check(dir, { rules: ['void-tags'] });
+
+    expect(issues.map(({ line }) => line)).toEqual([12]);
+    expect(previews(issues)).toEqual([
+      { before: '<img src="/a.png" alt="<hr>">', after: '<img src="/a.png" alt="<hr>" />' },
+    ]);
+  });
+
+  it('leaves escaped void tags alone', async () => {
+    write(dir, { 'index.mdx': '---\ntitle: Home\n---\n\nText \\<br> and \\<img src="/a.png">\n' });
+
+    expect((await check(dir, { rules: ['void-tags'] })).issues).toEqual([]);
+  });
+
+  it('substitutes docs.json variables in snippets before checking them', async () => {
+    write(dir, {
+      'index.mdx': '---\ntitle: Home\n---\n\nok\n',
+      'snippets/note.mdx': 'Hello {{foo.bar}} line<br>\n',
+    });
+    fs.writeJSONSync(path.join(dir, 'docs.json'), {
+      name: 'Test',
+      navigation: { pages: ['index'] },
+      variables: { 'foo.bar': 'a much longer value' },
+    });
+
+    const { issues } = await check(dir, {});
+
+    expect(issues.map(({ rule, line, column }) => [rule, line, column])).toEqual([
+      ['void-tags', 1, 23],
+    ]);
+    expect(previews(issues)).toEqual([{ before: '<br>', after: '<br />' }]);
+  });
+
+  it('leaves void tags that already have a closing tag', async () => {
+    const page = '---\ntitle: Home\n---\n\n<img src="/a.png" alt="a"></img>\n\nline<br></br>\n';
+    write(dir, { 'index.mdx': page });
+
+    expect((await check(dir, { rules: ['void-tags'] })).issues).toEqual([]);
+  });
+
+  it('accepts <MDX> fragments the build preprocesses', async () => {
+    write(dir, {
+      'index.mdx':
+        '---\ntitle: Home\n---\n\n{true ? <MDX>\n```bash\n<root>/{arch}/app.vpkg\n```\n</MDX> : null}\n',
+    });
+
+    expect((await check(dir, {})).issues).toEqual([]);
+  });
+
+  it('walks only Markdown files and respects .mintignore', async () => {
+    write(dir, {
+      '.mintignore': 'drafts/\n',
+      'openapi.yaml': 'openapi: [unclosed\n',
+      'drafts/wip.mdx': '---\ntitle: Wip\n---\n\nline<br>\n',
+      'SKILL.md': 'line<br>\n',
+      'index.mdx': '---\ntitle: Home\n---\n\nline<br>\n',
+    });
+
+    const result = await check(dir, { rules: ['void-tags'] });
+
+    expect(result.filesChecked).toBe(1);
+    expect(result.issues.map(({ file }) => file)).toEqual(['index.mdx']);
+  });
+
+  it('does not mask void tags outside strings, but skips expression strings, multi-line exports and BOM frontmatter', async () => {
+    write(dir, {
+      'index.mdx':
+        '---\ntitle: "a<br>b"\n---\n\nexport const items = [\n  "<br>",\n\n  "<hr>",\n];\n\nText {"<br>"} and {cond && \'<img>\'}\n\nline<br>\n',
+    });
+
+    const { issues } = await check(dir, { rules: ['void-tags'] });
+
+    expect(issues.map(({ line }) => line)).toEqual([13]);
+  });
+
+  it('ends an export block at a blank line once it parses, despite brackets in literals', async () => {
+    write(dir, {
+      'index.mdx':
+        '---\ntitle: Home\n---\n\nexport const css = `\n  .a { color: red;\n`;\n\nfirst<br>\n\nexport const re = /[(]/;\n\nsecond<br>\n\nexport const items = [\n  "<br>",\n\n  "<hr>",\n];\n\nthird<br>\n',
+    });
+
+    const { issues } = await check(dir, { rules: ['void-tags'] });
+
+    expect(issues.map(({ line }) => line)).toEqual([9, 13, 21]);
+  });
+
+  it('masks regex literals in expression value position but not division', async () => {
+    write(dir, {
+      'index.mdx':
+        "---\ntitle: Home\n---\n\n{items.map((s) => s.replace(/<br>/g, ''))}\n\n{total / width / 2} and<br>\n\n{value.replace(/\\/<hr>/, '')}\n\nline<br>\n",
+    });
+
+    const { issues } = await check(dir, { rules: ['void-tags'] });
+
+    expect(issues.map(({ rule, line }) => [rule, line])).toEqual([
+      ['void-tags', 7],
+      ['void-tags', 11],
+    ]);
+    expect(previews(issues)).toEqual([
+      { before: '<br>', after: '<br />' },
+      { before: '<br>', after: '<br />' },
+    ]);
+  });
+
+  it('masks line comments inside expressions', async () => {
+    write(dir, {
+      'index.mdx':
+        '---\ntitle: Home\n---\n\n{\n// <br>\n}\n\n{(\n  // <hr>\n  value\n)}\n\n{total // <br>\n}\n\nline<br>\n',
+    });
+
+    const { issues } = await check(dir, { rules: ['void-tags'] });
+
+    expect(issues.map(({ line }) => line)).toEqual([17]);
+  });
+
+  it('treats quotes in JSX text inside an expression as text, not strings', async () => {
+    write(dir, {
+      'index.mdx':
+        '---\ntitle: Home\n---\n\n{cond && <p>Don\'t {"<br>"} miss this</p>}\n\nline<br>\n\n{list.map((item) => <li key={item}>It\'s {item}</li>)}\n\nmore<hr>\n',
+    });
+
+    const { issues } = await check(dir, { rules: ['void-tags'] });
+
+    expect(issues.map(({ line }) => line)).toEqual([7, 11]);
+  });
+
+  it('keeps file order when linting many files concurrently', async () => {
+    const names = Array.from(
+      { length: 40 },
+      (_, index) => `page-${String(index).padStart(2, '0')}.mdx`
+    );
+    write(dir, Object.fromEntries(names.map((name) => [name, '---\ntitle: T\n---\n\nline<br>\n'])));
+
+    const result = await check(dir, { rules: ['void-tags'] });
+
+    const flagged = result.issues.map(({ file }) => file);
+    expect(flagged).toEqual([...flagged].sort());
+    expect(flagged).toHaveLength(40);
+  });
+
+  it('rejects unknown rule ids', async () => {
+    write(dir, { 'index.mdx': '---\ntitle: Home\n---\n' });
+
+    await expect(check(dir, { rules: ['nope'] })).rejects.toThrow('unknown rule or group "nope"');
+  });
+
+  it('reports every file that fails to parse in one run, with its position', async () => {
+    write(dir, {
+      'index.mdx': '---\ntitle: Home\n---\n\nok\n',
+      'a.mdx': '---\ntitle: A\n---\n\n<Note>\nunclosed\n',
+      'b.mdx': '---\ntitle: B\n---\n\nText {broken\n',
+    });
+
+    const result = await check(dir, {});
+    const parseErrors = result.issues.filter(({ rule }) => rule === 'parse-error');
+
+    expect(parseErrors.map(({ file }) => file).sort()).toEqual(['a.mdx', 'b.mdx']);
+    for (const issue of parseErrors) {
+      expect(issue).toMatchObject({ severity: 'error', fixable: false });
+      expect(issue.line).toBeGreaterThan(0);
+      expect(issue.message).toContain('(other checks were skipped for this file)');
+    }
+    expect(hasErrors(result.issues)).toBe(true);
+  });
+
+  it('still runs parse-error when --rules picks only other rules', async () => {
+    write(dir, { 'index.mdx': '---\ntitle: Home\n---\n\n<Note>\nunclosed\n' });
+
+    const result = await check(dir, { rules: ['void-tags'] });
+
+    expect(result.issues.map(({ rule }) => rule)).toEqual(['parse-error']);
+    await expect(check(dir, { rules: ['parse-error'] })).rejects.toThrow(
+      "parse-error always runs and can't be disabled"
+    );
+  });
+
+  it('lints snippets', async () => {
+    write(dir, {
+      'index.mdx': '---\ntitle: Home\n---\n\nok\n',
+      'snippets/note.mdx': '---\ntitle: Same\n---\n\nline<br>\n',
+    });
+
+    const result = await check(dir, {});
+
+    expect(result.issues.map(({ file, rule }) => [file, rule])).toEqual([
+      ['snippets/note.mdx', 'void-tags'],
+    ]);
+  });
+
+  it('rejects --files that name no page or snippet of the site', async () => {
+    write(dir, { 'index.mdx': '---\ntitle: Home\n---\n\nok\n', 'README.md': '# Readme\n' });
+
+    await expect(check(dir, { files: ['README.md'] })).rejects.toThrow(UsageError);
+  });
+
+  it('only lints the files it is given', async () => {
+    write(dir, {
+      'index.mdx': '---\ntitle: Home\n---\n\nline<br>\n',
+      'other.mdx': '---\ntitle: Other\n---\n\nline<br>\n',
+    });
+
+    const result = await check(dir, { files: ['other.mdx'] });
+
+    expect(result.filesChecked).toBe(1);
+    expect(result.issues.map(({ file }) => file)).toEqual(['other.mdx']);
+  });
+
+  it('never reads the content of unselected files in the check pass', async () => {
+    write(dir, {
+      'index.mdx': '---\ntitle: Home\n---\n\nline<br>\n',
+      'other.mdx': '---\ntitle: Other\n---\n\nline<br>\n',
+    });
+    const spy = vi.spyOn(fsp, 'readFile');
+
+    const result = await check(dir, { rules: ['void-tags'], files: ['other.mdx'] });
+
+    const reads = spy.mock.calls.map(([file]) => String(file));
+    spy.mockRestore();
+    expect(reads.some((file) => file.endsWith('other.mdx'))).toBe(true);
+    expect(reads.some((file) => file.endsWith('index.mdx'))).toBe(false);
+    expect(result.issues.map(({ file }) => file)).toEqual(['other.mdx']);
+  });
+
+  it('skips void tags in block-quoted fences and inline code', async () => {
+    write(dir, {
+      'index.mdx': '---\ntitle: Home\n---\n\n> Quote\n>\n> ```html\n> <br>\n> ```\n\nSee `<hr>`.\n',
+    });
+
+    expect((await check(dir, { rules: ['void-tags'] })).issues).toEqual([]);
+  });
+
+  it('flags void tags outside code on a page that fails to parse', async () => {
+    write(dir, {
+      'index.mdx':
+        '---\ntitle: Home\n---\n\n<Card title="a">\n\nLine<br>\n\n```html\n<br>\n```\n\nSee `<hr>`.\n\n</Card>\n',
+    });
+
+    const { issues } = await check(dir, { rules: ['void-tags'] });
+
+    expect(issues.map(({ line }) => line)).toEqual([7]);
+    expect(previews(issues)).toEqual([{ before: '<br>', after: '<br />' }]);
+  });
+
+  it('does not pair backticks across table cells', async () => {
+    write(dir, {
+      'index.mdx': '---\ntitle: Home\n---\n\n| A | B |\n| - | - |\n| `open | <br> close` |\n',
+    });
+
+    const { issues } = await check(dir, { rules: ['void-tags'] });
+
+    expect(issues.map(({ line, column }) => [line, column])).toEqual([[7, 11]]);
+  });
+
+  it('skips inline code inside table cells', async () => {
+    write(dir, {
+      'index.mdx': '---\ntitle: Home\n---\n\n| A | B |\n| - | - |\n| `a | b` | `<br>` |\n',
+    });
+
+    expect((await check(dir, { rules: ['void-tags'] })).issues).toEqual([]);
+  });
+
+  it('does not treat an indented line inside JSX as code', async () => {
+    write(dir, { 'index.mdx': '---\ntitle: Home\n---\n\n<Card>\n    line<br>\n</Card>\n' });
+
+    const { issues } = await check(dir, { rules: ['void-tags'] });
+
+    expect(issues.map(({ line, column }) => [line, column])).toEqual([[6, 9]]);
+  });
+
+  it('does not open inline code at an escaped backtick', async () => {
+    write(dir, { 'index.mdx': '---\ntitle: Home\n---\n\nText \\`a<br>\\` and `b\\`<hr>\n' });
+
+    const { issues } = await check(dir, { rules: ['void-tags'] });
+
+    expect(previews(issues)).toEqual([
+      { before: '<br>', after: '<br />' },
+      { before: '<hr>', after: '<hr />' },
+    ]);
+  });
+});
+
+describe('maskNonMarkup', () => {
+  it('masks a regex literal after typeof', () => {
+    expect(maskNonMarkup('{typeof /<br>/}')).toBe('{typeof /    /}');
+  });
+
+  it('masks template strings but keeps the code inside ${}', () => {
+    expect(maskNonMarkup('{`a\n\n${x + "<hr>"}\n\nb`}')).toBe('{` \n\n${x + "    "}\n\n `}');
+  });
+
+  it('keeps masking after an expression the tokenizer rejects', () => {
+    expect(maskNonMarkup('## A {#1-intro}\n\n{"<br>"}')).toBe('## A {#1-intro}\n\n{"    "}');
+  });
+
+  it('blanks an escaped tag and does not open an expression at an escaped brace', () => {
+    expect(maskNonMarkup('\\<br> \\{"<br>"} {"<br>"}')).toBe('\\ br> \\{"<br>"} {"    "}');
+  });
+});
+
+describe('toParseError', () => {
+  it('reads the position from the reason of an unclosed JSX tag', () => {
+    let error: unknown;
+    try {
+      getAST('---\ntitle: A\n---\n\n<Note>\nunclosed\n', 'a.mdx');
+    } catch (caught) {
+      error = caught;
+    }
+
+    expect(toParseError(error)).toEqual({
+      line: 5,
+      column: 1,
+      message: 'Expected a closing tag for `<Note>`',
+    });
+  });
+});
+
+describe('applyEdits', () => {
+  it('keeps a replacement that an insertion at its start precedes', () => {
+    expect(
+      applyEdits('a<br>b', [
+        { start: 1, end: 5, text: '<br />' },
+        { start: 1, end: 1, text: 'x' },
+      ])
+    ).toBe('ax<br />b');
+  });
+});
+
+describe('mapping back through edits', () => {
+  const inserted = [
+    { content: 'ab', edits: [{ start: 1, end: 1, text: 'XY' }] },
+    { content: 'aXYb', edits: [] },
+  ];
+  const deleted = [
+    { content: 'aXYb', edits: [{ start: 1, end: 3, text: '' }] },
+    { content: 'ab', edits: [] },
+  ];
+
+  it('snaps positions at or inside inserted text to the insertion point', () => {
+    expect(relocate(inserted, 1, { line: 1, column: 2 })).toEqual({ line: 1, column: 2 });
+    expect(relocate(inserted, 1, { line: 1, column: 3 })).toEqual({ line: 1, column: 2 });
+    expect(relocate(inserted, 1, { line: 1, column: 5 })).toEqual({ line: 1, column: 3 });
+  });
+
+  it('places a position at a deletion after the deleted text', () => {
+    expect(relocate(deleted, 1, { line: 1, column: 2 })).toEqual({ line: 1, column: 4 });
+  });
+
+  it('maps an edit at an insertion point to before the inserted text and rejects one inside it', () => {
+    expect(unmapEdit(inserted, 1, { start: 1, end: 1, text: 'Z' })).toEqual({
+      start: 1,
+      end: 1,
+      text: 'Z',
+    });
+    expect(unmapEdit(inserted, 1, { start: 2, end: 2, text: 'Z' })).toBeUndefined();
+    expect(unmapEdit(inserted, 1, { start: 3, end: 3, text: 'Z' })).toEqual({
+      start: 1,
+      end: 1,
+      text: 'Z',
+    });
+  });
+
+  it('maps an edit at a deletion point to before the deleted text', () => {
+    expect(unmapEdit(deleted, 1, { start: 1, end: 1, text: 'Z' })).toEqual({
+      start: 1,
+      end: 1,
+      text: 'Z',
+    });
+  });
+});

package/bin/agent-claim.js

@@ -45,8 +45,8 @@ const completedClaimSchema = z.object({
     identity: agentIdentityAssertionSchema,
 });
 const signupSchema = z.object({ orgId: z.string().min(1), claimed: z.literal(true) });
-export function claimDeployment(options_1, warn_1) {
-    return __awaiter(this, arguments, void 0, function* (options, warn, progress = () => { }) {
+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();
@@ -66,14 +66,7 @@ export function claimDeployment(options_1, warn_1) {
         if (new URL(discovery.issuer).origin !== new URL(credentials.issuer).origin) {
             throw new Error('Saved agent credentials belong to another issuer.');
         }
-        const save = (value) => __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield saveAgentCredentials(apiUrl, directory, value);
-            }
-            catch (_a) {
-                warn('Could not save claimed credentials to the keyring. Continuing for this run; a retry may not recover the completed claim.');
-            }
-        });
+        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`, {

package/bin/agent-credentials.js

@@ -7,11 +7,25 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 import { createHash } from 'node:crypto';
+import fs from 'node:fs/promises';
 import path from 'node:path';
 import { z } from 'zod';
+import { CONFIG_DIR } from './constants.js';
 import { getKeytar } from './keyring.js';
 const service = 'mintlify-agent';
+const fallbackFile = () => path.join(CONFIG_DIR, 'agent-credentials.json');
 export const agentCredentialsSchema = z.object({
     registrationId: z.string().min(1),
     issuer: z.url(),
@@ -29,13 +43,69 @@ function projectAccount(apiUrl, directory) {
 function registrationAccount(apiUrl, registrationId) {
     return `${new URL(apiUrl).origin}:${registrationId}`;
 }
+function readFallback() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return z
+                .record(z.string(), z.string())
+                .parse(JSON.parse(yield fs.readFile(fallbackFile(), 'utf-8')));
+        }
+        catch (_a) {
+            return {};
+        }
+    });
+}
+function writeFallback(entries) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield fs.mkdir(CONFIG_DIR, { recursive: true });
+        const temp = `${fallbackFile()}.${process.pid}.tmp`;
+        yield fs.writeFile(temp, JSON.stringify(entries, null, 2), { mode: 0o600 });
+        yield fs.chmod(temp, 0o600);
+        yield fs.rename(temp, fallbackFile());
+    });
+}
+function getSecret(account) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let keyringError;
+        try {
+            const value = yield (yield getKeytar()).getPassword(service, account);
+            if (value)
+                return value;
+        }
+        catch (error) {
+            keyringError = error;
+        }
+        const value = (yield readFallback())[account];
+        if (value)
+            return value;
+        if (keyringError)
+            throw keyringError;
+        return null;
+    });
+}
+function setSecret(account, value) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield (yield getKeytar()).setPassword(service, account, value);
+        }
+        catch (_a) {
+            yield writeFallback(Object.assign(Object.assign({}, (yield readFallback())), { [account]: value }));
+            yield getKeytar()
+                .then((keytar) => keytar.deletePassword(service, account))
+                .catch(() => { });
+            return;
+        }
+        const _b = yield readFallback(), _c = account, stale = _b[_c], rest = __rest(_b, [typeof _c === "symbol" ? _c : _c + ""]);
+        if (stale)
+            yield writeFallback(rest).catch(() => { });
+    });
+}
 export function loadAgentCredentials(apiUrl, directory) {
     return __awaiter(this, void 0, void 0, function* () {
-        const keytar = yield getKeytar();
-        const registrationId = yield keytar.getPassword(service, projectAccount(apiUrl, directory));
+        const registrationId = yield getSecret(projectAccount(apiUrl, directory));
         if (!registrationId)
             return null;
-        const value = yield keytar.getPassword(service, registrationAccount(apiUrl, registrationId));
+        const value = yield getSecret(registrationAccount(apiUrl, registrationId));
         if (!value)
             throw new Error('Saved agent credentials are missing. Use --new to create another site.');
         const credentials = agentCredentialsSchema.parse(JSON.parse(value));
@@ -48,8 +118,7 @@ export function loadAgentCredentials(apiUrl, directory) {
 export function saveAgentCredentials(apiUrl, directory, credentials) {
     return __awaiter(this, void 0, void 0, function* () {
         const value = agentCredentialsSchema.parse(credentials);
-        const keytar = yield getKeytar();
-        yield keytar.setPassword(service, registrationAccount(apiUrl, value.registrationId), JSON.stringify(value));
-        yield keytar.setPassword(service, projectAccount(apiUrl, directory), value.registrationId);
+        yield setSecret(registrationAccount(apiUrl, value.registrationId), JSON.stringify(value));
+        yield setSecret(projectAccount(apiUrl, directory), value.registrationId);
     });
 }

package/bin/cli.js

@@ -43,6 +43,7 @@ import { sendPublishPrompt, signup } from './signup.js';
 import { status, getCliSubdomains } from './status.js';
 import { trackTelemetryPreferenceChange } from './telemetry/track.js';
 import { update } from './update.js';
+import { runLintStep, splitList } from './validate/command.js';
 import { renderWelcome } from './welcome.js';
 import { workflowsBuilder } from './workflows/index.js';
 // The branded welcome screen replaces yargs' default help, but only for an
@@ -114,7 +115,7 @@ export const cli = ({ packageName = 'mint' }) => {
         .example('$0 claim --code ABCDEFGH', 'Finish the claim with the code from the user')
         .epilog('Run from the same directory as mint deploy, or pass --directory. Ask the user to open the claim link and return the code. The CLI reads saved credentials internally; do not read or print keychain secrets. Retry the same command if Mintlify signup fails.'), (argv) => __awaiter(void 0, void 0, void 0, function* () {
         try {
-            const message = yield claimDeployment({ apiUrl: API_URL, directory: argv.directory, code: argv.code, email: argv.email }, (message) => process.stderr.write(`Warning: ${message}\n`), (message) => process.stderr.write(`${message}\n`));
+            const message = yield claimDeployment({ apiUrl: API_URL, directory: argv.directory, code: argv.code, email: argv.email }, (message) => process.stderr.write(`${message}\n`));
             process.stdout.write(`${message}\n`);
             yield terminate(0);
         }
@@ -303,9 +304,29 @@ export const cli = ({ packageName = 'mint' }) => {
         type: 'boolean',
         default: false,
         description: 'Disable OpenAPI file generation',
+    })
+        .option('files', {
+        type: 'string',
+        array: true,
+        description: 'Limit page checks to these files or globs; site-wide checks and the build still cover the whole site',
+    })
+        .option('enable', {
+        type: 'string',
+        array: true,
+        coerce: splitList,
+        description: 'Turn on rules or groups (comma-separated), for example after --disable all',
+    })
+        .option('disable', {
+        type: 'string',
+        array: true,
+        coerce: splitList,
+        description: 'Turn off rules or groups (comma-separated), or all; parse errors are still reported',
     })
         .usage('usage: mintlify validate [options]')
         .example('mintlify validate', 'validate the build'), (argv) => __awaiter(void 0, void 0, void 0, function* () {
+        const lintPassed = yield runLintStep(argv);
+        if (!lintPassed)
+            return;
         if (!argv['disable-openapi']) {
             let openApiFilenames = [];
             try {