@cursor/july 0.1.2 → 0.1.4

package/dist/internal/open-browser.js

@@ -0,0 +1,34 @@
+/**
+ * Best-effort browser open; callers should always print the URL as fallback.
+ */
+import { spawn } from "node:child_process";
+import { join } from "node:path";
+export function openBrowser(url) {
+    var _a;
+    const command = process.platform === "darwin"
+        ? { cmd: "open", args: [url] }
+        : process.platform === "win32"
+            ? {
+                cmd: join((_a = process.env.SYSTEMROOT) !== null && _a !== void 0 ? _a : "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "powershell.exe"),
+                args: [
+                    "-NoProfile",
+                    "-NonInteractive",
+                    "-WindowStyle",
+                    "Hidden",
+                    "-Command",
+                    `Start-Process '${url.replace(/'/g, "''")}'`,
+                ],
+            }
+            : { cmd: "xdg-open", args: [url] };
+    try {
+        const child = spawn(command.cmd, command.args, {
+            stdio: "ignore",
+            detached: true,
+        });
+        child.on("error", () => { });
+        child.unref();
+    }
+    catch (_b) {
+        // Printed URL is the fallback.
+    }
+}

package/dist/internal/playground/toolchain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolchain.d.ts","sourceRoot":"","sources":["../../../src/internal/playground/toolchain.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAWH,4EAA4E;AAC5E,wBAAgB,WAAW,IAAI,MAAM,CAGpC;AAED,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB;AAmCD,0EAA0E;AAC1E,wBAAgB,0BAA0B,IAAI,mBAAmB,GAAG,SAAS,CAW5E;AAED,wBAAgB,4BAA4B,IAAI,OAAO,CAEtD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,aAAa,CAAC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,GACtC,MAAM,GAAG,SAAS,CAKpB;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,MAAM,GAAG,SAAS,CAUpB;AAED,oEAAoE;AACpE,wBAAsB,kBAAkB,CACtC,MAAM,GAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAkB,GAC3C,OAAO,CAAC,IAAI,CAAC,CAoBf;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC1C,MAAM,GAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAkB,GAC3C,OAAO,CAAC,IAAI,CAAC,CAWf;AAED,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,IAAI,IAAI,CAAC;CACd;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iEAAiE;IACjE,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC,GAAG,mBAAmB,GAAG,SAAS,CA4ElC;AAED,wBAAgB,iBAAiB,IAAI,MAAM,CAM1C"}
+{"version":3,"file":"toolchain.d.ts","sourceRoot":"","sources":["../../../src/internal/playground/toolchain.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAWH,4EAA4E;AAC5E,wBAAgB,WAAW,IAAI,MAAM,CAGpC;AAED,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB;AAmCD,0EAA0E;AAC1E,wBAAgB,0BAA0B,IAAI,mBAAmB,GAAG,SAAS,CAW5E;AAED,wBAAgB,4BAA4B,IAAI,OAAO,CAEtD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,aAAa,CAAC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,GACtC,MAAM,GAAG,SAAS,CAKpB;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,MAAM,GAAG,SAAS,CAUpB;AAED,oEAAoE;AACpE,wBAAsB,kBAAkB,CACtC,MAAM,GAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAkB,GAC3C,OAAO,CAAC,IAAI,CAAC,CAoBf;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC1C,MAAM,GAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAkB,GAC3C,OAAO,CAAC,IAAI,CAAC,CAWf;AAED,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,IAAI,IAAI,CAAC;CACd;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iEAAiE;IACjE,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC,GAAG,mBAAmB,GAAG,SAAS,CA8ElC;AAED,wBAAgB,iBAAiB,IAAI,MAAM,CAM1C"}

package/dist/internal/playground/toolchain.js

@@ -109,7 +109,7 @@ export function runPlaygroundBuild() {
         if (toolchain === undefined) {
             throw new Error("playground vite toolchain unavailable (need playground/ sources and the vite package)");
         }
-        logger("[agent-serve] building playground (vite)...");
+        logger("[agentkit] building playground (vite)...");
         const code = yield spawnVite(toolchain, ["build", "--config", VITE_CONFIG], {
             env: process.env,
         });
@@ -119,7 +119,7 @@ export function runPlaygroundBuild() {
         if (!playgroundBundleExists()) {
             throw new Error("playground vite build finished but dist/playground/index.html is missing");
         }
-        logger("[agent-serve] playground build complete");
+        logger("[agentkit] playground build complete");
     });
 }
 /**
@@ -133,7 +133,7 @@ export function ensurePlaygroundBundle() {
             return;
         }
         if (resolvePlaygroundToolchain() === undefined) {
-            logger("[agent-serve] playground bundle missing and vite toolchain unavailable; /playground will show a build hint");
+            logger("[agentkit] playground bundle missing and vite toolchain unavailable; /playground will show a build hint");
             return;
         }
         yield runPlaygroundBuild(logger);
@@ -146,7 +146,8 @@ export function ensurePlaygroundBundle() {
  */
 export function startPlaygroundDevServer(options) {
     var _a;
-    const logger = (_a = options.logger) !== null && _a !== void 0 ? _a : console.log;
+    var _b;
+    const logger = (_b = options.logger) !== null && _b !== void 0 ? _b : console.log;
     const toolchain = resolvePlaygroundToolchain();
     if (toolchain === undefined) {
         return undefined;
@@ -167,30 +168,34 @@ export function startPlaygroundDevServer(options) {
             delete env.AGENT_SERVE_BASE;
         }
     }
-    const modeNote = multiAgent
-        ? " (multi-agent)"
-        : options.basePath
-            ? ` (base ${options.basePath})`
-            : "";
-    logger(`[agent-serve] playground HMR starting on http://127.0.0.1:${port}${modeNote}`);
-    const child = spawn(process.execPath, [toolchain.viteCli, "--config", VITE_CONFIG], {
+    // Quiet + isolated from the TTY: the serve banner owns the terminal.
+    // Piped stdio keeps Vite from seeing a TTY (so it cannot clearScreen), and
+    // silent logging drops the "VITE ready" / URL spam. Errors still surface via
+    // spawn/exit handlers below.
+    const child = spawn(process.execPath, [toolchain.viteCli, "--config", VITE_CONFIG, "--logLevel", "silent"], {
         cwd: toolchain.packageRoot,
         env,
-        stdio: "inherit",
+        stdio: ["ignore", "ignore", "pipe"],
+    });
+    (_a = child.stderr) === null || _a === void 0 ? void 0 : _a.on("data", (chunk) => {
+        const text = chunk.toString().trimEnd();
+        if (text !== "") {
+            logger(`[agentkit] playground: ${text}`);
+        }
     });
     let stopped = false;
     child.on("error", (err) => {
         if (stopped) {
             return;
         }
-        logger(`[agent-serve] playground HMR spawn failed: ${err.message} — static /playground still served when built`);
+        logger(`[agentkit] playground spawn failed: ${err.message} — static /playground still served when built`);
     });
     child.on("exit", (code, signal) => {
         if (stopped) {
             return;
         }
         if (code !== 0 && code !== null) {
-            logger(`[agent-serve] playground HMR exited (code ${code}${signal ? `, signal ${signal}` : ""}) — static /playground still served when built`);
+            logger(`[agentkit] playground exited (code ${code}${signal ? `, signal ${signal}` : ""}) — static /playground still served when built`);
         }
     });
     return {

package/dist/internal/playground-proxy.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Loopback reverse proxy that injects engine / bearer auth so a normal
+ * browser can use the hosted (or remote) playground SPA.
+ *
+ * Hosted engines sit behind short-lived `engineAccess` headers that a
+ * browser cannot set; alias tokens are header-only too. This proxy binds
+ * `127.0.0.1` only and forwards every request upstream with those headers.
+ *
+ * Access is gated by a per-proxy `accessToken` (query on first hit → HttpOnly
+ * cookie): other local processes cannot upgrade to injected credentials just
+ * by knowing the port. Mutating requests also require Origin/Referer to match
+ * this proxy's own origin so another `http://127.0.0.1:<port>` page cannot
+ * CSRF the cookie (cookies are host-scoped across ports). Absolute-form
+ * request-targets are rejected so injected headers never leave the configured
+ * upstream.
+ *
+ * When `refreshUpstream` is provided (hosted `--prod`), credentials are
+ * re-minted shortly before `expiresAt` and once on upstream 401 so a long
+ * playground session does not require restarting the CLI.
+ */
+import { createServer } from "node:http";
+import { openBrowser } from "./open-browser.js";
+export { openBrowser };
+export interface PlaygroundProxyHandle {
+    /** e.g. `http://127.0.0.1:54321` (no trailing slash). */
+    localUrl: string;
+    port: number;
+    /** Random token required via query (first hit) or cookie thereafter. */
+    accessToken: string;
+    /**
+     * Build a browser entry URL for `/playground` that includes the access
+     * token (and optional sessionId).
+     */
+    playgroundUrl: (sessionId?: string) => string;
+    close: () => Promise<void>;
+}
+export interface PlaygroundUpstreamAccess {
+    upstreamUrl: string;
+    headers?: Record<string, string>;
+    expiresAt?: string;
+}
+export interface StartPlaygroundProxyArgs {
+    /** Upstream agent base URL (engineAccess or --url). */
+    upstreamUrl: string;
+    /** Headers injected on every upstream request (engine tokens, wake, …). */
+    headers?: Record<string, string>;
+    /** Optional bearer for local servers that require it. */
+    bearerToken?: string;
+    /** Initial engineAccess expiry (ISO); enables proactive refresh. */
+    expiresAt?: string;
+    /**
+     * Re-mint upstream URL + headers (hosted `--prod`). Single-flighted across
+     * concurrent browser requests; called near expiry and once on 401.
+     */
+    refreshUpstream?: () => Promise<PlaygroundUpstreamAccess>;
+    /** Bind port; `0` = ephemeral. */
+    port?: number;
+    /** Injected for tests. */
+    createServerImpl?: typeof createServer;
+    /** Injected clock for expiry tests. */
+    now?: () => number;
+    /** Injected token for tests (defaults to a random 32-byte value). */
+    accessToken?: string;
+}
+/**
+ * Start a loopback proxy. Resolves once listening.
+ */
+export declare function startPlaygroundProxy(args: StartPlaygroundProxyArgs): Promise<PlaygroundProxyHandle>;
+//# sourceMappingURL=playground-proxy.d.ts.map

package/dist/internal/playground-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playground-proxy.d.ts","sourceRoot":"","sources":["../../src/internal/playground-proxy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EACL,YAAY,EAMb,MAAM,WAAW,CAAC;AAInB,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EAAE,WAAW,EAAE,CAAC;AAqBvB,MAAM,WAAW,qBAAqB;IACpC,yDAAyD;IACzD,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,wEAAwE;IACxE,WAAW,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,aAAa,EAAE,CAAC,SAAS,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAC9C,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B;AAED,MAAM,WAAW,wBAAwB;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,wBAAwB;IACvC,uDAAuD;IACvD,WAAW,EAAE,MAAM,CAAC;IACpB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,yDAAyD;IACzD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,oEAAoE;IACpE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,OAAO,CAAC,wBAAwB,CAAC,CAAC;IAC1D,kCAAkC;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,0BAA0B;IAC1B,gBAAgB,CAAC,EAAE,OAAO,YAAY,CAAC;IACvC,uCAAuC;IACvC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,qEAAqE;IACrE,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAQD;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,wBAAwB,GAC7B,OAAO,CAAC,qBAAqB,CAAC,CAmGhC"}

package/dist/internal/playground-proxy.js

@@ -0,0 +1,468 @@
+/**
+ * Loopback reverse proxy that injects engine / bearer auth so a normal
+ * browser can use the hosted (or remote) playground SPA.
+ *
+ * Hosted engines sit behind short-lived `engineAccess` headers that a
+ * browser cannot set; alias tokens are header-only too. This proxy binds
+ * `127.0.0.1` only and forwards every request upstream with those headers.
+ *
+ * Access is gated by a per-proxy `accessToken` (query on first hit → HttpOnly
+ * cookie): other local processes cannot upgrade to injected credentials just
+ * by knowing the port. Mutating requests also require Origin/Referer to match
+ * this proxy's own origin so another `http://127.0.0.1:<port>` page cannot
+ * CSRF the cookie (cookies are host-scoped across ports). Absolute-form
+ * request-targets are rejected so injected headers never leave the configured
+ * upstream.
+ *
+ * When `refreshUpstream` is provided (hosted `--prod`), 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";
+import { URL } from "node:url";
+import { openBrowser } from "./open-browser.js";
+export { openBrowser };
+const HOP_BY_HOP = new Set([
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "trailers",
+    "transfer-encoding",
+    "upgrade",
+    "host",
+    "content-length",
+]);
+/** Re-mint when the port token is within this window of expiry. */
+const ACCESS_EXPIRY_LEEWAY_MS = 5 * 60 * 1000;
+const PROXY_COOKIE = "agentkit_playground_proxy";
+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;
+                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 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();
+                    }
+                    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(/\/$/, ""));
+    if (upstream.protocol !== "http:" && upstream.protocol !== "https:") {
+        throw new Error(`Unsupported upstream protocol: ${upstream.protocol}`);
+    }
+    return upstream;
+}
+function parseExpiresAtMs(expiresAt) {
+    if (expiresAt === undefined || expiresAt.trim() === "") {
+        return undefined;
+    }
+    const ms = Date.parse(expiresAt);
+    return Number.isFinite(ms) ? ms : undefined;
+}
+function buildInjectHeaders(headers, bearerToken) {
+    const out = Object.assign({}, (headers !== null && headers !== void 0 ? 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);
+    });
+}
+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,
+        });
+        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);
+        }
+        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;
+        }
+        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;
+        }
+        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();
+            }
+        }
+    });
+}
+/**
+ * Cookies are host-scoped across ports on 127.0.0.1, so SameSite=Strict alone
+ * does not stop CSRF from another loopback origin. Require the browser's
+ * Origin (or Referer / Sec-Fetch-Site: same-origin) to match this proxy for
+ * mutating methods. Safe methods stay cookie-gated only (no side effects).
+ */
+function isTrustedBrowserOrigin(args) {
+    const method = args.method.toUpperCase();
+    if (method === "GET" || method === "HEAD" || method === "OPTIONS") {
+        return true;
+    }
+    if (args.proxyOrigin === "") {
+        return false;
+    }
+    if (args.origin === args.proxyOrigin) {
+        return true;
+    }
+    if (args.referer !== undefined &&
+        (args.referer === args.proxyOrigin ||
+            args.referer.startsWith(`${args.proxyOrigin}/`))) {
+        return true;
+    }
+    // Some same-origin fetches omit Origin; modern browsers still send this.
+    if (args.secFetchSite === "same-origin") {
+        return true;
+    }
+    return false;
+}
+function headerString(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return Array.isArray(value) ? value[0] : value;
+}
+function authorizeLocalRequest(args) {
+    const cookieToken = readCookie(args.cookieHeader, PROXY_COOKIE);
+    if (cookieToken === args.accessToken) {
+        return { kind: "allow" };
+    }
+    const url = new URL(args.pathWithQuery, "http://127.0.0.1");
+    const queryToken = url.searchParams.get(PROXY_TOKEN_QUERY);
+    if (queryToken === args.accessToken) {
+        url.searchParams.delete(PROXY_TOKEN_QUERY);
+        const redirectPath = `${url.pathname}${url.search}`;
+        return {
+            kind: "bootstrap",
+            redirectPath,
+            setCookie: `${PROXY_COOKIE}=${args.accessToken}; Path=/; HttpOnly; SameSite=Strict`,
+        };
+    }
+    return { kind: "deny" };
+}
+function readCookie(header, name) {
+    if (header === undefined) {
+        return undefined;
+    }
+    const raw = Array.isArray(header) ? header.join("; ") : header;
+    for (const part of raw.split(";")) {
+        const trimmed = part.trim();
+        const eq = trimmed.indexOf("=");
+        if (eq <= 0)
+            continue;
+        if (trimmed.slice(0, eq) === name) {
+            return trimmed.slice(eq + 1);
+        }
+    }
+    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;
+            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);
+                upstreamRes.on("end", () => resolve(status));
+                upstreamRes.on("error", () => {
+                    if (!res.writableEnded) {
+                        res.end();
+                    }
+                    resolve(status);
+                });
+            });
+            upstreamReq.on("error", (error) => {
+                reject(error);
+            });
+            res.on("close", () => {
+                if (!res.writableEnded) {
+                    upstreamReq.destroy();
+                }
+            });
+            upstreamReq.end(body);
+        });
+    });
+}
+/**
+ * Build an upstream URL that always keeps the configured host/port.
+ * Absolute-form or protocol-relative request-targets must not retarget
+ * outbound requests (injected engine/bearer credentials would follow).
+ */
+function buildTargetUrl(pathWithQuery, upstream) {
+    const pathParse = parseProxyPath(pathWithQuery);
+    const relative = pathParse.ok ? pathParse.path : "/";
+    const target = new URL(relative, upstream);
+    // Force authority back onto the configured upstream even if `new URL`
+    // accepted an absolute/protocol-relative request-target.
+    target.protocol = upstream.protocol;
+    target.hostname = upstream.hostname;
+    target.port = upstream.port;
+    target.username = "";
+    target.password = "";
+    // Preserve upstream pathname prefix when the base URL has one
+    // (unusual for engineAccess; kept for `--url` mounts).
+    if (upstream.pathname !== "/" && upstream.pathname !== "") {
+        const basePath = upstream.pathname.replace(/\/$/, "");
+        if (!pathnameHasPrefix(target.pathname, basePath)) {
+            target.pathname =
+                target.pathname === "/"
+                    ? `${basePath}/`
+                    : `${basePath}${target.pathname}`;
+        }
+    }
+    return target;
+}
+/** Reject absolute / scheme-relative request-targets; keep path + query only. */
+function parseProxyPath(pathWithQuery) {
+    const raw = pathWithQuery.trim();
+    if (raw === "") {
+        return { ok: true, path: "/" };
+    }
+    // Absolute-form ("http://evil/…") or protocol-relative ("//evil/…").
+    if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/u.test(raw) || raw.startsWith("//")) {
+        return { ok: false };
+    }
+    return { ok: true, path: raw.startsWith("/") ? raw : `/${raw}` };
+}
+function pathnameHasPrefix(pathname, basePath) {
+    return pathname === basePath || pathname.startsWith(`${basePath}/`);
+}