@mintlify/previewing 4.0.1036 → 4.0.1038

package/dist/local-preview/run.d.ts

@@ -2,4 +2,5 @@ import { ArgumentsCamelCase } from 'yargs';
 export declare const run: (argv: ArgumentsCamelCase & {
     needsUpdate: boolean;
     fileImportsMap?: Map<string, Set<string>>;
+    apiUrl?: string;
 }) => Promise<void>;

package/dist/local-preview/run.js

@@ -11,6 +11,37 @@ import listener, { initializeImportCache } from './listener/index.js';
 import { refreshTrackedReferencedFiles } from './listener/referencedFiles.js';
 import { getLocalNetworkIp } from './network.js';
 import { setupNext } from './setupNext.js';
+const PROXY_RESPONSE_HEADER_DENYLIST = new Set([
+    'connection',
+    'keep-alive',
+    'proxy-authenticate',
+    'proxy-authorization',
+    'te',
+    'trailer',
+    'transfer-encoding',
+    'upgrade',
+    'content-encoding',
+    'content-length',
+]);
+const ASSISTANT_MESSAGE_JSON_LIMIT = '5mb';
+function applyUpstreamProxyHeaders(upstream, res) {
+    const headers = upstream.headers;
+    const hasGetSetCookie = typeof headers.getSetCookie === 'function';
+    const setCookies = hasGetSetCookie ? headers.getSetCookie() : undefined;
+    headers.forEach((value, key) => {
+        const lower = key.toLowerCase();
+        if (PROXY_RESPONSE_HEADER_DENYLIST.has(lower))
+            return;
+        if (lower === 'set-cookie' && hasGetSetCookie)
+            return;
+        res.setHeader(key, value);
+    });
+    if (setCookies?.length) {
+        for (const cookie of setCookies) {
+            res.appendHeader('Set-Cookie', cookie);
+        }
+    }
+}
 export const run = async (argv) => {
     const port = argv.port || '3000';
     const currentPort = parseInt(port, 10) || 3000;
@@ -19,8 +50,72 @@ export const run = async (argv) => {
     const io = new SocketServer(server);
     const requestHandler = await setupNext();
     const localIp = getLocalNetworkIp();
+    const apiUrl = argv.apiUrl ?? process.env.MINTLIFY_API_URL ?? 'http://localhost:5000';
+    const accessToken = argv.accessToken;
+    const subdomain = argv.subdomain;
+    process.env.MINTLIFY_CLI_ACCESS_TOKEN = accessToken ?? '';
+    process.env.MINTLIFY_API_URL = apiUrl;
+    if (subdomain)
+        process.env.MINTLIFY_CLI_SUBDOMAIN = subdomain;
     // next-server is bugged, public files added after starting aren't served
     app.use('/', express.static(NEXT_PUBLIC_PATH));
+    app.post('/_mintlify/api-public/search/:subdomain', express.json(), async (req, res) => {
+        const targetSubdomain = subdomain ?? req.params.subdomain;
+        try {
+            const upstream = await fetch(`${apiUrl}/api/cli/${targetSubdomain}/search`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
+                },
+                body: JSON.stringify(req.body),
+            });
+            const data = await upstream.json();
+            res.status(upstream.status).json(data);
+        }
+        catch {
+            res.status(502).json({ error: 'search proxy failed' });
+        }
+    });
+    app.post('/_mintlify/api-public/assistant/:subdomain/message', express.json({ limit: ASSISTANT_MESSAGE_JSON_LIMIT }), async (req, res) => {
+        const targetSubdomain = subdomain ?? req.params.subdomain;
+        try {
+            const upstream = await fetch(`${apiUrl}/api/cli/${targetSubdomain}/assistant/message`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
+                },
+                body: JSON.stringify(req.body),
+            });
+            res.status(upstream.status);
+            applyUpstreamProxyHeaders(upstream, res);
+            if (upstream.body) {
+                const reader = upstream.body.getReader();
+                const pump = async () => {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                        res.end();
+                        return;
+                    }
+                    res.write(value);
+                    return pump();
+                };
+                await pump();
+            }
+            else {
+                res.end();
+            }
+        }
+        catch {
+            if (!res.headersSent) {
+                res.status(502).json({ error: 'assistant proxy failed' });
+            }
+            else {
+                res.destroy();
+            }
+        }
+    });
     app.all('*', (req, res) => requestHandler(req, res));
     const onChange = () => {
         io.emit('reload');