@cursor/july 0.1.2 → 0.1.3

package/dist/internal/cli-ax.js

@@ -19,12 +19,22 @@ import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { serve } from "../index.js";
+import { lookupSessionContinuation, runChat } from "./chat-client.js";
+import { cmdLogin } from "./cli-cursor.js";
+import { resolveDeployAuth } from "./cli-deploy.js";
+import { resolveApiKey } from "./cursor/credentials.js";
 import { CLI_COMMAND_NAME } from "./distribution.js";
 import { discoverEvals, filterDiscoveredEvals, runDiscoveredEvals, } from "./eval-runner.js";
-import { initProject, printInitGuide } from "./init-project.js";
+import { formatInitNextSteps, formatInitScaffoldSummary, initNextCommands, initProject, installScaffoldDependencies, printInitGuide, } from "./init-project.js";
+import { offerInstallCursorSkills } from "./install-cursor-skills.js";
+import { runLogsTail, sanitizeCustomerError } from "./logs-client.js";
+import { openBrowser } from "./open-browser.js";
+import { startPlaygroundProxy } from "./playground-proxy.js";
+import { resolveProdSlug, resolveProdTarget } from "./resolve-prod-target.js";
 import { runSession } from "./run-client.js";
+import { fetchSessionEvents, formatSessionsTable, listSessions, } from "./sessions-client.js";
 import { createStreamProgress } from "./stream-progress.js";
-import { formatTrajectoryText, loadTrajectoryFromEventsFile, } from "./trajectory.js";
+import { buildTrajectory, formatTrajectoryText, loadTrajectoryFromEventsFile, } from "./trajectory.js";
 function shouldStreamProgress(options) {
     if (options.stream === false) {
         return false;
@@ -78,11 +88,25 @@ function startEphemeral(options) {
         };
     });
 }
-function resolveTarget(options) {
+export function resolveTarget(options) {
     return __awaiter(this, void 0, void 0, function* () {
+        if (options.prod === true && options.url !== undefined) {
+            die("--prod and --url are mutually exclusive");
+        }
         if (options.url !== undefined) {
             return { agentUrl: options.url.replace(/\/$/, "") };
         }
+        if (options.prod === true) {
+            const prod = yield resolveProdTarget({
+                dir: options.dir,
+                cwd: options.cwd,
+                slug: options.slug,
+                team: options.team,
+                apiKey: options.apiKey,
+                fetchImpl: options.fetchImpl,
+            });
+            return { agentUrl: prod.agentUrl, headers: prod.headers };
+        }
         return startEphemeral(options);
     });
 }
@@ -94,21 +118,166 @@ export function cmdInit(options) {
             printInitGuide();
             return 0;
         }
-        const dir = resolve((_a = options.cwd) !== null && _a !== void 0 ? _a : process.cwd(), target);
+        const cwd = (_a = options.cwd) !== null && _a !== void 0 ? _a : process.cwd();
+        const dir = resolve(cwd, target);
         const result = yield initProject({ dir });
-        process.stdout.write(`${JSON.stringify({
-            ok: true,
-            directory: result.rootDir,
-            created: result.files,
-            next: [
-                `cd ${dir === process.cwd() ? "." : dir}`,
-                `${CLI_COMMAND_NAME} validate`,
-                `${CLI_COMMAND_NAME} info --json`,
-                `${CLI_COMMAND_NAME} run --message "hello"`,
-                `${CLI_COMMAND_NAME} eval`,
-            ],
-        }, null, 2)}\n`);
-        return 0;
+        let signedIn = (yield resolveApiKey()) !== undefined;
+        // Machine-readable path: install deps (piped), never block on browser login.
+        if (options.json) {
+            const install = yield installScaffoldDependencies(result.rootDir, {
+                stdio: "pipe",
+            });
+            process.stdout.write(`${JSON.stringify({
+                ok: install.ok,
+                directory: result.rootDir,
+                created: result.created,
+                skipped: result.skipped,
+                installed: install.ok,
+                installError: install.ok
+                    ? null
+                    : install.stderr.trim() || `npm install exited ${install.exitCode}`,
+                next: initNextCommands({
+                    rootDir: result.rootDir,
+                    cwd,
+                    signedIn,
+                }),
+            }, null, 2)}\n`);
+            return install.ok ? 0 : 1;
+        }
+        process.stdout.write(formatInitScaffoldSummary({
+            rootDir: result.rootDir,
+            files: result.files,
+        }));
+        process.stdout.write("Installing npm packages\n\n");
+        const install = yield installScaffoldDependencies(result.rootDir, {
+            stdio: "inherit",
+        });
+        if (!install.ok) {
+            process.stderr.write(`\nnpm install failed (exit ${install.exitCode}). Fix the install, then run ${CLI_COMMAND_NAME} dev.\n`);
+            return install.exitCode || 1;
+        }
+        process.stdout.write("\n");
+        // Personal Cursor skills so coding agents can pick up create-agent / debug / …
+        try {
+            yield offerInstallCursorSkills();
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`\nCould not install Cursor skills (${message}). Continuing init.\n\n`);
+        }
+        let loginExit = 0;
+        if (!signedIn) {
+            process.stdout.write("Signing you in to Cursor\n\n");
+            loginExit = yield cmdLogin({});
+            signedIn = loginExit === 0 && (yield resolveApiKey()) !== undefined;
+            process.stdout.write("\n");
+        }
+        process.stdout.write(formatInitNextSteps({
+            rootDir: result.rootDir,
+            cwd,
+            signedIn,
+        }));
+        return loginExit;
+    });
+}
+/**
+ * `chat` — talk to a running (or `--prod` hosted) agent. With `--json`,
+ * prints a trajectory instead of the interactive UI.
+ */
+/**
+ * `resume <sessionId>` — reattach the interactive chat REPL to an existing
+ * session (looks up the continuation token via `/v1/sessions` when omitted).
+ * Same flags as `chat` (`--prod`, `--message`, `--json`, …). `--session`
+ * is accepted as a redundant alias for the positional id.
+ */
+export function cmdResume(sessionId, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const resolved = (_a = trimNonEmpty(sessionId)) !== null && _a !== void 0 ? _a : trimNonEmpty(options.sessionId);
+        if (resolved === undefined) {
+            process.stderr.write(`Usage: ${CLI_COMMAND_NAME} resume <sessionId> [--url | --prod] [--message <text>] [--json] [--text]\n` +
+                `                          [--continuation-token <t>] [--slug <slug>] [--team <id>]\n`);
+            return 2;
+        }
+        return cmdChat(Object.assign(Object.assign({}, options), { sessionId: resolved }));
+    });
+}
+function trimNonEmpty(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed === "" ? undefined : trimmed;
+}
+export function cmdChat(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        var _b, _c;
+        const message = (_a = options.messages) === null || _a === void 0 ? void 0 : _a[0];
+        // chat never starts an ephemeral server — default to local serve URL.
+        const target = yield resolveTarget(Object.assign(Object.assign({}, options), { url: options.prod === true
+                ? undefined
+                : ((_b = options.url) !== null && _b !== void 0 ? _b : "http://127.0.0.1:3000") }));
+        if (options.json) {
+            if (message === undefined) {
+                process.stderr.write("chat --json requires --message\n");
+                return 2;
+            }
+            let continuationToken = options.continuationToken;
+            if (options.sessionId !== undefined &&
+                (continuationToken === undefined || continuationToken === "")) {
+                try {
+                    continuationToken = yield lookupSessionContinuation({
+                        baseUrl: target.agentUrl,
+                        sessionId: options.sessionId,
+                        auth: {
+                            bearerToken: options.bearerToken,
+                            headers: target.headers,
+                        },
+                    });
+                }
+                catch (error) {
+                    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+                    return 1;
+                }
+            }
+            const result = yield runSession({
+                baseUrl: target.agentUrl,
+                messages: [message],
+                sessionId: options.sessionId,
+                continuationToken,
+                bearerToken: options.bearerToken,
+                headers: target.headers,
+            });
+            if (options.text) {
+                process.stdout.write(formatTrajectoryText(result.trajectory));
+            }
+            else {
+                console.log(JSON.stringify({
+                    ok: result.ok,
+                    sessionId: result.sessionId,
+                    continuationToken: (_c = result.continuationToken) !== null && _c !== void 0 ? _c : null,
+                    trajectory: result.trajectory,
+                }, null, 2));
+            }
+            return result.ok ? 0 : 1;
+        }
+        try {
+            yield runChat({
+                baseUrl: target.agentUrl,
+                message,
+                sessionId: options.sessionId,
+                continuationToken: options.continuationToken,
+                bearerToken: options.bearerToken,
+                headers: target.headers,
+                noColor: options.noColor,
+            });
+            return 0;
+        }
+        catch (error) {
+            process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+            return 1;
+        }
     });
 }
 export function cmdRun(options) {
@@ -125,17 +294,16 @@ export function cmdRun(options) {
             if (stream) {
                 process.stderr.write(`→ ${target.agentUrl}\n`);
             }
-            const result = yield runSession(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ baseUrl: target.agentUrl, messages }, (options.sessionId === undefined
-                ? {}
-                : { sessionId: options.sessionId })), (options.continuationToken === undefined
-                ? {}
-                : { continuationToken: options.continuationToken })), (options.bearerToken === undefined
-                ? {}
-                : { bearerToken: options.bearerToken })), (options.timeoutMs === undefined
-                ? {}
-                : { timeoutMs: options.timeoutMs })), (progress === undefined
-                ? {}
-                : { onEvent: (e) => progress.onEvent(e) })));
+            const result = yield runSession({
+                baseUrl: target.agentUrl,
+                messages,
+                sessionId: options.sessionId,
+                continuationToken: options.continuationToken,
+                bearerToken: options.bearerToken,
+                headers: target.headers,
+                timeoutMs: options.timeoutMs,
+                onEvent: progress === undefined ? undefined : (e) => progress.onEvent(e),
+            });
             let eventsPath;
             const writeEvents = options.events !== false;
             if (writeEvents) {
@@ -150,8 +318,25 @@ export function cmdRun(options) {
                 }
                 yield writeFile(eventsPath, `${result.events.map((e) => JSON.stringify(e)).join("\n")}\n`, "utf8");
             }
-            const playgroundUrl = options.url !== undefined
-                ? `${target.agentUrl.replace(/\/$/, "")}/playground?sessionId=${encodeURIComponent(result.sessionId)}`
+            const playgroundUrl = options.prod === true
+                ? null
+                : options.url !== undefined
+                    ? `${target.agentUrl.replace(/\/$/, "")}/playground?sessionId=${encodeURIComponent(result.sessionId)}`
+                    : null;
+            const playgroundHint = options.prod === true
+                ? [
+                    CLI_COMMAND_NAME,
+                    "playground",
+                    "--prod",
+                    ...(options.slug !== undefined && options.slug.trim() !== ""
+                        ? ["--slug", options.slug.trim()]
+                        : []),
+                    ...(options.team !== undefined && options.team.trim() !== ""
+                        ? ["--team", options.team.trim()]
+                        : []),
+                    "--session",
+                    result.sessionId,
+                ].join(" ")
                 : null;
             if (options.text) {
                 process.stdout.write(formatTrajectoryText(result.trajectory));
@@ -161,6 +346,9 @@ export function cmdRun(options) {
                 if (playgroundUrl !== null) {
                     process.stderr.write(`playground: ${playgroundUrl}\n`);
                 }
+                else if (playgroundHint !== null) {
+                    process.stderr.write(`playground: ${playgroundHint}\n`);
+                }
             }
             else {
                 console.log(JSON.stringify({
@@ -169,11 +357,14 @@ export function cmdRun(options) {
                     continuationToken: (_c = result.continuationToken) !== null && _c !== void 0 ? _c : null,
                     trace: eventsPath !== null && eventsPath !== void 0 ? eventsPath : null,
                     playgroundUrl,
-                    visualize: playgroundUrl !== null
-                        ? `Open ${playgroundUrl}`
-                        : eventsPath !== undefined
-                            ? `Start the playground (${CLI_COMMAND_NAME} serve --dir ${options.dir}), then Open trace → ${eventsPath}`
-                            : null,
+                    playgroundHint,
+                    visualize: playgroundHint !== null
+                        ? `Run ${playgroundHint}`
+                        : playgroundUrl !== null
+                            ? `Open ${playgroundUrl}`
+                            : eventsPath !== undefined
+                                ? `Start the playground (${CLI_COMMAND_NAME} serve --dir ${options.dir}), then Open trace → ${eventsPath}`
+                                : null,
                     trajectory: result.trajectory,
                 }, null, 2));
             }
@@ -208,14 +399,23 @@ export function cmdCall(options) {
         }
         const target = yield resolveTarget(options);
         try {
+            const headers = {
+                "content-type": "application/json",
+            };
+            if (target.headers !== undefined) {
+                Object.assign(headers, target.headers);
+            }
+            if (options.bearerToken !== undefined) {
+                headers.authorization = `Bearer ${options.bearerToken}`;
+            }
+            const body = { input };
+            if (options.sessionId !== undefined) {
+                body.sessionId = options.sessionId;
+            }
             const response = yield fetch(`${target.agentUrl}/v1/tools/${encodeURIComponent(toolName)}`, {
                 method: "POST",
-                headers: Object.assign({ "content-type": "application/json" }, (options.bearerToken === undefined
-                    ? {}
-                    : { authorization: `Bearer ${options.bearerToken}` })),
-                body: JSON.stringify(Object.assign({ input }, (options.sessionId === undefined
-                    ? {}
-                    : { sessionId: options.sessionId }))),
+                headers,
+                body: JSON.stringify(body),
             });
             const payload = yield response
                 .json()
@@ -291,17 +491,21 @@ export function cmdEval(options) {
             if (options.verbose || stream) {
                 process.stderr.write(`eval target: ${target.agentUrl}\n`);
             }
-            const results = yield runDiscoveredEvals(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ projectRoot, baseUrl: target.agentUrl }, (options.evalIds === undefined || options.evalIds.length === 0
-                ? {}
-                : { filterIds: options.evalIds })), (options.tags === undefined || options.tags.length === 0
-                ? {}
-                : { tags: options.tags })), (options.timeoutMs === undefined
-                ? {}
-                : { timeoutMs: options.timeoutMs })), (options.bearerToken === undefined
-                ? {}
-                : { bearerToken: options.bearerToken })), { verbose: Boolean(options.verbose) || stream }), (progress === undefined
-                ? {}
-                : { onEvent: (e) => progress.onEvent(e) })));
+            const results = yield runDiscoveredEvals({
+                projectRoot,
+                baseUrl: target.agentUrl,
+                filterIds: options.evalIds === undefined || options.evalIds.length === 0
+                    ? undefined
+                    : options.evalIds,
+                tags: options.tags === undefined || options.tags.length === 0
+                    ? undefined
+                    : options.tags,
+                timeoutMs: options.timeoutMs,
+                bearerToken: options.bearerToken,
+                headers: target.headers,
+                verbose: Boolean(options.verbose) || stream,
+                onEvent: progress === undefined ? undefined : (e) => progress.onEvent(e),
+            });
             if (results.length === 0) {
                 process.stderr.write("No matching evals found.\n");
                 return 2;
@@ -343,3 +547,347 @@ function printEvalResults(results, options) {
     }
     return failed === 0 ? 0 : 1;
 }
+/**
+ * `logs` — follow deploy progress (`--prod`) then runtime agent logs.
+ * Local / `--url` tails `/v1/logs` only.
+ */
+export function cmdLogs(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        if (options.prod === true && options.url !== undefined) {
+            process.stderr.write("--prod and --url are mutually exclusive\n");
+            return 2;
+        }
+        const controller = new AbortController();
+        const onSignal = () => {
+            controller.abort();
+        };
+        process.on("SIGINT", onSignal);
+        process.on("SIGTERM", onSignal);
+        try {
+            if (options.prod === true) {
+                const slug = resolveProdSlug({
+                    dir: options.dir,
+                    cwd: options.cwd,
+                    slug: options.slug,
+                });
+                const auth = yield resolveDeployAuth({
+                    team: options.team,
+                    apiKey: options.apiKey,
+                    fetchImpl: options.fetchImpl,
+                });
+                if (typeof auth === "number") {
+                    return auth;
+                }
+                yield runLogsTail({
+                    prod: true,
+                    dir: options.dir,
+                    cwd: options.cwd,
+                    slug,
+                    team: options.team,
+                    apiKey: options.apiKey,
+                    bearerToken: options.bearerToken,
+                    once: options.once,
+                    json: options.json,
+                    fetchImpl: options.fetchImpl,
+                    signal: controller.signal,
+                    getDeployment: () => auth.client.getDeployment({ teamId: auth.teamId, slug }),
+                    resolveRuntime: () => __awaiter(this, void 0, void 0, function* () {
+                        const target = yield resolveProdTarget({
+                            dir: options.dir,
+                            cwd: options.cwd,
+                            slug,
+                            team: options.team,
+                            apiKey: options.apiKey,
+                            fetchImpl: options.fetchImpl,
+                            err: () => { },
+                        });
+                        return { agentUrl: target.agentUrl, headers: target.headers };
+                    }),
+                });
+                return 0;
+            }
+            yield runLogsTail({
+                dir: options.dir,
+                cwd: options.cwd,
+                url: (_a = options.url) !== null && _a !== void 0 ? _a : "http://127.0.0.1:3000",
+                bearerToken: options.bearerToken,
+                once: options.once,
+                json: options.json,
+                fetchImpl: options.fetchImpl,
+                signal: controller.signal,
+            });
+            return 0;
+        }
+        catch (error) {
+            if (controller.signal.aborted) {
+                return 0;
+            }
+            const raw = error instanceof Error ? error.message : String(error);
+            process.stderr.write(`${sanitizeCustomerError(raw)}\n`);
+            return 1;
+        }
+        finally {
+            process.off("SIGINT", onSignal);
+            process.off("SIGTERM", onSignal);
+        }
+    });
+}
+/** Resolve local / `--url` / `--prod` agent base URL + request headers. */
+function resolveSessionTarget(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        if (options.prod === true && options.url !== undefined) {
+            process.stderr.write("--prod and --url are mutually exclusive\n");
+            return 2;
+        }
+        if (options.prod === true) {
+            try {
+                const target = yield resolveProdTarget({
+                    dir: options.dir,
+                    cwd: options.cwd,
+                    slug: options.slug,
+                    team: options.team,
+                    apiKey: options.apiKey,
+                    fetchImpl: options.fetchImpl,
+                });
+                return { agentUrl: target.agentUrl, headers: target.headers };
+            }
+            catch (error) {
+                process.stderr.write(`${sanitizeCustomerError(error instanceof Error ? error.message : String(error))}\n`);
+                return 1;
+            }
+        }
+        return {
+            agentUrl: ((_a = options.url) !== null && _a !== void 0 ? _a : "http://127.0.0.1:3000").replace(/\/$/, ""),
+        };
+    });
+}
+/**
+ * `sessions` — list sessions on a running (or `--prod` hosted) agent.
+ */
+export function cmdSessions(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const target = yield resolveSessionTarget(options);
+        if (typeof target === "number") {
+            return target;
+        }
+        try {
+            const sessions = yield listSessions({
+                baseUrl: target.agentUrl,
+                auth: {
+                    bearerToken: options.bearerToken,
+                    headers: target.headers,
+                },
+                fetchImpl: options.fetchImpl,
+            });
+            if (options.json === true) {
+                process.stdout.write(`${JSON.stringify({ sessions }, null, 2)}\n`);
+                return 0;
+            }
+            process.stdout.write(formatSessionsTable(sessions));
+            return 0;
+        }
+        catch (error) {
+            process.stderr.write(`${sanitizeCustomerError(error instanceof Error ? error.message : String(error))}\n`);
+            return 1;
+        }
+    });
+}
+/**
+ * `session <id>` — view a full session (trajectory text by default).
+ * `--json` → trajectory JSON; `--events` (`rawEvents`) → raw event list.
+ * Interactive reattach: `resume <id>` (or `chat --session`).
+ */
+export function cmdSession(sessionId, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (sessionId === undefined || sessionId.trim() === "") {
+            process.stderr.write(`Usage: ${CLI_COMMAND_NAME} session <sessionId> [--url | --prod] [--json | --text | --events]\n`);
+            return 2;
+        }
+        if (options.rawEvents === true && options.json === true) {
+            process.stderr.write("--events and --json are mutually exclusive\n");
+            return 2;
+        }
+        const target = yield resolveSessionTarget(options);
+        if (typeof target === "number") {
+            return target;
+        }
+        try {
+            const events = yield fetchSessionEvents({
+                baseUrl: target.agentUrl,
+                sessionId,
+                auth: {
+                    bearerToken: options.bearerToken,
+                    headers: target.headers,
+                },
+                fetchImpl: options.fetchImpl,
+            });
+            if (options.rawEvents === true) {
+                process.stdout.write(`${JSON.stringify({ sessionId, events }, null, 2)}\n`);
+                return 0;
+            }
+            const trajectory = buildTrajectory(events);
+            if (options.json === true) {
+                process.stdout.write(`${JSON.stringify(trajectory, null, 2)}\n`);
+                return 0;
+            }
+            process.stdout.write(formatTrajectoryText(trajectory));
+            return 0;
+        }
+        catch (error) {
+            process.stderr.write(`${sanitizeCustomerError(error instanceof Error ? error.message : String(error))}\n`);
+            return 1;
+        }
+    });
+}
+/**
+ * `playground` — open the web UI against local / `--url` / `--prod`.
+ *
+ * Hosted engines need short-lived access headers a browser cannot set, so
+ * `--prod` (and `--bearer-token`) run a loopback reverse proxy that injects
+ * them. Ctrl-C stops the proxy.
+ */
+export function cmdPlayground(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (options.prod === true && options.url !== undefined) {
+            process.stderr.write("--prod and --url are mutually exclusive\n");
+            return 2;
+        }
+        const sessionId = options.sessionId !== undefined && options.sessionId.trim() !== ""
+            ? options.sessionId.trim()
+            : undefined;
+        // Hosted: mint engineAccess and refresh it for the life of the proxy.
+        if (options.prod === true) {
+            let initial;
+            try {
+                initial = yield resolveProdTarget({
+                    dir: options.dir,
+                    cwd: options.cwd,
+                    slug: options.slug,
+                    team: options.team,
+                    apiKey: options.apiKey,
+                    fetchImpl: options.fetchImpl,
+                });
+            }
+            catch (error) {
+                process.stderr.write(`${sanitizeCustomerError(error instanceof Error ? error.message : String(error))}\n`);
+                return 1;
+            }
+            let proxy;
+            try {
+                proxy = yield startPlaygroundProxy({
+                    upstreamUrl: initial.agentUrl,
+                    headers: initial.headers,
+                    expiresAt: initial.expiresAt,
+                    refreshUpstream: () => __awaiter(this, void 0, void 0, function* () {
+                        var _a;
+                        const next = yield resolveProdTarget({
+                            dir: options.dir,
+                            cwd: options.cwd,
+                            slug: (_a = options.slug) !== null && _a !== void 0 ? _a : initial.slug,
+                            team: options.team,
+                            apiKey: options.apiKey,
+                            fetchImpl: options.fetchImpl,
+                            err: () => { },
+                        });
+                        return {
+                            upstreamUrl: next.agentUrl,
+                            headers: next.headers,
+                            expiresAt: next.expiresAt,
+                        };
+                    }),
+                });
+            }
+            catch (error) {
+                process.stderr.write(`${sanitizeCustomerError(error instanceof Error ? error.message : String(error))}\n`);
+                return 1;
+            }
+            return yield runPlaygroundProxySession({
+                proxy,
+                sessionId,
+                print: options.print === true,
+                signal: options.signal,
+            });
+        }
+        const target = yield resolveSessionTarget(options);
+        if (typeof target === "number") {
+            return target;
+        }
+        const needsProxy = (target.headers !== undefined && Object.keys(target.headers).length > 0) ||
+            (options.bearerToken !== undefined && options.bearerToken.trim() !== "");
+        if (!needsProxy) {
+            const base = `${target.agentUrl.replace(/\/$/, "")}/playground`;
+            const playgroundUrl = sessionId === undefined
+                ? base
+                : `${base}?sessionId=${encodeURIComponent(sessionId)}`;
+            process.stdout.write(`${playgroundUrl}\n`);
+            if (options.print !== true) {
+                openBrowser(playgroundUrl);
+            }
+            return 0;
+        }
+        let proxy;
+        try {
+            proxy = yield startPlaygroundProxy({
+                upstreamUrl: target.agentUrl,
+                headers: target.headers,
+                bearerToken: options.bearerToken,
+            });
+        }
+        catch (error) {
+            process.stderr.write(`${sanitizeCustomerError(error instanceof Error ? error.message : String(error))}\n`);
+            return 1;
+        }
+        return yield runPlaygroundProxySession({
+            proxy,
+            sessionId,
+            print: options.print === true,
+            signal: options.signal,
+        });
+    });
+}
+function runPlaygroundProxySession(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { proxy } = args;
+        const playgroundUrl = proxy.playgroundUrl(args.sessionId);
+        process.stdout.write(`${playgroundUrl}\n`);
+        process.stderr.write(`Playground proxy on loopback (Ctrl-C to stop).\n`);
+        if (args.print !== true) {
+            openBrowser(playgroundUrl);
+        }
+        const controller = new AbortController();
+        const onSignal = () => {
+            controller.abort();
+        };
+        process.on("SIGINT", onSignal);
+        process.on("SIGTERM", onSignal);
+        const external = args.signal;
+        if (external !== undefined) {
+            if (external.aborted) {
+                controller.abort();
+            }
+            else {
+                external.addEventListener("abort", onSignal, { once: true });
+            }
+        }
+        try {
+            yield new Promise((resolve) => {
+                if (controller.signal.aborted) {
+                    resolve();
+                    return;
+                }
+                controller.signal.addEventListener("abort", () => resolve(), {
+                    once: true,
+                });
+            });
+            return 0;
+        }
+        finally {
+            process.off("SIGINT", onSignal);
+            process.off("SIGTERM", onSignal);
+            external === null || external === void 0 ? void 0 : external.removeEventListener("abort", onSignal);
+            yield proxy.close().catch(() => { });
+        }
+    });
+}