@mintlify/cli 4.0.1472 → 4.0.1474

package/__test__/keyring.test.ts

@@ -19,11 +19,16 @@ describe('keyring', () => {
     vi.resetModules();
   });
 
-  it('stores access and refresh tokens via keytar', async () => {
+  it('stores access token, refresh token, and user email via keytar', async () => {
     const { storeCredentials } = await import('../src/keyring.js');
-    await storeCredentials('access', 'refresh');
+    await storeCredentials('access', 'refresh', 'dev@mintlify.com');
     expect(mockKeytar.setPassword).toHaveBeenCalledWith('mintlify', 'access_token', 'access');
     expect(mockKeytar.setPassword).toHaveBeenCalledWith('mintlify', 'refresh_token', 'refresh');
+    expect(mockKeytar.setPassword).toHaveBeenCalledWith(
+      'mintlify',
+      'user_email',
+      'dev@mintlify.com'
+    );
   });
 
   it('retrieves the access token via keytar', async () => {
@@ -40,11 +45,29 @@ describe('keyring', () => {
     expect(mockKeytar.getPassword).toHaveBeenCalledWith('mintlify', 'refresh_token');
   });
 
-  it('deletes both tokens via keytar', async () => {
+  it('retrieves the user email via keytar', async () => {
+    const { getUserEmail } = await import('../src/keyring.js');
+    const email = await getUserEmail();
+    expect(email).toBe('test-token');
+    expect(mockKeytar.getPassword).toHaveBeenCalledWith('mintlify', 'user_email');
+  });
+
+  it('stores the user email via keytar', async () => {
+    const { storeUserEmail } = await import('../src/keyring.js');
+    await storeUserEmail('dev@mintlify.com');
+    expect(mockKeytar.setPassword).toHaveBeenCalledWith(
+      'mintlify',
+      'user_email',
+      'dev@mintlify.com'
+    );
+  });
+
+  it('deletes tokens and user email via keytar', async () => {
     const { clearCredentials } = await import('../src/keyring.js');
     await clearCredentials();
     expect(mockKeytar.deletePassword).toHaveBeenCalledWith('mintlify', 'access_token');
     expect(mockKeytar.deletePassword).toHaveBeenCalledWith('mintlify', 'refresh_token');
+    expect(mockKeytar.deletePassword).toHaveBeenCalledWith('mintlify', 'user_email');
   });
 
   it('throws a helpful error when keytar is not installed', async () => {

package/bin/cli.js

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

package/bin/constants.js

@@ -7,6 +7,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 = 10000;
+export const TELEMETRY_IDENTITY_TIMEOUT_MS = 3000;
 export const CALLBACK_PORT = 11582;
 const IS_LOCAL_BUILD = process.env.CLI_TEST_MODE === 'true' ? true : getCliVersion() == LOCAL_LINKED_CLI_VERSION;
 export const API_URL = (_a = process.env.MINTLIFY_API_URL) !== null && _a !== void 0 ? _a : (IS_LOCAL_BUILD ? 'http://localhost:5000' : 'https://leaves.mintlify.com');

package/bin/idToken.js

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

package/bin/keyring.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 const SERVICE = 'mintlify';
 const ACCESS_TOKEN_ACCOUNT = 'access_token';
 const REFRESH_TOKEN_ACCOUNT = 'refresh_token';
+const USER_EMAIL_ACCOUNT = 'user_email';
 function getKeytar() {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
@@ -23,13 +24,22 @@ function getKeytar() {
         }
     });
 }
-export function storeCredentials(accessToken, refreshToken) {
+export function storeCredentials(accessToken, refreshToken, userEmail) {
     return __awaiter(this, void 0, void 0, function* () {
         const keytar = yield getKeytar();
         yield Promise.all([
             keytar.setPassword(SERVICE, ACCESS_TOKEN_ACCOUNT, accessToken),
             keytar.setPassword(SERVICE, REFRESH_TOKEN_ACCOUNT, refreshToken),
         ]);
+        try {
+            if (userEmail === null) {
+                yield keytar.deletePassword(SERVICE, USER_EMAIL_ACCOUNT);
+            }
+            else if (userEmail !== undefined) {
+                yield keytar.setPassword(SERVICE, USER_EMAIL_ACCOUNT, userEmail);
+            }
+        }
+        catch (_a) { }
     });
 }
 export function getAccessToken() {
@@ -44,12 +54,25 @@ export function getRefreshToken() {
         return keytar.getPassword(SERVICE, REFRESH_TOKEN_ACCOUNT);
     });
 }
+export function getUserEmail() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const keytar = yield getKeytar();
+        return keytar.getPassword(SERVICE, USER_EMAIL_ACCOUNT);
+    });
+}
+export function storeUserEmail(userEmail) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const keytar = yield getKeytar();
+        yield keytar.setPassword(SERVICE, USER_EMAIL_ACCOUNT, userEmail);
+    });
+}
 export function clearCredentials() {
     return __awaiter(this, void 0, void 0, function* () {
         const keytar = yield getKeytar();
         yield Promise.all([
             keytar.deletePassword(SERVICE, ACCESS_TOKEN_ACCOUNT),
             keytar.deletePassword(SERVICE, REFRESH_TOKEN_ACCOUNT),
+            keytar.deletePassword(SERVICE, USER_EMAIL_ACCOUNT).catch(() => false),
         ]);
     });
 }

package/bin/login.js

@@ -17,12 +17,13 @@ import { calculatePKCECodeChallenge, randomNonce, randomPKCECodeVerifier, random
 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';
 export function login() {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
+        var _a, _b, _c;
         const codeVerifier = randomPKCECodeVerifier();
         const codeChallenge = yield calculatePKCECodeChallenge(codeVerifier);
         const nonce = randomNonce();
@@ -52,7 +53,7 @@ export function login() {
         try {
             code = yield Promise.race([codePromise, inputPromise]);
         }
-        catch (_c) {
+        catch (_d) {
             closeServer();
             inputPromise.cancel();
             addLog(_jsx(ErrorLog, { message: "login cancelled" }));
@@ -79,7 +80,7 @@ export function login() {
             return;
         }
         const token = body;
-        yield storeCredentials(token.access_token, token.refresh_token);
+        yield storeCredentials(token.access_token, token.refresh_token, (_c = getEmailFromIdToken(token.id_token)) !== null && _c !== void 0 ? _c : null);
         void trackLoginSuccess();
         addLog(_jsx(SuccessLog, { message: "logged in successfully" }));
         yield promptSubdomainSelection(token.access_token);

package/bin/signup.js

@@ -16,13 +16,14 @@ 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';
 const sendAIUsageMessage = () => {
     addLogs(_jsx(Text, { children: "Agent Detected - sending AI friendly prompt" }), _jsx(Text, { children: '<mint-cli-instructions>' }), _jsx(Text, { children: "You were asked to create a Mintlify account. Here is how to do that with the `mint signup` command. Fill in any values you already have from this conversation; ask the user directly for anything you don't \u2014 never invent a person's name, company, or email." }), _jsx(Text, { children: "Command: `mint signup --firstName [firstName] --lastName [lastName] --company [company] --email [email]`." }), _jsx(Text, { children: "Important: this command blocks until the user clicks a verification link sent to their email, which can take several minutes. Run it as a background task, not in the foreground \u2014 do not wait on it synchronously. You'll be notified when it finishes; then tell the user their account is ready." }), _jsx(Text, { children: '</mint-cli-instructions>' }));
 };
 export function signup() {
     return __awaiter(this, arguments, void 0, function* (options = {}) {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         if (isAI() && (!options.firstName || !options.lastName || !options.company || !options.email)) {
             sendAIUsageMessage();
             return;
@@ -51,7 +52,7 @@ export function signup() {
                 return;
             }
         }
-        catch (_h) {
+        catch (_j) {
             closeServer();
             addLog(_jsx(ErrorLog, { message: "signup failed: could not reach the server" }));
             return;
@@ -61,7 +62,7 @@ export function signup() {
         try {
             code = yield codePromise;
         }
-        catch (_j) {
+        catch (_k) {
             addLog(_jsx(ErrorLog, { message: "signup cancelled" }));
             return;
         }
@@ -83,7 +84,7 @@ export function signup() {
             return;
         }
         const token = body;
-        yield storeCredentials(token.access_token, token.refresh_token);
+        yield storeCredentials(token.access_token, token.refresh_token, (_h = getEmailFromIdToken(token.id_token)) !== null && _h !== void 0 ? _h : email);
         yield clearConfigValue('subdomain').catch(() => undefined);
         addLog(_jsx(SuccessLog, { message: "account created and logged in successfully" }));
         addLog(_jsx(Text, { children: "Continue in the browser tab where you verified your email to connect GitHub." }));

package/bin/status.js

@@ -42,11 +42,11 @@ export function getCliStatus(accessToken) {
  * 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 function fetchCliStatus() {
+export function fetchCliStatus(signal) {
     return __awaiter(this, void 0, void 0, function* () {
         let res;
         try {
-            res = yield authenticatedFetch(`${API_URL}/api/cli/status`);
+            res = yield authenticatedFetch(`${API_URL}/api/cli/status`, { signal });
         }
         catch (error) {
             const detail = error instanceof Error ? error.message : String(error);

package/bin/telemetry/client.js

@@ -12,6 +12,7 @@ const TELEMETRY_ASYNC_TIMEOUT_MS = 10000;
 const POSTHOG_API_KEY = 'phc_eNuN6Ojnk9O7uWfC17z12AK85fNR0BY6IiGVy0Gfwzw';
 const POSTHOG_HOST = 'https://ph.mintlify.com';
 let client = null;
+let pendingWork = Promise.resolve();
 export function getPostHogClient() {
     if (!client) {
         client = new PostHog(POSTHOG_API_KEY, {
@@ -20,8 +21,21 @@ export function getPostHogClient() {
     }
     return client;
 }
+export function deferShutdownUntil(work) {
+    pendingWork = Promise.allSettled([pendingWork, work]).then(() => undefined);
+}
 export function shutdownPostHog() {
     return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield Promise.race([
+                pendingWork,
+                new Promise((resolve) => {
+                    const t = setTimeout(resolve, TELEMETRY_ASYNC_TIMEOUT_MS);
+                    t.unref();
+                }),
+            ]);
+        }
+        catch (_a) { }
         if (!client)
             return;
         try {
@@ -33,7 +47,7 @@ export function shutdownPostHog() {
                 }),
             ]);
         }
-        catch (_a) { }
+        catch (_b) { }
         client = null;
     });
 }

package/bin/telemetry/track.js

@@ -9,9 +9,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 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';
 function captureWithTimeout(event, properties) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -30,22 +32,39 @@ function captureWithTimeout(event, properties) {
         ]);
     });
 }
+function getAuthenticatedUserEmail() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const [accessToken, storedEmail] = yield Promise.all([getAccessToken(), getUserEmail()]);
+            if (!accessToken)
+                return null;
+            if (storedEmail)
+                return storedEmail;
+            const status = yield fetchCliStatus(AbortSignal.timeout(TELEMETRY_IDENTITY_TIMEOUT_MS));
+            if (!status.ok)
+                return null;
+            const email = status.status.user.email;
+            yield storeUserEmail(email).catch(() => { });
+            return email;
+        }
+        catch (_a) {
+            return null;
+        }
+    });
+}
 export function trackCommand(_a) {
     return __awaiter(this, arguments, void 0, function* ({ command, cliVersion, subdomain, }) {
         if (!isTelemetryEnabled())
             return;
-        try {
-            yield captureWithTimeout('cli.command.executed', {
-                command,
-                cli_version: cliVersion,
-                os: os.platform(),
-                arch: os.arch(),
-                node_version: process.version,
-                is_ai_agent: isAI(),
-                subdomain,
-            });
-        }
-        catch (_b) { }
+        const work = (() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const email = yield getAuthenticatedUserEmail();
+                yield captureWithTimeout('cli.command.executed', Object.assign({ command, cli_version: cliVersion, os: os.platform(), arch: os.arch(), node_version: process.version, is_ai_agent: isAI(), subdomain }, (email ? { email, $set: { email } } : {})));
+            }
+            catch (_a) { }
+        }))();
+        deferShutdownUntil(work);
+        yield work;
     });
 }
 function trackLoginEvent(event, extra) {

package/bin/tokenRefresh.js

@@ -8,6 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { STYTCH_CLIENT_ID, TOKEN_ENDPOINT } from './constants.js';
+import { getEmailFromIdToken } from './idToken.js';
 import { getRefreshToken, storeCredentials } from './keyring.js';
 let inflightRefresh = null;
 export function refreshAccessToken() {
@@ -40,7 +41,7 @@ function doRefresh() {
             const body = (yield res.json().catch(() => null));
             if (!(body === null || body === void 0 ? void 0 : body.access_token) || !body.refresh_token)
                 return null;
-            yield storeCredentials(body.access_token, body.refresh_token);
+            yield storeCredentials(body.access_token, body.refresh_token, getEmailFromIdToken(body.id_token));
             return body.access_token;
         }
         catch (_a) {