@mintlify/cli 4.0.1802 → 4.0.1804

package/bin/vendor/converter.js

@@ -6661,7 +6661,10 @@ function serializeCommentThreadIds(ids) {
 }
 
 // ../editor/dist/converter/utils/static-html-source.js
-var STATIC_HTML_TYPES = /* @__PURE__ */ new Set([BLOCK_TYPES.staticHTML, BLOCK_TYPES.inlineStaticHTML]);
+var STATIC_HTML_TYPES = /* @__PURE__ */ new Set([
+  BLOCK_TYPES.staticHTML,
+  BLOCK_TYPES.inlineStaticHTML
+]);
 function keepsStaticHtmlSource(tagName, hasStaticHtmlParent) {
   return !hasStaticHtmlParent || tagName === "svg";
 }
@@ -28472,21 +28475,58 @@ function renderTooltip(state, node2, renderInline2) {
     state.write(`<${BLOCK_TYPES.tooltip}${attrs2 ? ` ${attrs2}` : ""} />`);
   }
 }
-function renderStaticHTML(state, node2, renderContent2) {
+var sourceTexts = /* @__PURE__ */ new WeakMap();
+function parsedText(node2, source) {
+  try {
+    let text2;
+    mdxToPm(source, { schema: node2.type.schema }).doc.descendants((child) => {
+      if (text2 === void 0 && STATIC_HTML_TYPES.has(child.type.name))
+        text2 = child.textContent;
+      return text2 === void 0;
+    });
+    return text2;
+  } catch (_a2) {
+    return void 0;
+  }
+}
+function sourceText(node2, mdxJsxNode, source) {
+  if (!sourceTexts.has(mdxJsxNode))
+    sourceTexts.set(mdxJsxNode, parsedText(node2, source));
+  return sourceTexts.get(mdxJsxNode);
+}
+function textDiffersFromSource(node2, mdxJsxNode, source) {
+  if (node2.childCount === 0 && !node2.inlineContent)
+    return false;
+  const text2 = sourceText(node2, mdxJsxNode, source);
+  return text2 !== void 0 && text2 !== node2.textContent;
+}
+function sourceOpeningTag(mdxJsxNode) {
+  return stringifyMdxNode([Object.assign(Object.assign({}, mdxJsxNode), { children: [], data: void 0 })]).trim().replace(/^<|\s*\/>$/g, "");
+}
+function renderStaticHTML(state, node2, renderContent2, renderInline2) {
   var _a2;
   const inline = state.inTable || node2.type.name === BLOCK_TYPES.inlineStaticHTML;
   const escapeTablePipes = (value) => state.escapesPipes ? value.replace(/\|/g, "&#124;") : value;
+  const inlineSource = (value) => escapeTablePipes(value.replace(/\s*\n\s*/g, " ").trim());
   const mdxJsxNode = node2.attrs.mdxJsxNode;
+  let sourceTag;
   if (mdxJsxNode) {
     try {
       const str = stringifyMdxNode([mdxJsxNode]);
-      if (inline) {
-        state.write(escapeTablePipes(str.replace(/\s*\n\s*/g, " ").trim()));
-      } else {
-        state.write(str);
-        state.closeBlock();
+      if (!textDiffersFromSource(node2, mdxJsxNode, str)) {
+        if (inline) {
+          state.write(inlineSource(str));
+        } else {
+          state.write(str);
+          state.closeBlock();
+        }
+        return;
+      }
+      if (mdxJsxNode.name) {
+        sourceTag = sourceOpeningTag(mdxJsxNode);
+        if (inline)
+          sourceTag = inlineSource(sourceTag);
       }
-      return;
     } catch (_b) {
     }
   }
@@ -28499,13 +28539,16 @@ function renderStaticHTML(state, node2, renderContent2) {
   }).filter(Boolean);
   const expressionProps = getExpressionAttrStrings(attributes);
   const attrs2 = [...namedAttrs, ...expressionProps].join(" ");
-  const tag2 = attrs2 ? `${tagName} ${attrs2}` : tagName;
+  const tag2 = sourceTag !== null && sourceTag !== void 0 ? sourceTag : attrs2 ? `${tagName} ${attrs2}` : tagName;
   if (node2.childCount > 0) {
     state.write(`<${tag2}>`);
     if (!inline)
       state.ensureNewLine();
-    renderContent2(state, node2);
-    state.write(`</${tagName}>`);
+    if (node2.inlineContent)
+      renderInline2(state, node2);
+    else
+      renderContent2(state, node2);
+    state.write(`</${sourceTag ? mdxJsxNode.name : tagName}>`);
   } else {
     state.write(`<${tag2} />`);
   }
@@ -29116,7 +29159,7 @@ function renderNode(state, node2, _parent, _index) {
       break;
     case BLOCK_TYPES.staticHTML:
     case BLOCK_TYPES.inlineStaticHTML:
-      renderStaticHTML(state, node2, renderContent);
+      renderStaticHTML(state, node2, renderContent, boundRenderInline);
       break;
     case BLOCK_TYPES.unknownTag:
     case BLOCK_TYPES.inlineUnknownTag:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mintlify/cli",
-  "version": "4.0.1802",
+  "version": "4.0.1804",
   "description": "The Mintlify CLI",
   "engines": {
     "node": ">=18.0.0"
@@ -87,7 +87,7 @@
     "keytar": "7.9.0"
   },
   "devDependencies": {
-    "@mintlify/editor": "0.0.619",
+    "@mintlify/editor": "0.0.620",
     "@mintlify/ts-config": "2.0.2",
     "@tsconfig/recommended": "1.0.2",
     "@types/detect-port": "1.3.2",
@@ -106,5 +106,5 @@
     "vitest": "2.1.9",
     "vitest-mock-process": "1.0.4"
   },
-  "gitHead": "5c3ece93a21155964942953f6e889233ace06eaa"
+  "gitHead": "97f5b1f90612968ac5d9a8782bbf6e15d0690252"
 }

package/src/agent-deployment.ts

@@ -10,6 +10,7 @@ const readySchema = z.object({
   remote: z.url(),
   branch: z.literal('main'),
   expiresAt: z.iso.datetime(),
+  orgSlug: z.string().min(1).optional(),
 });
 const existingSchema = z.discriminatedUnion('status', [
   readySchema.extend({ code: z.literal('deployment_already_exists') }),
@@ -43,7 +44,12 @@ const trustedReposSchema = z.object({
 
 export type AgentSite = z.infer<typeof readySchema>;
 export type AgentWriteToken = z.infer<typeof writeTokenSchema>;
-export type AgentSiteSettings = { subdomain: string; orgName?: string };
+export type AgentProjectType = 'site' | 'workspace';
+export type AgentSiteSettings = {
+  subdomain: string;
+  orgName?: string;
+  projectType?: AgentProjectType;
+};
 
 export async function provisionAgentSite(
   apiUrl: string,

package/src/cli.tsx

@@ -22,10 +22,11 @@ import { comingSoon } from './comingSoon.js';
 import { setTelemetryEnabled } from './config.js';
 import { getConfigValue, setConfigValue, clearConfigValue } from './config.js';
 import { API_URL } from './constants.js';
+import { pushBaseCheckout } from './deploy-base.js';
 import { deployFromGithubActions, isGithubActions } from './deploy-github-actions.js';
 import { formatGithubSetup, setupGithubDeployment } from './deploy-github-setup.js';
 import { DEPLOY_HELP, deploymentInstructions } from './deploy-instructions.js';
-import { formatDeployment, prepareAgentDeployment } from './deploy.js';
+import { agentEditorUrl, formatDeployment, prepareAgentDeployment } from './deploy.js';
 import { FEEDBACK_CATEGORIES, feedback } from './feedback.js';
 import { formatHandler } from './format.js';
 import {
@@ -235,13 +236,29 @@ export const cli = ({ packageName = 'mint' }: { packageName?: string }) => {
               default: false,
               description: 'With --github, overwrite an existing .github/workflows/mintlify.yml',
             })
+            .option('base', {
+              type: 'boolean',
+              description:
+                'Provision a base, edited in the Mintlify editor, instead of a docs site',
+            })
+            .option('push', {
+              type: 'string',
+              description: 'With --base, rebase this clone onto main and push it to the base',
+            })
+            .implies('push', 'base')
+            .conflicts('push', 'email')
             .conflicts('github', 'email')
+            .conflicts('base', 'github')
             .example('$0 deploy --subdomain my-docs', 'Provision a site without signing in')
             .example(
               '$0 deploy --email you@example.com',
               'Get repository access and a claim link for the current site'
             )
             .example('$0 deploy --new --subdomain another-site', 'Create another anonymous site')
+            .example(
+              '$0 deploy --base --subdomain my-base',
+              'Provision a base and get its editor link'
+            )
             .example(
               '$0 deploy --github --subdomain my-docs',
               'Deploy the site from GitHub Actions on every push to the default branch'
@@ -288,12 +305,21 @@ export const cli = ({ packageName = 'mint' }: { packageName?: string }) => {
                 subdomain: argv.subdomain,
                 orgName: argv.orgName,
                 newSite: argv.new,
+                base: argv.base,
               },
               (message) => {
                 process.stderr.write(`Warning: ${message}\n`);
               },
               (message) => process.stderr.write(`${message}\n`)
             );
+            if (argv.push && result.status === 'ready') {
+              await pushBaseCheckout(argv.push, result.write);
+              process.stdout.write(
+                `Pushed ${argv.push} to the base.\nEditor: ${agentEditorUrl(result.site)}\n`
+              );
+              await terminate(0);
+              return;
+            }
             process.stdout.write(`${formatDeployment(result, API_URL)}\n`);
             let claimUrl: string | undefined;
             if (argv.email && result.status === 'ready') {

package/src/deploy-base.ts

@@ -0,0 +1,18 @@
+import type { AgentWriteToken } from './agent-deployment.js';
+import { git } from './deploy-github-actions.js';
+
+export async function pushBaseCheckout(checkout: string, write: AgentWriteToken): Promise<void> {
+  const env = {
+    ...process.env,
+    GIT_CONFIG_COUNT: '1',
+    GIT_CONFIG_KEY_0: `http.${write.remote}.extraHeader`,
+    GIT_CONFIG_VALUE_0: `Authorization: Bearer ${write.token}`,
+  };
+  await git(['fetch', write.remote, write.branch], checkout, env);
+  await git(['rebase', 'FETCH_HEAD'], checkout, env).catch(() => {
+    throw new Error(
+      `Could not rebase ${checkout} onto the latest ${write.branch}. Resolve the conflicts, run git rebase --continue, then rerun mint deploy --base --push ${checkout}.`
+    );
+  });
+  await git(['push', write.remote, `HEAD:refs/heads/${write.branch}`], checkout, env);
+}

package/src/deploy-github-actions.ts

@@ -44,7 +44,7 @@ async function getGithubOidcToken(env: NodeJS.ProcessEnv, audience: string): Pro
   return parsed.data.value;
 }
 
-function git(args: string[], cwd: string, env: NodeJS.ProcessEnv): Promise<string> {
+export function git(args: string[], cwd: string, env: NodeJS.ProcessEnv): Promise<string> {
   return new Promise((resolve, reject) => {
     const child = spawn('git', args, { cwd, env, stdio: ['ignore', 'pipe', 'inherit'] });
     let out = '';

package/src/deploy-instructions.ts

@@ -9,6 +9,7 @@ export const DEPLOY_HELP = [
   'To claim an existing site without provisioning, run mint claim --email <email>. Show the link to the user and ask them to return the displayed code. Then run mint claim --code <code>. Use the original documentation directory for both commands, or pass --directory.',
   'The output contains a short-lived write token. Do not paste it into public logs or save it in a Git remote.',
   'Pass --github from the root of a GitHub repository to deploy on every push: it trusts the repository (via the gh CLI and the origin remote) to deploy the site and writes .github/workflows/mintlify.yml. Commit and push that workflow. Pass --directory to deploy a docs subdirectory of the repository as the site root. Use --force to overwrite a different existing workflow.',
+  'Pass --base to provision a base instead of a docs site. The output has the claim steps, a clone command, and the editor link; there is no site URL. Commit in the clone, then run mint deploy --base --push <clone-directory> to publish. --base cannot be combined with --github.',
   'In GitHub Actions (GITHUB_ACTIONS=true), no agent credentials are used: the workflow needs `permissions: id-token: write`, --subdomain is required, and the current commit is force-pushed to the site from a trusted repository and branch.',
 ].join('\n\n');
 
@@ -17,8 +18,38 @@ export const CLAIM_INSTRUCTIONS = [
   'After they provide it, run mint deploy --email <their-email> from the same documentation directory (or repeat --directory). This reuses the site and returns its claim link.',
 ];
 
+const baseClaimStep = (claimUrl?: string) =>
+  claimUrl
+    ? [
+        `3. Claim the base last. Send the user this link: ${claimUrl}`,
+        '   They sign in and get a code. When they give it to you, run: mint claim --code <code>',
+      ]
+    : [
+        '3. Claim the base last. Ask the user for their email (never invent one), then run:',
+        '   mint deploy --base --email <their-email>',
+        '   Send the user the claim link it prints. They sign in and get a code. When they give it to you, run: mint claim --code <code>',
+      ];
+
+function baseInstructions(result: Extract<DeployResult, { status: 'ready' }>, claimUrl?: string) {
+  const { site, write } = result;
+  const checkout = site.subdomain;
+  return [
+    '\nNext steps:',
+    `1. Clone the base into ./${checkout}:`,
+    `   git -c http.${write.remote}.extraHeader="Authorization: Bearer ${write.token}" clone ${write.remote} ${checkout}`,
+    `   The clone command works until ${write.tokenExpiresAt}. Run mint deploy --base again for a fresh one.`,
+    `2. Commit your changes in ./${checkout}, then publish them:`,
+    `   mint deploy --base --push ${checkout}`,
+    '   This rebases onto the latest main and pushes. Do not run git push yourself.',
+    ...baseClaimStep(claimUrl),
+    '   After the claim, the user opens the base at the editor link above and edits it there. The CLI can no longer push to it.',
+    'Run every mint command from this directory (or repeat --directory).',
+  ].join('\n');
+}
+
 export function deploymentInstructions(result: DeployResult, claimUrl?: string): string {
   if (result.status !== 'ready') return '';
+  if (result.projectType === 'workspace') return baseInstructions(result, claimUrl);
   return [
     '\nNext steps:',
     '1. Clone the hosted repository into a separate directory. Do not replace the user’s existing Git remote.',

package/src/deploy.ts

@@ -14,10 +14,12 @@ import {
 import {
   getAgentWriteToken,
   provisionAgentSite,
+  type AgentProjectType,
   type AgentSite,
   type AgentWriteToken,
 } from './agent-deployment.js';
 import { getAgentSiteMetadata, setAgentSiteMetadata } from './config.js';
+import { DASHBOARD_URL } from './constants.js';
 import { trackEvent } from './telemetry/track.js';
 
 export type DeployOptions = {
@@ -26,12 +28,14 @@ export type DeployOptions = {
   subdomain?: string;
   orgName?: string;
   newSite?: boolean;
+  base?: boolean;
 };
 
 export type DeployResult =
   | { status: 'claimed' }
   | {
       status: 'ready';
+      projectType: AgentProjectType;
       site: AgentSite;
       write: AgentWriteToken;
       created: boolean;
@@ -61,6 +65,7 @@ export async function prepareAgentDeployment(
   const subdomain = options.subdomain ?? (options.newSite ? undefined : previous?.subdomain);
   if (!subdomain) throw new Error('Choose a site name with --subdomain <name>.');
   const discovery = await discoverAgentAuth(apiUrl);
+  const projectType: AgentProjectType = options.base ? 'workspace' : 'site';
 
   const save = (credentials: AgentCredentials) =>
     saveAgentCredentials(apiUrl, directory, credentials);
@@ -77,10 +82,11 @@ export async function prepareAgentDeployment(
     if (identity.registrationId !== credentials.registrationId)
       throw new Error('Agent identity does not match the saved registration.');
     if (identity.identityType === 'user_bound') return { status: 'claimed' };
-    progress('Provisioning the site and repository...');
+    progress(`Provisioning the ${options.base ? 'base' : 'site'} and repository...`);
     const site = await provisionAgentSite(apiUrl, authenticated.accessToken, {
       subdomain,
       orgName: options.orgName,
+      ...(options.base && { projectType }),
     });
     if (site.status === 'expired') {
       warn('The previous anonymous site expired. Creating a new registration and site.');
@@ -103,7 +109,14 @@ export async function prepareAgentDeployment(
     const write = await getAgentWriteToken(apiUrl, authenticated.accessToken);
     if (write.remote !== site.remote)
       throw new Error('Repository credentials do not match the provisioned site.');
-    return { status: 'ready', site, write, created: site.created, credentials: authenticated };
+    return {
+      status: 'ready',
+      projectType,
+      site,
+      write,
+      created: site.created,
+      credentials: authenticated,
+    };
   }
   throw new Error('The new anonymous site is already expired. Please retry later.');
 }
@@ -116,10 +129,28 @@ export function agentSiteUrl(apiUrl: string, subdomain: string): string {
   return new URL(`https://${subdomain}.${domain}`).toString();
 }
 
+export function agentEditorUrl(site: Pick<AgentSite, 'subdomain' | 'orgSlug'>): string {
+  return site.orgSlug
+    ? new URL(`/${site.orgSlug}/${site.subdomain}/editor`, DASHBOARD_URL).toString()
+    : new URL(DASHBOARD_URL).toString();
+}
+
 export function formatDeployment(result: DeployResult, apiUrl: string): string {
   if (result.status === 'claimed')
     return 'This site has been claimed. Manage it in the Mintlify dashboard. Use mint deploy --new --subdomain <name> to create another site.';
   const { site, write } = result;
+  const access = [
+    `Repository: ${site.remote}`,
+    `Branch: ${site.branch}`,
+    `Write token: ${write.token}`,
+    `Write token expires: ${write.tokenExpiresAt}`,
+  ];
+  if (result.projectType === 'workspace')
+    return [
+      result.created ? 'Base provisioned.' : 'Using the existing anonymous base.',
+      `Editor: ${agentEditorUrl(site)}`,
+      `Expires: ${site.expiresAt}. Claim it before then or it is deleted.`,
+    ].join('\n');
   const siteUrl = agentSiteUrl(apiUrl, site.subdomain);
   return [
     result.created
@@ -127,10 +158,7 @@ export function formatDeployment(result: DeployResult, apiUrl: string): string {
       : 'Using the existing anonymous repository; push any changes to build the site.',
     `Site: ${siteUrl}`,
     `Expires: ${site.expiresAt}`,
-    `Repository: ${site.remote}`,
-    `Branch: ${site.branch}`,
-    `Write token: ${write.token}`,
-    `Write token expires: ${write.tokenExpiresAt}`,
+    ...access,
     'Commit and push your documentation to this repository to start the build.',
     'The site link becomes available after the push and build complete.',
   ].join('\n');