@mintlify/cli 4.0.1734 → 4.0.1735

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mintlify/cli",
-  "version": "4.0.1734",
+  "version": "4.0.1735",
   "description": "The Mintlify CLI",
   "engines": {
     "node": ">=18.0.0"
@@ -101,5 +101,5 @@
     "vitest": "2.1.9",
     "vitest-mock-process": "1.0.4"
   },
-  "gitHead": "ae7819bfab79f6c765d39aed34bf33363f4be72a"
+  "gitHead": "06c165289d14569110e9510ffca7470891ba2722"
 }

package/src/agent-claim.ts

@@ -56,7 +56,6 @@ const signupSchema = z.object({ orgId: z.string().min(1), claimed: z.literal(tru
 
 export async function claimDeployment(
   options: { apiUrl: string; directory: string; code?: string; email?: string },
-  warn: (message: string) => void,
   progress: (message: string) => void = () => {}
 ): Promise<string> {
   const { apiUrl, directory } = options;
@@ -81,15 +80,7 @@ export async function claimDeployment(
   if (new URL(discovery.issuer).origin !== new URL(credentials.issuer).origin) {
     throw new Error('Saved agent credentials belong to another issuer.');
   }
-  const save = async (value: AgentCredentials) => {
-    try {
-      await saveAgentCredentials(apiUrl, directory, value);
-    } catch {
-      warn(
-        'Could not save claimed credentials to the keyring. Continuing for this run; a retry may not recover the completed claim.'
-      );
-    }
-  };
+  const save = (value: AgentCredentials) => saveAgentCredentials(apiUrl, directory, value);
   if (!credentials.claimVerified) {
     progress('Completing the WorkOS claim...');
     const completed = await agentResponse(

package/src/agent-credentials.ts

@@ -1,10 +1,13 @@
 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),
@@ -28,14 +31,59 @@ function registrationAccount(apiUrl: string, registrationId: string): string {
   return `${new URL(apiUrl).origin}:${registrationId}`;
 }
 
+async function readFallback(): Promise<Record<string, string>> {
+  try {
+    return z
+      .record(z.string(), z.string())
+      .parse(JSON.parse(await fs.readFile(fallbackFile(), 'utf-8')));
+  } catch {
+    return {};
+  }
+}
+
+async function writeFallback(entries: Record<string, string>): Promise<void> {
+  await fs.mkdir(CONFIG_DIR, { recursive: true });
+  const temp = `${fallbackFile()}.${process.pid}.tmp`;
+  await fs.writeFile(temp, JSON.stringify(entries, null, 2), { mode: 0o600 });
+  await fs.chmod(temp, 0o600);
+  await fs.rename(temp, fallbackFile());
+}
+
+async function getSecret(account: string): Promise<string | null> {
+  let keyringError: unknown;
+  try {
+    const value = await (await getKeytar()).getPassword(service, account);
+    if (value) return value;
+  } catch (error) {
+    keyringError = error;
+  }
+  const value = (await readFallback())[account];
+  if (value) return value;
+  if (keyringError) throw keyringError;
+  return null;
+}
+
+async function setSecret(account: string, value: string): Promise<void> {
+  try {
+    await (await getKeytar()).setPassword(service, account, value);
+  } catch {
+    await writeFallback({ ...(await readFallback()), [account]: value });
+    await getKeytar()
+      .then((keytar) => keytar.deletePassword(service, account))
+      .catch(() => {});
+    return;
+  }
+  const { [account]: stale, ...rest } = await readFallback();
+  if (stale) await writeFallback(rest).catch(() => {});
+}
+
 export async function loadAgentCredentials(
   apiUrl: string,
   directory: string
 ): Promise<AgentCredentials | null> {
-  const keytar = await getKeytar();
-  const registrationId = await keytar.getPassword(service, projectAccount(apiUrl, directory));
+  const registrationId = await getSecret(projectAccount(apiUrl, directory));
   if (!registrationId) return null;
-  const value = await keytar.getPassword(service, registrationAccount(apiUrl, registrationId));
+  const value = await 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));
@@ -51,11 +99,6 @@ export async function saveAgentCredentials(
   credentials: AgentCredentials
 ): Promise<void> {
   const value = agentCredentialsSchema.parse(credentials);
-  const keytar = await getKeytar();
-  await keytar.setPassword(
-    service,
-    registrationAccount(apiUrl, value.registrationId),
-    JSON.stringify(value)
-  );
-  await keytar.setPassword(service, projectAccount(apiUrl, directory), value.registrationId);
+  await setSecret(registrationAccount(apiUrl, value.registrationId), JSON.stringify(value));
+  await setSecret(projectAccount(apiUrl, directory), value.registrationId);
 }

package/src/cli.tsx

@@ -143,7 +143,6 @@ export const cli = ({ packageName = 'mint' }: { packageName?: string }) => {
           try {
             const message = await 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`)
             );
             process.stdout.write(`${message}\n`);

package/src/deploy.ts

@@ -62,15 +62,8 @@ export async function prepareAgentDeployment(
   if (!subdomain) throw new Error('Choose a site name with --subdomain <name>.');
   const discovery = await discoverAgentAuth(apiUrl);
 
-  const save = async (credentials: AgentCredentials) => {
-    try {
-      await saveAgentCredentials(apiUrl, directory, credentials);
-    } catch {
-      warn(
-        'Could not save agent credentials to the keyring. Continuing for this run; later commands may not recover access.'
-      );
-    }
-  };
+  const save = (credentials: AgentCredentials) =>
+    saveAgentCredentials(apiUrl, directory, credentials);
 
   for (let attempt = 0; attempt < 2; attempt++) {
     const credentials = saved ?? (await registerAgent(discovery));