@mintlify/cli 4.0.1792 → 4.0.1794

package/__test__/feedback.test.ts

@@ -0,0 +1,42 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { authenticatedFetch } from '../src/authenticatedFetch.js';
+import { API_URL } from '../src/constants.js';
+import { sendFeedback } from '../src/feedback.js';
+
+vi.mock('../src/authenticatedFetch.js');
+
+const input = { message: 'mint dev crashed', clientId: 'c1', category: 'bug' as const };
+const respond = (status: number) =>
+  vi.mocked(authenticatedFetch).mockResolvedValue(new Response('{}', { status }));
+
+beforeEach(() => vi.resetAllMocks());
+
+describe('mint feedback', () => {
+  it('posts the feedback with the cli source', async () => {
+    respond(201);
+    expect(await sendFeedback(input)).toBeUndefined();
+    const [url, init] = vi.mocked(authenticatedFetch).mock.calls[0]!;
+    expect(url).toBe(`${API_URL}/api/cli/feedback`);
+    expect(init?.method).toBe('POST');
+    expect(JSON.parse(String(init?.body))).toEqual({ ...input, source: 'cli' });
+  });
+  it('asks for login on 401', async () => {
+    respond(401);
+    expect(await sendFeedback(input)).toContain('mint login');
+  });
+  it('asks for login when no credentials are stored', async () => {
+    vi.mocked(authenticatedFetch).mockRejectedValue(
+      new Error('Not authenticated. Run `mint login` to authenticate.')
+    );
+    expect(await sendFeedback(input)).toContain('mint login');
+  });
+  it('reports a network failure', async () => {
+    vi.mocked(authenticatedFetch).mockRejectedValue(new Error('fetch failed'));
+    expect(await sendFeedback(input)).toBe('could not reach the server');
+  });
+  it('reports a server error', async () => {
+    respond(400);
+    expect(await sendFeedback(input)).toBe('could not send feedback (HTTP 400)');
+  });
+});

package/bin/cli.js

@@ -27,6 +27,7 @@ import { deployFromGithubActions, isGithubActions } from './deploy-github-action
 import { formatGithubSetup, setupGithubDeployment } from './deploy-github-setup.js';
 import { DEPLOY_HELP, deploymentInstructions } from './deploy-instructions.js';
 import { formatDeployment, prepareAgentDeployment } from './deploy.js';
+import { FEEDBACK_CATEGORIES, feedback } from './feedback.js';
 import { formatHandler } from './format.js';
 import { checkPort, checkNodeVersion, autoUpgradeIfNeeded, getVersions, isAI, suppressConsoleWarnings, terminate, } from './helpers.js';
 import { init } from './init.js';
@@ -542,6 +543,31 @@ export const cli = ({ packageName = 'mint' }) => {
     }), (argv) => __awaiter(void 0, void 0, void 0, function* () {
         yield addDomain(argv.domain, argv.basePath);
         yield terminate(0);
+    }))
+        .command('feedback <message>', 'Send feedback to the Mintlify team', (yargs) => yargs
+        .positional('message', {
+        type: 'string',
+        demandOption: true,
+        description: 'Feedback to send. Leave out API keys, tokens, and other secrets',
+    })
+        .option('client-id', {
+        type: 'string',
+        demandOption: true,
+        description: 'ID for this report, so the team can tell retries apart',
+    })
+        .option('category', {
+        choices: FEEDBACK_CATEGORIES,
+        demandOption: true,
+        description: 'Feedback category',
+    })
+        .example('$0 feedback "mint dev crashes on a missing image" --client-id 7f3a --category bug', 'Report a bug')
+        .epilog('Requires mint login. Never include API keys, tokens, passwords, or other secrets in the message.'), (argv) => __awaiter(void 0, void 0, void 0, function* () {
+        const sent = yield feedback({
+            message: argv.message,
+            clientId: argv.clientId,
+            category: argv.category,
+        });
+        yield terminate(sent ? 0 : 1);
     }))
         .command('config', 'Manage CLI configuration', (yargs) => yargs
         .command('set <key> <value>', 'Set a configuration value', (yargs) => yargs

package/bin/feedback.js

@@ -0,0 +1,41 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { addLog, ErrorLog, SuccessLog } from '@mintlify/previewing';
+import { authenticatedFetch } from './authenticatedFetch.js';
+import { API_URL } from './constants.js';
+export const FEEDBACK_CATEGORIES = ['bug', 'docs', 'idea'];
+const LOGIN_REQUIRED = 'not logged in. Run `mint login` first, then retry.';
+export function sendFeedback(input) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let res;
+        try {
+            res = yield authenticatedFetch(`${API_URL}/api/cli/feedback`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(Object.assign(Object.assign({}, input), { source: 'cli' })),
+            });
+        }
+        catch (error) {
+            const notLoggedIn = error instanceof Error && /not authenticated/i.test(error.message);
+            return notLoggedIn ? LOGIN_REQUIRED : 'could not reach the server';
+        }
+        if (res.status === 401)
+            return LOGIN_REQUIRED;
+        return res.ok ? undefined : `could not send feedback (HTTP ${res.status})`;
+    });
+}
+export function feedback(input) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const error = yield sendFeedback(input);
+        addLog(error ? _jsx(ErrorLog, { message: error }) : _jsx(SuccessLog, { message: "feedback sent" }));
+        return !error;
+    });
+}