@mintlify/cli 4.0.1472 → 4.0.1474

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mintlify/cli",
-  "version": "4.0.1472",
+  "version": "4.0.1474",
   "description": "The Mintlify CLI",
   "engines": {
     "node": ">=18.0.0"
@@ -45,12 +45,12 @@
   },
   "dependencies": {
     "@inquirer/prompts": "7.9.0",
-    "@mintlify/common": "1.0.1127",
-    "@mintlify/link-rot": "3.0.1329",
+    "@mintlify/common": "1.0.1128",
+    "@mintlify/link-rot": "3.0.1330",
     "@mintlify/models": "0.0.351",
-    "@mintlify/prebuild": "1.0.1281",
-    "@mintlify/previewing": "4.0.1353",
-    "@mintlify/validation": "0.1.844",
+    "@mintlify/prebuild": "1.0.1282",
+    "@mintlify/previewing": "4.0.1354",
+    "@mintlify/validation": "0.1.845",
     "adm-zip": "0.6.0",
     "chalk": "5.2.0",
     "color": "4.2.3",
@@ -86,7 +86,7 @@
     "keytar": "7.9.0"
   },
   "devDependencies": {
-    "@mintlify/editor": "0.0.357",
+    "@mintlify/editor": "0.0.358",
     "@mintlify/ts-config": "2.0.2",
     "@tsconfig/recommended": "1.0.2",
     "@types/detect-port": "1.3.2",
@@ -105,5 +105,5 @@
     "vitest": "2.1.9",
     "vitest-mock-process": "1.0.4"
   },
-  "gitHead": "bb12d905a42453ef8bdcb23a928bbe9de59ea218"
+  "gitHead": "5b773bbb5a32822d5875d5e350e48eb374065be8"
 }

package/src/cli.tsx

@@ -102,7 +102,7 @@ export const cli = ({ packageName = 'mint' }: { packageName?: string }) => {
       .option('telemetry', {
         type: 'boolean',
         alias: 't',
-        description: 'Enable or disable anonymous usage telemetry',
+        description: 'Enable or disable usage telemetry',
       })
       .middleware(async (argv) => {
         if (argv.telemetry !== undefined && argv._.length === 0) {

package/src/constants.ts

@@ -9,6 +9,7 @@ export const HOME_DIR = os.homedir();
 export const CONFIG_DIR = path.join(HOME_DIR, '.config', 'mintlify');
 export const CLI_CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 export const TELEMETRY_ASYNC_TIMEOUT_MS = 10_000;
+export const TELEMETRY_IDENTITY_TIMEOUT_MS = 3_000;
 
 export const CALLBACK_PORT = 11582;
 

package/src/idToken.ts

@@ -0,0 +1,17 @@
+interface IdTokenClaims {
+  email?: unknown;
+}
+
+export function getEmailFromIdToken(idToken: string | undefined): string | undefined {
+  if (!idToken) return undefined;
+
+  try {
+    const payload = idToken.split('.')[1];
+    if (!payload) return undefined;
+
+    const claims = JSON.parse(Buffer.from(payload, 'base64url').toString('utf8')) as IdTokenClaims;
+    return typeof claims.email === 'string' && claims.email.length > 0 ? claims.email : undefined;
+  } catch {
+    return undefined;
+  }
+}

package/src/keyring.ts

@@ -1,6 +1,7 @@
 const SERVICE = 'mintlify';
 const ACCESS_TOKEN_ACCOUNT = 'access_token';
 const REFRESH_TOKEN_ACCOUNT = 'refresh_token';
+const USER_EMAIL_ACCOUNT = 'user_email';
 
 async function getKeytar(): Promise<typeof import('keytar')> {
   try {
@@ -14,12 +15,24 @@ async function getKeytar(): Promise<typeof import('keytar')> {
   }
 }
 
-export async function storeCredentials(accessToken: string, refreshToken: string): Promise<void> {
+export async function storeCredentials(
+  accessToken: string,
+  refreshToken: string,
+  userEmail?: string | null
+): Promise<void> {
   const keytar = await getKeytar();
   await Promise.all([
     keytar.setPassword(SERVICE, ACCESS_TOKEN_ACCOUNT, accessToken),
     keytar.setPassword(SERVICE, REFRESH_TOKEN_ACCOUNT, refreshToken),
   ]);
+
+  try {
+    if (userEmail === null) {
+      await keytar.deletePassword(SERVICE, USER_EMAIL_ACCOUNT);
+    } else if (userEmail !== undefined) {
+      await keytar.setPassword(SERVICE, USER_EMAIL_ACCOUNT, userEmail);
+    }
+  } catch {}
 }
 
 export async function getAccessToken(): Promise<string | null> {
@@ -32,10 +45,21 @@ export async function getRefreshToken(): Promise<string | null> {
   return keytar.getPassword(SERVICE, REFRESH_TOKEN_ACCOUNT);
 }
 
+export async function getUserEmail(): Promise<string | null> {
+  const keytar = await getKeytar();
+  return keytar.getPassword(SERVICE, USER_EMAIL_ACCOUNT);
+}
+
+export async function storeUserEmail(userEmail: string): Promise<void> {
+  const keytar = await getKeytar();
+  await keytar.setPassword(SERVICE, USER_EMAIL_ACCOUNT, userEmail);
+}
+
 export async function clearCredentials(): Promise<void> {
   const keytar = await getKeytar();
   await Promise.all([
     keytar.deletePassword(SERVICE, ACCESS_TOKEN_ACCOUNT),
     keytar.deletePassword(SERVICE, REFRESH_TOKEN_ACCOUNT),
+    keytar.deletePassword(SERVICE, USER_EMAIL_ACCOUNT).catch(() => false),
   ]);
 }

package/src/login.tsx

@@ -13,6 +13,7 @@ import {
 import { startCallbackServer } from './callbackServer.js';
 import { setConfigValue } from './config.js';
 import { DASHBOARD_URL, STYTCH_CLIENT_ID, TOKEN_ENDPOINT } from './constants.js';
+import { getEmailFromIdToken } from './idToken.js';
 import { storeCredentials } from './keyring.js';
 import { getCliSubdomains } from './status.js';
 import { trackLoginAttempt, trackLoginFailed, trackLoginSuccess } from './telemetry/track.js';
@@ -113,7 +114,11 @@ export async function login(): Promise<void> {
   }
 
   const token = body as TokenResponse;
-  await storeCredentials(token.access_token, token.refresh_token);
+  await storeCredentials(
+    token.access_token,
+    token.refresh_token,
+    getEmailFromIdToken(token.id_token) ?? null
+  );
   void trackLoginSuccess();
   addLog(<SuccessLog message="logged in successfully" />);
   await promptSubdomainSelection(token.access_token);

package/src/signup.tsx

@@ -12,6 +12,7 @@ import { startCallbackServer } from './callbackServer.js';
 import { clearConfigValue } from './config.js';
 import { API_URL, DASHBOARD_URL, STYTCH_CLIENT_ID, TOKEN_ENDPOINT } from './constants.js';
 import { isAI } from './helpers.js';
+import { getEmailFromIdToken } from './idToken.js';
 import { storeCredentials } from './keyring.js';
 import type { TokenResponse } from './login.js';
 
@@ -124,7 +125,11 @@ export async function signup(options: SignupOptions = {}): Promise<void> {
   }
 
   const token = body as TokenResponse;
-  await storeCredentials(token.access_token, token.refresh_token);
+  await storeCredentials(
+    token.access_token,
+    token.refresh_token,
+    getEmailFromIdToken(token.id_token) ?? email
+  );
   await clearConfigValue('subdomain').catch(() => undefined);
   addLog(<SuccessLog message="account created and logged in successfully" />);
   addLog(<Text>Continue in the browser tab where you verified your email to connect GitHub.</Text>);

package/src/status.tsx

@@ -38,10 +38,10 @@ export type CliStatusResult =
  * Like getCliStatus, but refreshes an expired session and says why it failed, so commands can
  * tell "log in again" apart from "the server is down" and from "not allowed".
  */
-export async function fetchCliStatus(): Promise<CliStatusResult> {
+export async function fetchCliStatus(signal?: AbortSignal): Promise<CliStatusResult> {
   let res: Response;
   try {
-    res = await authenticatedFetch(`${API_URL}/api/cli/status`);
+    res = await authenticatedFetch(`${API_URL}/api/cli/status`, { signal });
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
     if (/not authenticated/i.test(detail)) return { ok: false, reason: 'unauthenticated' };

package/src/telemetry/client.ts

@@ -6,6 +6,7 @@ const POSTHOG_API_KEY = 'phc_eNuN6Ojnk9O7uWfC17z12AK85fNR0BY6IiGVy0Gfwzw';
 const POSTHOG_HOST = 'https://ph.mintlify.com';
 
 let client: PostHog | null = null;
+let pendingWork: Promise<void> = Promise.resolve();
 
 export function getPostHogClient(): PostHog {
   if (!client) {
@@ -16,7 +17,21 @@ export function getPostHogClient(): PostHog {
   return client;
 }
 
+export function deferShutdownUntil(work: Promise<void>): void {
+  pendingWork = Promise.allSettled([pendingWork, work]).then(() => undefined);
+}
+
 export async function shutdownPostHog(): Promise<void> {
+  try {
+    await Promise.race([
+      pendingWork,
+      new Promise<void>((resolve) => {
+        const t = setTimeout(resolve, TELEMETRY_ASYNC_TIMEOUT_MS);
+        t.unref();
+      }),
+    ]);
+  } catch {}
+
   if (!client) return;
   try {
     await Promise.race([

package/src/telemetry/track.ts

@@ -1,9 +1,11 @@
 import os from 'os';
 
 import { isTelemetryEnabled } from '../config.js';
-import { TELEMETRY_ASYNC_TIMEOUT_MS } from '../constants.js';
+import { TELEMETRY_ASYNC_TIMEOUT_MS, TELEMETRY_IDENTITY_TIMEOUT_MS } from '../constants.js';
 import { getVersions, isAI } from '../helpers.js';
-import { getPostHogClient } from './client.js';
+import { getAccessToken, getUserEmail, storeUserEmail } from '../keyring.js';
+import { fetchCliStatus } from '../status.js';
+import { deferShutdownUntil, getPostHogClient } from './client.js';
 import { getDistinctId } from './distinctId.js';
 
 export interface TrackCommandOptions {
@@ -31,6 +33,23 @@ async function captureWithTimeout(
   ]);
 }
 
+async function getAuthenticatedUserEmail(): Promise<string | null> {
+  try {
+    const [accessToken, storedEmail] = await Promise.all([getAccessToken(), getUserEmail()]);
+    if (!accessToken) return null;
+    if (storedEmail) return storedEmail;
+
+    const status = await fetchCliStatus(AbortSignal.timeout(TELEMETRY_IDENTITY_TIMEOUT_MS));
+    if (!status.ok) return null;
+
+    const email = status.status.user.email;
+    await storeUserEmail(email).catch(() => {});
+    return email;
+  } catch {
+    return null;
+  }
+}
+
 export async function trackCommand({
   command,
   cliVersion,
@@ -38,17 +57,24 @@ export async function trackCommand({
 }: TrackCommandOptions): Promise<void> {
   if (!isTelemetryEnabled()) return;
 
-  try {
-    await captureWithTimeout('cli.command.executed', {
-      command,
-      cli_version: cliVersion,
-      os: os.platform(),
-      arch: os.arch(),
-      node_version: process.version,
-      is_ai_agent: isAI(),
-      subdomain,
-    });
-  } catch {}
+  const work = (async () => {
+    try {
+      const email = await getAuthenticatedUserEmail();
+      await captureWithTimeout('cli.command.executed', {
+        command,
+        cli_version: cliVersion,
+        os: os.platform(),
+        arch: os.arch(),
+        node_version: process.version,
+        is_ai_agent: isAI(),
+        subdomain,
+        ...(email ? { email, $set: { email } } : {}),
+      });
+    } catch {}
+  })();
+
+  deferShutdownUntil(work);
+  await work;
 }
 
 async function trackLoginEvent(event: string, extra?: Record<string, unknown>): Promise<void> {

package/src/tokenRefresh.ts

@@ -1,8 +1,10 @@
 import { STYTCH_CLIENT_ID, TOKEN_ENDPOINT } from './constants.js';
+import { getEmailFromIdToken } from './idToken.js';
 import { getRefreshToken, storeCredentials } from './keyring.js';
 
 interface TokenResponse {
   access_token: string;
+  id_token?: string;
   refresh_token: string;
   token_type: 'bearer';
   expires_in: number;
@@ -40,7 +42,11 @@ async function doRefresh(): Promise<string | 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);
+    await storeCredentials(
+      body.access_token,
+      body.refresh_token,
+      getEmailFromIdToken(body.id_token)
+    );
     return body.access_token;
   } catch {
     return null;