@mintlify/cli 4.0.1097 → 4.0.1099

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mintlify/cli",
-  "version": "4.0.1097",
+  "version": "4.0.1099",
   "description": "The Mintlify CLI",
   "engines": {
     "node": ">=18.0.0"
@@ -45,11 +45,11 @@
   },
   "dependencies": {
     "@inquirer/prompts": "7.9.0",
-    "@mintlify/common": "1.0.840",
-    "@mintlify/link-rot": "3.0.1015",
-    "@mintlify/prebuild": "1.0.982",
-    "@mintlify/previewing": "4.0.1043",
-    "@mintlify/validation": "0.1.656",
+    "@mintlify/common": "1.0.841",
+    "@mintlify/link-rot": "3.0.1016",
+    "@mintlify/prebuild": "1.0.983",
+    "@mintlify/previewing": "4.0.1044",
+    "@mintlify/validation": "0.1.657",
     "adm-zip": "0.5.16",
     "chalk": "5.2.0",
     "color": "4.2.3",
@@ -93,5 +93,5 @@
     "vitest": "2.1.9",
     "vitest-mock-process": "1.0.4"
   },
-  "gitHead": "7d99240d2ad695afdd1cc96ec1c042e12b18fde8"
+  "gitHead": "9580be43b49210b3a2a21e11e8b6930f67801556"
 }

package/src/analytics/client.ts

@@ -1,3 +1,4 @@
+import { authenticatedFetch } from '../authenticatedFetch.js';
 import { API_URL } from '../constants.js';
 import type {
   BucketThreadsResponse,
@@ -13,32 +14,14 @@ import type {
 
 type Params = Record<string, string | number | undefined>;
 
-async function getAuthHeaders(): Promise<Record<string, string>> {
-  try {
-    const { getAccessToken } = await import('../keyring.js');
-    const token = await getAccessToken();
-    if (token) {
-      return { Authorization: `Bearer ${token}` };
-    }
-  } catch {}
-
-  const envToken = process.env.MINTLIFY_SESSION_TOKEN;
-  if (envToken) {
-    return { Authorization: `Bearer ${envToken}` };
-  }
-
-  throw new Error('Not authenticated. Run `mint login` to authenticate.');
-}
-
 async function request<T>(path: string, params: Params = {}): Promise<T> {
   const url = new URL(`${API_URL}/api/cli/analytics${path}`);
   for (const [key, value] of Object.entries(params)) {
     if (value !== undefined) url.searchParams.set(key, String(value));
   }
 
-  const authHeaders = await getAuthHeaders();
-  const res = await fetch(url, {
-    headers: { ...authHeaders, Accept: 'application/json' },
+  const res = await authenticatedFetch(url.toString(), {
+    headers: { Accept: 'application/json' },
   });
 
   if (!res.ok) {

package/src/authenticatedFetch.ts

@@ -0,0 +1,42 @@
+import { getAccessToken } from './keyring.js';
+import { refreshAccessToken } from './tokenRefresh.js';
+
+async function getKeyringToken(): Promise<string | null> {
+  try {
+    return await getAccessToken();
+  } catch {
+    return null;
+  }
+}
+
+export async function authenticatedFetch(url: string | URL, init?: RequestInit): Promise<Response> {
+  const keyringToken = await getKeyringToken();
+  const envToken = process.env.MINTLIFY_SESSION_TOKEN;
+  const token = keyringToken ?? envToken;
+
+  if (!token) {
+    throw new Error('Not authenticated. Run `mint login` to authenticate.');
+  }
+
+  const makeRequest = (t: string) =>
+    fetch(url, {
+      ...init,
+      headers: { ...init?.headers, Authorization: `Bearer ${t}` },
+    });
+
+  const res = await makeRequest(token);
+  if (res.status !== 401) return res;
+
+  // If the keyring token expired, try refreshing it
+  if (keyringToken) {
+    const refreshed = await refreshAccessToken();
+    if (refreshed) return makeRequest(refreshed);
+  }
+
+  // Fall back to the env session token if it wasn't already used
+  if (envToken && token !== envToken) {
+    return makeRequest(envToken);
+  }
+
+  return res;
+}

package/src/keyring.ts

@@ -27,6 +27,11 @@ export async function getAccessToken(): Promise<string | null> {
   return keytar.getPassword(SERVICE, ACCESS_TOKEN_ACCOUNT);
 }
 
+export async function getRefreshToken(): Promise<string | null> {
+  const keytar = await getKeytar();
+  return keytar.getPassword(SERVICE, REFRESH_TOKEN_ACCOUNT);
+}
+
 export async function clearCredentials(): Promise<void> {
   const keytar = await getKeytar();
   await Promise.all([

package/src/login.tsx

@@ -1,5 +1,5 @@
 import { input } from '@inquirer/prompts';
-import { addLog } from '@mintlify/previewing';
+import { addLog, ErrorLog, SuccessLog } from '@mintlify/previewing';
 import chalk from 'chalk';
 import { Box, Text } from 'ink';
 import open from 'open';
@@ -49,7 +49,7 @@ export async function login(): Promise<void> {
       </Text>
       <Box flexDirection="column" paddingLeft={3} gap={1}>
         <Text dimColor>If your browser doesn't open automatically, copy this URL:</Text>
-        <Text color="cyan">{url}</Text>
+        <Text dimColor>{url}</Text>
       </Box>
     </Box>
   );
@@ -82,7 +82,7 @@ export async function login(): Promise<void> {
   } catch {
     closeServer();
     inputPromise.cancel();
-    addLog(<Text color="red">✖ Login cancelled.</Text>);
+    addLog(<ErrorLog message="login cancelled" />);
     return;
   }
 
@@ -106,12 +106,12 @@ export async function login(): Promise<void> {
   if (!res.ok) {
     const reason = body.error_message ?? body.error ?? 'unknown error';
     void trackLoginFailed(reason);
-    addLog(<Text color="red">✖ Login failed: {reason}</Text>);
+    addLog(<ErrorLog message={`login failed: ${reason}`} />);
     return;
   }
 
   const token = body as TokenResponse;
   await storeCredentials(token.access_token, token.refresh_token);
   void trackLoginSuccess();
-  addLog(<Text color="green">✔ Logged in successfully.</Text>);
+  addLog(<SuccessLog message="logged in successfully" />);
 }

package/src/logout.tsx

@@ -1,9 +1,8 @@
-import { addLog } from '@mintlify/previewing';
-import { Text } from 'ink';
+import { addLog, SuccessLog } from '@mintlify/previewing';
 
 import { clearCredentials } from './keyring.js';
 
 export async function logout(): Promise<void> {
   await clearCredentials();
-  addLog(<Text color="green">Logged out successfully.</Text>);
+  addLog(<SuccessLog message="logged out successfully" />);
 }

package/src/status.tsx

@@ -1,8 +1,11 @@
-import { addLog } from '@mintlify/previewing';
-import { Text } from 'ink';
+import { addLog, ErrorLog } from '@mintlify/previewing';
+import { Box, Text } from 'ink';
 import { z } from 'zod';
 
+import { authenticatedFetch } from './authenticatedFetch.js';
+import { getConfigValue } from './config.js';
 import { API_URL } from './constants.js';
+import { getCliVersion } from './helpers.js';
 import { getAccessToken } from './keyring.js';
 
 const StatusResponseSchema = z.object({
@@ -29,17 +32,15 @@ export async function status(): Promise<void> {
   const accessToken = await getAccessToken();
 
   if (!accessToken) {
-    addLog(<Text color="red">Not logged in. Run `mint login` to authenticate.</Text>);
+    addLog(<ErrorLog message="not logged in. Run `mint login` to authenticate." />);
     return;
   }
 
   try {
-    const res = await fetch(`${API_URL}/api/cli/status`, {
-      headers: { Authorization: `Bearer ${accessToken}` },
-    });
+    const res = await authenticatedFetch(`${API_URL}/api/cli/status`);
 
     if (!res.ok) {
-      addLog(<Text color="red">Not logged in. Run `mint login` to authenticate.</Text>);
+      addLog(<ErrorLog message="not logged in. Run `mint login` to authenticate." />);
       return;
     }
 
@@ -47,18 +48,46 @@ export async function status(): Promise<void> {
     const parsed = StatusResponseSchema.safeParse(json);
 
     if (!parsed.success) {
-      addLog(<Text color="red">Unexpected response from server. Please try again.</Text>);
+      addLog(<ErrorLog message="unexpected response from server. please try again." />);
       return;
     }
 
-    const { user, org } = parsed.data;
+    const { user, org, subdomain: apiSubdomain } = parsed.data;
+    const version = getCliVersion();
+    const subdomain = getConfigValue('subdomain') ?? apiSubdomain ?? null;
     addLog(
-      <Text>
-        Logged in as <Text color="green">{user.email}</Text> in org{' '}
-        <Text color="green">{org.name}</Text>
-      </Text>
+      <Box flexDirection="column" paddingY={1}>
+        {version && (
+          <Box>
+            <Box minWidth={16}>
+              <Text dimColor>Version</Text>
+            </Box>
+            <Text>{version}</Text>
+          </Box>
+        )}
+        <Box>
+          <Box minWidth={16}>
+            <Text dimColor>Email</Text>
+          </Box>
+          <Text>{user.email}</Text>
+        </Box>
+        <Box>
+          <Box minWidth={16}>
+            <Text dimColor>Organization</Text>
+          </Box>
+          <Text>{org.name}</Text>
+        </Box>
+        {subdomain && (
+          <Box>
+            <Box minWidth={16}>
+              <Text dimColor>Subdomain</Text>
+            </Box>
+            <Text>{subdomain}</Text>
+          </Box>
+        )}
+      </Box>
     );
   } catch (e) {
-    addLog(<Text color="red">Unexpected response from server. Please try again.</Text>);
+    addLog(<ErrorLog message="unexpected response from server. please try again." />);
   }
 }

package/src/tokenRefresh.ts

@@ -0,0 +1,48 @@
+import { STYTCH_CLIENT_ID, TOKEN_ENDPOINT } from './constants.js';
+import { getRefreshToken, storeCredentials } from './keyring.js';
+
+interface TokenResponse {
+  access_token: string;
+  refresh_token: string;
+  token_type: 'bearer';
+  expires_in: number;
+}
+
+let inflightRefresh: Promise<string | null> | null = null;
+
+export async function refreshAccessToken(): Promise<string | null> {
+  if (inflightRefresh) return inflightRefresh;
+
+  inflightRefresh = doRefresh().finally(() => {
+    inflightRefresh = null;
+  });
+
+  return inflightRefresh;
+}
+
+async function doRefresh(): Promise<string | null> {
+  try {
+    const refreshToken = await getRefreshToken();
+    if (!refreshToken) return null;
+
+    const res = await fetch(TOKEN_ENDPOINT, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        client_id: STYTCH_CLIENT_ID,
+        grant_type: 'refresh_token',
+        refresh_token: refreshToken,
+      }),
+    });
+
+    if (!res.ok) return null;
+
+    const body = (await res.json().catch(() => null)) as TokenResponse | null;
+    if (!body?.access_token || !body.refresh_token) return null;
+
+    await storeCredentials(body.access_token, body.refresh_token);
+    return body.access_token;
+  } catch {
+    return null;
+  }
+}