@cursor/bdk 0.2.8 → 0.2.10

package/dist/internal/playground-proxy.js

@@ -18,22 +18,6 @@
  * credentials are re-minted shortly before `expiresAt` and once on upstream
  * 401 so a long playground session does not require restarting the CLI.
  */
-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());
-    });
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
 import { randomBytes } from "node:crypto";
 import { createServer, request as httpRequest, } from "node:http";
 import { request as httpsRequest } from "node:https";
@@ -68,101 +52,97 @@ const PROXY_TOKEN_QUERY = "proxyToken";
 /**
  * Start a loopback proxy. Resolves once listening.
  */
-export function startPlaygroundProxy(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c;
-        const upstream = parseUpstreamUrl(args.upstreamUrl);
-        const state = {
-            upstream,
-            injectHeaders: buildInjectHeaders(args.headers, args.bearerToken),
-            expiresAtMs: parseExpiresAtMs(args.expiresAt),
-        };
-        const accessToken = (_a = args.accessToken) !== null && _a !== void 0 ? _a : randomBytes(32).toString("base64url");
-        const now = (_b = args.now) !== null && _b !== void 0 ? _b : Date.now;
-        let refreshInFlight;
-        /** Set after listen; used for Origin CSRF checks. */
-        let proxyOrigin = "";
-        const ensureFreshAccess = (force) => __awaiter(this, void 0, void 0, function* () {
-            if (args.refreshUpstream === undefined) {
-                return;
-            }
-            const expired = state.expiresAtMs !== undefined && now() >= state.expiresAtMs - ACCESS_EXPIRY_LEEWAY_MS;
-            if (!force && !expired) {
-                return;
-            }
-            if (refreshInFlight !== undefined) {
-                yield refreshInFlight;
+export async function startPlaygroundProxy(args) {
+    const upstream = parseUpstreamUrl(args.upstreamUrl);
+    const state = {
+        upstream,
+        injectHeaders: buildInjectHeaders(args.headers, args.bearerToken),
+        expiresAtMs: parseExpiresAtMs(args.expiresAt),
+    };
+    const accessToken = args.accessToken ?? randomBytes(32).toString("base64url");
+    const now = args.now ?? Date.now;
+    let refreshInFlight;
+    /** Set after listen; used for Origin CSRF checks. */
+    let proxyOrigin = "";
+    const ensureFreshAccess = async (force) => {
+        if (args.refreshUpstream === undefined) {
+            return;
+        }
+        const expired = state.expiresAtMs !== undefined && now() >= state.expiresAtMs - ACCESS_EXPIRY_LEEWAY_MS;
+        if (!force && !expired) {
+            return;
+        }
+        if (refreshInFlight !== undefined) {
+            await refreshInFlight;
+            return;
+        }
+        refreshInFlight = (async () => {
+            const next = await args.refreshUpstream();
+            state.upstream = parseUpstreamUrl(next.upstreamUrl);
+            state.injectHeaders = buildInjectHeaders(next.headers, args.bearerToken);
+            state.expiresAtMs = parseExpiresAtMs(next.expiresAt);
+        })().finally(() => {
+            refreshInFlight = undefined;
+        });
+        await refreshInFlight;
+    };
+    const create = args.createServerImpl ?? createServer;
+    const server = create((req, res) => {
+        void handleProxyRequest({
+            req,
+            res,
+            getState: () => state,
+            ensureFreshAccess,
+            canRefresh: args.refreshUpstream !== undefined,
+            accessToken,
+            proxyOrigin: () => proxyOrigin,
+        }).catch((error) => {
+            if (res.headersSent) {
+                if (!res.writableEnded) {
+                    res.end();
+                }
                 return;
             }
-            refreshInFlight = (() => __awaiter(this, void 0, void 0, function* () {
-                const next = yield args.refreshUpstream();
-                state.upstream = parseUpstreamUrl(next.upstreamUrl);
-                state.injectHeaders = buildInjectHeaders(next.headers, args.bearerToken);
-                state.expiresAtMs = parseExpiresAtMs(next.expiresAt);
-            }))().finally(() => {
-                refreshInFlight = undefined;
-            });
-            yield refreshInFlight;
+            const message = error instanceof Error ? error.message : String(error);
+            res.writeHead(502, { "content-type": "text/plain; charset=utf-8" });
+            res.end(`Playground proxy error: ${message}`);
         });
-        const create = (_c = args.createServerImpl) !== null && _c !== void 0 ? _c : createServer;
-        const server = create((req, res) => {
-            void handleProxyRequest({
-                req,
-                res,
-                getState: () => state,
-                ensureFreshAccess,
-                canRefresh: args.refreshUpstream !== undefined,
-                accessToken,
-                proxyOrigin: () => proxyOrigin,
-            }).catch((error) => {
-                if (res.headersSent) {
-                    if (!res.writableEnded) {
-                        res.end();
-                    }
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(args.port ?? 0, "127.0.0.1", () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    const address = server.address();
+    const localUrl = `http://127.0.0.1:${address.port}`;
+    proxyOrigin = localUrl;
+    return {
+        localUrl,
+        port: address.port,
+        accessToken,
+        playgroundUrl: (sessionId) => {
+            const url = new URL(`${localUrl}/playground`);
+            url.searchParams.set(PROXY_TOKEN_QUERY, accessToken);
+            if (sessionId !== undefined && sessionId.trim() !== "") {
+                url.searchParams.set("sessionId", sessionId.trim());
+            }
+            return url.toString();
+        },
+        close: () => new Promise((resolve, reject) => {
+            // Drop keep-alive / streamed playground connections so Ctrl-C
+            // does not hang waiting for active sockets.
+            server.closeAllConnections();
+            server.close(error => {
+                if (error) {
+                    reject(error);
                     return;
                 }
-                const message = error instanceof Error ? error.message : String(error);
-                res.writeHead(502, { "content-type": "text/plain; charset=utf-8" });
-                res.end(`Playground proxy error: ${message}`);
-            });
-        });
-        yield new Promise((resolve, reject) => {
-            var _a;
-            server.once("error", reject);
-            server.listen((_a = args.port) !== null && _a !== void 0 ? _a : 0, "127.0.0.1", () => {
-                server.off("error", reject);
                 resolve();
             });
-        });
-        const address = server.address();
-        const localUrl = `http://127.0.0.1:${address.port}`;
-        proxyOrigin = localUrl;
-        return {
-            localUrl,
-            port: address.port,
-            accessToken,
-            playgroundUrl: (sessionId) => {
-                const url = new URL(`${localUrl}/playground`);
-                url.searchParams.set(PROXY_TOKEN_QUERY, accessToken);
-                if (sessionId !== undefined && sessionId.trim() !== "") {
-                    url.searchParams.set("sessionId", sessionId.trim());
-                }
-                return url.toString();
-            },
-            close: () => new Promise((resolve, reject) => {
-                // Drop keep-alive / streamed playground connections so Ctrl-C
-                // does not hang waiting for active sockets.
-                server.closeAllConnections();
-                server.close(error => {
-                    if (error) {
-                        reject(error);
-                        return;
-                    }
-                    resolve();
-                });
-            }),
-        };
-    });
+        }),
+    };
 }
 function parseUpstreamUrl(raw) {
     const upstream = new URL(raw.replace(/\/$/, ""));
@@ -179,118 +159,99 @@ function parseExpiresAtMs(expiresAt) {
     return Number.isFinite(ms) ? ms : undefined;
 }
 function buildInjectHeaders(headers, bearerToken) {
-    const out = Object.assign({}, (headers !== null && headers !== void 0 ? headers : {}));
+    const out = { ...(headers ?? {}) };
     if (bearerToken !== undefined && bearerToken.trim() !== "") {
         out.authorization = `Bearer ${bearerToken.trim()}`;
     }
     return out;
 }
-function readRequestBody(req) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, req_1, req_1_1;
-        var _b, e_1, _c, _d;
-        const chunks = [];
-        try {
-            for (_a = true, req_1 = __asyncValues(req); req_1_1 = yield req_1.next(), _b = req_1_1.done, !_b; _a = true) {
-                _d = req_1_1.value;
-                _a = false;
-                const chunk = _d;
-                chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (!_a && !_b && (_c = req_1.return)) yield _c.call(req_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return Buffer.concat(chunks);
-    });
+async function readRequestBody(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    }
+    return Buffer.concat(chunks);
 }
-function handleProxyRequest(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const { req, res, getState, ensureFreshAccess, canRefresh, accessToken, proxyOrigin } = args;
-        const pathWithQuery = (_a = req.url) !== null && _a !== void 0 ? _a : "/";
-        const pathParse = parseProxyPath(pathWithQuery);
-        if (!pathParse.ok) {
-            res.writeHead(400, { "content-type": "text/plain; charset=utf-8" });
-            res.end("Absolute-form request targets are not allowed");
-            return;
-        }
-        const auth = authorizeLocalRequest({
-            pathWithQuery: pathParse.path,
-            cookieHeader: req.headers.cookie,
-            accessToken,
+async function handleProxyRequest(args) {
+    const { req, res, getState, ensureFreshAccess, canRefresh, accessToken, proxyOrigin } = args;
+    const pathWithQuery = req.url ?? "/";
+    const pathParse = parseProxyPath(pathWithQuery);
+    if (!pathParse.ok) {
+        res.writeHead(400, { "content-type": "text/plain; charset=utf-8" });
+        res.end("Absolute-form request targets are not allowed");
+        return;
+    }
+    const auth = authorizeLocalRequest({
+        pathWithQuery: pathParse.path,
+        cookieHeader: req.headers.cookie,
+        accessToken,
+    });
+    if (auth.kind === "deny") {
+        res.writeHead(401, { "content-type": "text/plain; charset=utf-8" });
+        res.end("Playground proxy requires the session access token");
+        return;
+    }
+    if (auth.kind === "bootstrap") {
+        res.writeHead(302, {
+            location: auth.redirectPath,
+            "set-cookie": auth.setCookie,
+            "cache-control": "no-store",
         });
-        if (auth.kind === "deny") {
-            res.writeHead(401, { "content-type": "text/plain; charset=utf-8" });
-            res.end("Playground proxy requires the session access token");
-            return;
-        }
-        if (auth.kind === "bootstrap") {
-            res.writeHead(302, {
-                location: auth.redirectPath,
-                "set-cookie": auth.setCookie,
-                "cache-control": "no-store",
-            });
-            res.end();
-            return;
-        }
-        const method = (_b = req.method) !== null && _b !== void 0 ? _b : "GET";
-        if (!isTrustedBrowserOrigin({
-            method,
-            origin: headerString(req.headers.origin),
-            referer: headerString(req.headers.referer),
-            secFetchSite: headerString(req.headers["sec-fetch-site"]),
-            proxyOrigin: proxyOrigin(),
-        })) {
-            res.writeHead(403, { "content-type": "text/plain; charset=utf-8" });
-            res.end("Playground proxy rejected cross-origin request");
-            return;
-        }
-        let body;
-        try {
-            body = yield readRequestBody(req);
+        res.end();
+        return;
+    }
+    const method = req.method ?? "GET";
+    if (!isTrustedBrowserOrigin({
+        method,
+        origin: headerString(req.headers.origin),
+        referer: headerString(req.headers.referer),
+        secFetchSite: headerString(req.headers["sec-fetch-site"]),
+        proxyOrigin: proxyOrigin(),
+    })) {
+        res.writeHead(403, { "content-type": "text/plain; charset=utf-8" });
+        res.end("Playground proxy rejected cross-origin request");
+        return;
+    }
+    let body;
+    try {
+        body = await readRequestBody(req);
+    }
+    catch {
+        if (!res.headersSent) {
+            res.writeHead(400, { "content-type": "text/plain; charset=utf-8" });
+            res.end("Playground proxy failed to read request body");
         }
-        catch (_c) {
-            if (!res.headersSent) {
-                res.writeHead(400, { "content-type": "text/plain; charset=utf-8" });
-                res.end("Playground proxy failed to read request body");
-            }
-            return;
+        return;
+    }
+    const forward = (state, deferWriteOnUnauthorized) => forwardOnce({
+        method,
+        pathWithQuery: pathParse.path,
+        inboundHeaders: req.headers,
+        body,
+        state,
+        res,
+        deferWriteOnUnauthorized,
+    });
+    try {
+        await ensureFreshAccess(false);
+        let status = await forward(getState(), canRefresh);
+        if (status === 401 && canRefresh) {
+            await ensureFreshAccess(true);
+            // Retry once; always write this response (even if still 401).
+            status = await forward(getState(), false);
         }
-        const forward = (state, deferWriteOnUnauthorized) => forwardOnce({
-            method,
-            pathWithQuery: pathParse.path,
-            inboundHeaders: req.headers,
-            body,
-            state,
-            res,
-            deferWriteOnUnauthorized,
-        });
-        try {
-            yield ensureFreshAccess(false);
-            let status = yield forward(getState(), canRefresh);
-            if (status === 401 && canRefresh) {
-                yield ensureFreshAccess(true);
-                // Retry once; always write this response (even if still 401).
-                status = yield forward(getState(), false);
-            }
-            void status;
+        void status;
+    }
+    catch (error) {
+        if (!res.headersSent) {
+            const message = error instanceof Error ? error.message : String(error);
+            res.writeHead(502, { "content-type": "text/plain; charset=utf-8" });
+            res.end(`Playground proxy upstream error: ${message}`);
         }
-        catch (error) {
-            if (!res.headersSent) {
-                const message = error instanceof Error ? error.message : String(error);
-                res.writeHead(502, { "content-type": "text/plain; charset=utf-8" });
-                res.end(`Playground proxy upstream error: ${message}`);
-            }
-            else if (!res.writableEnded) {
-                res.end();
-            }
+        else if (!res.writableEnded) {
+            res.end();
         }
-    });
+    }
 }
 /**
  * Cookies are host-scoped across ports on 127.0.0.1, so SameSite=Strict alone
@@ -359,76 +320,75 @@ function readCookie(header, name) {
     }
     return undefined;
 }
-function forwardOnce(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { method, pathWithQuery, inboundHeaders, body, state, res } = args;
-        const target = buildTargetUrl(pathWithQuery, state.upstream);
-        const outboundHeaders = {};
-        for (const [name, value] of Object.entries(inboundHeaders)) {
-            if (value === undefined)
-                continue;
-            const lower = name.toLowerCase();
-            if (HOP_BY_HOP.has(lower))
-                continue;
-            if (lower === "authorization")
-                continue;
-            // Do not forward the loopback session cookie upstream.
-            if (lower === "cookie")
-                continue;
-            if (BROWSER_PROVENANCE.has(lower))
-                continue;
-            outboundHeaders[name] = value;
-        }
-        for (const [name, value] of Object.entries(state.injectHeaders)) {
-            outboundHeaders[name] = value;
-        }
-        outboundHeaders.host = target.host;
-        outboundHeaders["content-length"] = String(body.byteLength);
-        const isHttps = target.protocol === "https:";
-        const requestFn = isHttps ? httpsRequest : httpRequest;
-        const options = {
-            protocol: target.protocol,
-            hostname: target.hostname,
-            port: target.port === "" ? (isHttps ? 443 : 80) : Number(target.port),
-            method,
-            path: `${target.pathname}${target.search}`,
-            headers: outboundHeaders,
-        };
-        return yield new Promise((resolve, reject) => {
-            const upstreamReq = requestFn(options, upstreamRes => {
-                var _a;
-                const status = (_a = upstreamRes.statusCode) !== null && _a !== void 0 ? _a : 502;
-                if (status === 401 && args.deferWriteOnUnauthorized) {
-                    // Drain so the socket can be reused; caller will refresh + retry.
-                    upstreamRes.resume();
-                    upstreamRes.on("end", () => resolve(status));
-                    upstreamRes.on("error", () => resolve(status));
-                    return;
-                }
-                const responseHeaders = Object.assign({}, upstreamRes.headers);
-                for (const hop of HOP_BY_HOP) {
-                    delete responseHeaders[hop];
-                }
-                res.writeHead(status, responseHeaders);
-                upstreamRes.pipe(res);
+async function forwardOnce(args) {
+    const { method, pathWithQuery, inboundHeaders, body, state, res } = args;
+    const target = buildTargetUrl(pathWithQuery, state.upstream);
+    const outboundHeaders = {};
+    for (const [name, value] of Object.entries(inboundHeaders)) {
+        if (value === undefined)
+            continue;
+        const lower = name.toLowerCase();
+        if (HOP_BY_HOP.has(lower))
+            continue;
+        if (lower === "authorization")
+            continue;
+        // Do not forward the loopback session cookie upstream.
+        if (lower === "cookie")
+            continue;
+        if (BROWSER_PROVENANCE.has(lower))
+            continue;
+        outboundHeaders[name] = value;
+    }
+    for (const [name, value] of Object.entries(state.injectHeaders)) {
+        outboundHeaders[name] = value;
+    }
+    outboundHeaders.host = target.host;
+    outboundHeaders["content-length"] = String(body.byteLength);
+    const isHttps = target.protocol === "https:";
+    const requestFn = isHttps ? httpsRequest : httpRequest;
+    const options = {
+        protocol: target.protocol,
+        hostname: target.hostname,
+        port: target.port === "" ? (isHttps ? 443 : 80) : Number(target.port),
+        method,
+        path: `${target.pathname}${target.search}`,
+        headers: outboundHeaders,
+    };
+    return await new Promise((resolve, reject) => {
+        const upstreamReq = requestFn(options, upstreamRes => {
+            const status = upstreamRes.statusCode ?? 502;
+            if (status === 401 && args.deferWriteOnUnauthorized) {
+                // Drain so the socket can be reused; caller will refresh + retry.
+                upstreamRes.resume();
                 upstreamRes.on("end", () => resolve(status));
-                upstreamRes.on("error", () => {
-                    if (!res.writableEnded) {
-                        res.end();
-                    }
-                    resolve(status);
-                });
-            });
-            upstreamReq.on("error", error => {
-                reject(error);
-            });
-            res.on("close", () => {
+                upstreamRes.on("error", () => resolve(status));
+                return;
+            }
+            const responseHeaders = {
+                ...upstreamRes.headers,
+            };
+            for (const hop of HOP_BY_HOP) {
+                delete responseHeaders[hop];
+            }
+            res.writeHead(status, responseHeaders);
+            upstreamRes.pipe(res);
+            upstreamRes.on("end", () => resolve(status));
+            upstreamRes.on("error", () => {
                 if (!res.writableEnded) {
-                    upstreamReq.destroy();
+                    res.end();
                 }
+                resolve(status);
             });
-            upstreamReq.end(body);
         });
+        upstreamReq.on("error", error => {
+            reject(error);
+        });
+        res.on("close", () => {
+            if (!res.writableEnded) {
+                upstreamReq.destroy();
+            }
+        });
+        upstreamReq.end(body);
     });
 }
 /**