@vercel/sandbox 2.0.0-beta.2 → 2.0.0-beta.20

package/dist/api-client/api-client.js

@@ -1,478 +1,442 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.APIClient = void 0;
-const base_client_1 = require("./base-client");
-const validators_1 = require("./validators");
-const api_error_1 = require("./api-error");
-const file_writer_1 = require("./file-writer");
-const version_1 = require("../version");
-const consume_readable_1 = require("../utils/consume-readable");
-const zod_1 = require("zod");
-const jsonlines_1 = __importDefault(require("jsonlines"));
-const os_1 = __importDefault(require("os"));
-const stream_1 = require("stream");
-const normalizePath_1 = require("../utils/normalizePath");
-const oidc_1 = require("@vercel/oidc");
-const network_policy_1 = require("../utils/network-policy");
-const types_1 = require("../utils/types");
-const promises_1 = require("node:timers/promises");
+import { APIError, StreamError } from "./api-error.js";
+import { BaseClient, parseOrThrow } from "./base-client.js";
+import { CommandFinishedResponse, CommandResponse, CreateSnapshotResponse, EmptyResponse, LogLine, SandboxAndSessionResponse, SandboxesPaginationResponse, SessionAndRoutesResponse, SessionResponse, SessionsResponse, SnapshotResponse, SnapshotsResponse, StopSessionResponse, UpdateSandboxResponse } from "./validators.js";
+import { FileWriter } from "./file-writer.js";
+import { VERSION } from "../version.js";
+import { consumeReadable } from "../utils/consume-readable.js";
+import { normalizePath } from "../utils/normalizePath.js";
+import { toAPINetworkPolicy } from "../utils/network-policy.js";
+import { getPrivateParams } from "../utils/types.js";
+import { z } from "zod";
+import { Readable } from "stream";
+import jsonlines from "jsonlines";
+import os from "os";
+import { getVercelOidcToken } from "@vercel/oidc";
+
+//#region src/api-client/api-client.ts
 function decodeUnverifiedToken(token) {
-    if (token.split(".").length !== 3) {
-        return null;
-    }
-    try {
-        const payload = JSON.parse(Buffer.from(token.split(".")[1], "base64url").toString("utf8"));
-        if (payload.owner_id) {
-            return { owner_id: payload.owner_id, project_id: payload.project_id };
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-class APIClient extends base_client_1.BaseClient {
-    constructor(params) {
-        super({
-            baseUrl: params.baseUrl ?? "https://vercel.com/api",
-            token: params.token,
-            debug: false,
-            fetch: params.fetch,
-        });
-        this.teamId = params.teamId;
-        this.isJwtToken = false;
-        const claims = decodeUnverifiedToken(params.token);
-        if (claims) {
-            this.isJwtToken = true;
-            this.projectId = claims.project_id;
-            this.teamId = claims.owner_id;
-        }
-    }
-    async ensureValidToken() {
-        if (!this.isJwtToken) {
-            return;
-        }
-        try {
-            // Use getVercelOidcToken to refresh the token with team/project scope
-            const freshToken = await (0, oidc_1.getVercelOidcToken)({
-                expirationBufferMs: 5 * 60 * 1000, // 5 minutes
-                team: this.teamId,
-                project: this.projectId,
-            });
-            // Update token if it changed
-            if (freshToken !== this.token) {
-                this.token = freshToken;
-                const claims = decodeUnverifiedToken(freshToken);
-                if (claims) {
-                    this.teamId = claims.owner_id;
-                }
-            }
-        }
-        catch {
-            // Ignore refresh errors and continue with current token
-        }
-    }
-    async request(path, params) {
-        await this.ensureValidToken();
-        return super.request(path, {
-            ...params,
-            query: { teamId: this.teamId, ...params?.query },
-            headers: {
-                "content-type": "application/json",
-                "user-agent": `vercel/sandbox/${version_1.VERSION} (Node.js/${process.version}; ${os_1.default.platform()}/${os_1.default.arch()})`,
-                ...params?.headers,
-            },
-        });
-    }
-    async getSandbox(params) {
-        const privateParams = (0, types_1.getPrivateParams)(params);
-        let querystring = new URLSearchParams(privateParams).toString();
-        querystring = querystring ? `?${querystring}` : "";
-        return (0, base_client_1.parseOrThrow)(validators_1.SandboxAndRoutesResponse, await this.request(`/v1/sandboxes/${params.sandboxId}${querystring}`, {
-            signal: params.signal,
-        }));
-    }
-    async createSandbox(params) {
-        const privateParams = (0, types_1.getPrivateParams)(params);
-        return (0, base_client_1.parseOrThrow)(validators_1.NamedSandboxAndSessionResponse, await this.request("/v1/sandboxes/named", {
-            method: "POST",
-            body: JSON.stringify({
-                projectId: params.projectId,
-                ports: params.ports,
-                source: params.source,
-                timeout: params.timeout,
-                resources: params.resources,
-                runtime: params.runtime,
-                name: params.name,
-                persistent: params.persistent,
-                networkPolicy: params.networkPolicy
-                    ? (0, network_policy_1.toAPINetworkPolicy)(params.networkPolicy)
-                    : undefined,
-                env: params.env,
-                ...privateParams,
-            }),
-            signal: params.signal,
-        }));
-    }
-    async runCommand(params) {
-        if (params.wait) {
-            const response = await this.request(`/v1/sandboxes/${params.sandboxId}/cmd`, {
-                method: "POST",
-                body: JSON.stringify({
-                    command: params.command,
-                    args: params.args,
-                    cwd: params.cwd,
-                    env: params.env,
-                    sudo: params.sudo,
-                    wait: true,
-                }),
-                signal: params.signal,
-            });
-            if (!response.ok) {
-                await (0, base_client_1.parseOrThrow)(zod_1.z.any(), response);
-            }
-            if (response.headers.get("content-type") !== "application/x-ndjson") {
-                throw new api_error_1.APIError(response, {
-                    message: "Expected a stream of command data",
-                    sandboxId: params.sandboxId,
-                });
-            }
-            if (response.body === null) {
-                throw new api_error_1.APIError(response, {
-                    message: "No response body",
-                    sandboxId: params.sandboxId,
-                });
-            }
-            const jsonlinesStream = jsonlines_1.default.parse();
-            pipe(response.body, jsonlinesStream).catch((err) => {
-                console.error("Error piping command stream:", err);
-            });
-            const iterator = jsonlinesStream[Symbol.asyncIterator]();
-            const commandChunk = await iterator.next();
-            const { command } = validators_1.CommandResponse.parse(commandChunk.value);
-            const finished = (async () => {
-                const finishedChunk = await iterator.next();
-                const { command } = validators_1.CommandFinishedResponse.parse(finishedChunk.value);
-                return command;
-            })();
-            return { command, finished };
-        }
-        return (0, base_client_1.parseOrThrow)(validators_1.CommandResponse, await this.request(`/v1/sandboxes/${params.sandboxId}/cmd`, {
-            method: "POST",
-            body: JSON.stringify({
-                command: params.command,
-                args: params.args,
-                cwd: params.cwd,
-                env: params.env,
-                sudo: params.sudo,
-            }),
-            signal: params.signal,
-        }));
-    }
-    async getCommand(params) {
-        return params.wait
-            ? (0, base_client_1.parseOrThrow)(validators_1.CommandFinishedResponse, await this.request(`/v1/sandboxes/${params.sandboxId}/cmd/${params.cmdId}`, { signal: params.signal, query: { wait: "true" } }))
-            : (0, base_client_1.parseOrThrow)(validators_1.CommandResponse, await this.request(`/v1/sandboxes/${params.sandboxId}/cmd/${params.cmdId}`, { signal: params.signal }));
-    }
-    async mkDir(params) {
-        return (0, base_client_1.parseOrThrow)(validators_1.EmptyResponse, await this.request(`/v1/sandboxes/${params.sandboxId}/fs/mkdir`, {
-            method: "POST",
-            body: JSON.stringify({ path: params.path, cwd: params.cwd }),
-            signal: params.signal,
-        }));
-    }
-    getFileWriter(params) {
-        const writer = new file_writer_1.FileWriter();
-        return {
-            response: (async () => {
-                return this.request(`/v1/sandboxes/${params.sandboxId}/fs/write`, {
-                    method: "POST",
-                    headers: {
-                        "content-type": "application/gzip",
-                        "x-cwd": params.extractDir,
-                    },
-                    body: await (0, consume_readable_1.consumeReadable)(writer.readable),
-                    signal: params.signal,
-                });
-            })(),
-            writer,
-        };
-    }
-    async listSandboxes(params) {
-        return (0, base_client_1.parseOrThrow)(validators_1.SandboxesResponse, await this.request(`/v1/sandboxes`, {
-            query: {
-                project: params.projectId,
-                name: params.name,
-                limit: params.limit,
-                since: typeof params.since === "number"
-                    ? params.since
-                    : params.since?.getTime(),
-                until: typeof params.until === "number"
-                    ? params.until
-                    : params.until?.getTime(),
-            },
-            method: "GET",
-            signal: params.signal,
-        }));
-    }
-    async listSnapshots(params) {
-        return (0, base_client_1.parseOrThrow)(validators_1.SnapshotsResponse, await this.request(`/v1/sandboxes/snapshots`, {
-            query: {
-                project: params.projectId,
-                name: params.name,
-                limit: params.limit,
-                since: typeof params.since === "number"
-                    ? params.since
-                    : params.since?.getTime(),
-                until: typeof params.until === "number"
-                    ? params.until
-                    : params.until?.getTime(),
-            },
-            method: "GET",
-            signal: params.signal,
-        }));
-    }
-    async writeFiles(params) {
-        const { writer, response } = this.getFileWriter({
-            sandboxId: params.sandboxId,
-            extractDir: params.extractDir,
-            signal: params.signal,
-        });
-        for (const file of params.files) {
-            await writer.addFile({
-                name: (0, normalizePath_1.normalizePath)({
-                    filePath: file.path,
-                    extractDir: params.extractDir,
-                    cwd: params.cwd,
-                }),
-                content: file.content,
-            });
-        }
-        writer.end();
-        await (0, base_client_1.parseOrThrow)(validators_1.EmptyResponse, await response);
-    }
-    async readFile(params) {
-        const response = await this.request(`/v1/sandboxes/${params.sandboxId}/fs/read`, {
-            method: "POST",
-            body: JSON.stringify({ path: params.path, cwd: params.cwd }),
-            signal: params.signal,
-        });
-        if (response.status === 404) {
-            return null;
-        }
-        if (response.body === null) {
-            return null;
-        }
-        return stream_1.Readable.fromWeb(response.body);
-    }
-    async killCommand(params) {
-        return (0, base_client_1.parseOrThrow)(validators_1.CommandResponse, await this.request(`/v1/sandboxes/${params.sandboxId}/${params.commandId}/kill`, {
-            method: "POST",
-            body: JSON.stringify({ signal: params.signal }),
-            signal: params.abortSignal,
-        }));
-    }
-    getLogs(params) {
-        const self = this;
-        const disposer = new AbortController();
-        const signal = !params.signal
-            ? disposer.signal
-            : mergeSignals(params.signal, disposer.signal);
-        const generator = (async function* () {
-            const url = `/v1/sandboxes/${params.sandboxId}/cmd/${params.cmdId}/logs`;
-            const response = await self.request(url, {
-                method: "GET",
-                signal,
-            });
-            if (!response.ok) {
-                await (0, base_client_1.parseOrThrow)(zod_1.z.any(), response);
-            }
-            if (response.headers.get("content-type") !== "application/x-ndjson") {
-                throw new api_error_1.APIError(response, {
-                    message: "Expected a stream of logs",
-                    sandboxId: params.sandboxId,
-                });
-            }
-            if (response.body === null) {
-                throw new api_error_1.APIError(response, {
-                    message: "No response body",
-                    sandboxId: params.sandboxId,
-                });
-            }
-            const jsonlinesStream = jsonlines_1.default.parse();
-            pipe(response.body, jsonlinesStream).catch((err) => {
-                console.error("Error piping logs:", err);
-            });
-            for await (const chunk of jsonlinesStream) {
-                const parsed = validators_1.LogLine.parse(chunk);
-                if (parsed.stream === "error") {
-                    throw new api_error_1.StreamError(parsed.data.code, parsed.data.message, params.sandboxId);
-                }
-                yield parsed;
-            }
-        })();
-        return Object.assign(generator, {
-            [Symbol.dispose]() {
-                disposer.abort("Disposed");
-            },
-            close: () => disposer.abort("Disposed"),
-        });
-    }
-    async stopSandbox(params) {
-        const url = `/v1/sandboxes/${params.sandboxId}/stop`;
-        const response = await (0, base_client_1.parseOrThrow)(validators_1.SandboxResponse, await this.request(url, { method: "POST", signal: params.signal }));
-        if (params.blocking) {
-            let sandbox = response.json.sandbox;
-            while (sandbox.status !== "stopped" && sandbox.status !== "failed" && sandbox.status !== "aborted") {
-                await (0, promises_1.setTimeout)(500, undefined, { signal: params.signal });
-                const poll = await this.getSandbox({
-                    sandboxId: params.sandboxId,
-                    signal: params.signal,
-                });
-                sandbox = poll.json.sandbox;
-                response.json.sandbox = sandbox;
-            }
-        }
-        return response;
-    }
-    async updateNetworkPolicy(params) {
-        const url = `/v1/sandboxes/${params.sandboxId}/network-policy`;
-        return (0, base_client_1.parseOrThrow)(validators_1.UpdateNetworkPolicyResponse, await this.request(url, {
-            method: "POST",
-            body: JSON.stringify((0, network_policy_1.toAPINetworkPolicy)(params.networkPolicy)),
-            signal: params.signal,
-        }));
-    }
-    async extendTimeout(params) {
-        const url = `/v1/sandboxes/${params.sandboxId}/extend-timeout`;
-        return (0, base_client_1.parseOrThrow)(validators_1.ExtendTimeoutResponse, await this.request(url, {
-            method: "POST",
-            body: JSON.stringify({ duration: params.duration }),
-            signal: params.signal,
-        }));
-    }
-    async createSnapshot(params) {
-        const url = `/v1/sandboxes/${params.sandboxId}/snapshot`;
-        const body = params.expiration === undefined
-            ? undefined
-            : JSON.stringify({ expiration: params.expiration });
-        return (0, base_client_1.parseOrThrow)(validators_1.CreateSnapshotResponse, await this.request(url, {
-            method: "POST",
-            body,
-            signal: params.signal,
-        }));
-    }
-    async deleteSnapshot(params) {
-        const url = `/v1/sandboxes/snapshots/${params.snapshotId}`;
-        return (0, base_client_1.parseOrThrow)(validators_1.SnapshotResponse, await this.request(url, { method: "DELETE", signal: params.signal }));
-    }
-    async getSnapshot(params) {
-        const url = `/v1/sandboxes/snapshots/${params.snapshotId}`;
-        return (0, base_client_1.parseOrThrow)(validators_1.SnapshotResponse, await this.request(url, { signal: params.signal }));
-    }
-    async getNamedSandbox(params) {
-        const query = {
-            projectId: params.projectId,
-        };
-        if (params.resume !== undefined) {
-            query.resume = String(params.resume);
-        }
-        return (0, base_client_1.parseOrThrow)(validators_1.NamedSandboxAndSessionResponse, await this.request(`/v1/sandboxes/named/${encodeURIComponent(params.name)}`, {
-            query,
-            signal: params.signal,
-        }));
-    }
-    async listNamedSandboxes(params) {
-        const result = await (0, base_client_1.parseOrThrow)(validators_1.NamedSandboxesPaginationResponse, await this.request(`/v1/sandboxes/named`, {
-            query: {
-                project: params.projectId,
-                limit: params.limit,
-                sortBy: params.sortBy,
-                namePrefix: params.namePrefix,
-                cursor: params.cursor,
-            },
-            method: "GET",
-            signal: params.signal,
-        }));
-        return {
-            ...result,
-            json: {
-                sandboxes: result.json.namedSandboxes,
-                pagination: result.json.pagination,
-            },
-        };
-    }
-    async updateNamedSandbox(params) {
-        return (0, base_client_1.parseOrThrow)(validators_1.UpdateNamedSandboxResponse, await this.request(`/v1/sandboxes/named/${encodeURIComponent(params.name)}`, {
-            method: "PATCH",
-            query: {
-                projectId: params.projectId,
-            },
-            body: JSON.stringify({
-                persistent: params.persistent,
-                resources: params.resources,
-                runtime: params.runtime,
-                timeout: params.timeout,
-                networkPolicy: params.networkPolicy
-                    ? (0, network_policy_1.toAPINetworkPolicy)(params.networkPolicy)
-                    : undefined,
-            }),
-            signal: params.signal,
-        }));
-    }
-    async deleteNamedSandbox(params) {
-        return (0, base_client_1.parseOrThrow)(validators_1.UpdateNamedSandboxResponse, await this.request(`/v1/sandboxes/named/${encodeURIComponent(params.name)}`, {
-            method: "DELETE",
-            query: {
-                projectId: params.projectId,
-                preserveSandboxes: "false",
-                preserveSnapshots: params.preserveSnapshots !== undefined
-                    ? String(params.preserveSnapshots)
-                    : undefined,
-            },
-            signal: params.signal,
-        }));
-    }
+	if (token.split(".").length !== 3) return null;
+	try {
+		const payload = JSON.parse(Buffer.from(token.split(".")[1], "base64url").toString("utf8"));
+		if (payload.owner_id) return {
+			owner_id: payload.owner_id,
+			project_id: payload.project_id
+		};
+		return null;
+	} catch {
+		return null;
+	}
 }
-exports.APIClient = APIClient;
-async function pipe(readable, output) {
-    const reader = readable.getReader();
-    try {
-        while (true) {
-            const read = await reader.read();
-            if (read.value) {
-                output.write(Buffer.from(read.value));
-            }
-            if (read.done) {
-                break;
-            }
-        }
-    }
-    catch (err) {
-        output.emit("error", err);
-    }
-    finally {
-        output.end();
-    }
+var APIClient = class extends BaseClient {
+	constructor(params) {
+		super({
+			baseUrl: params.baseUrl ?? "https://vercel.com/api",
+			token: params.token,
+			debug: false,
+			fetch: params.fetch
+		});
+		this.teamId = params.teamId;
+		this.isJwtToken = false;
+		const claims = decodeUnverifiedToken(params.token);
+		if (claims) {
+			this.isJwtToken = true;
+			this.projectId = claims.project_id;
+			this.teamId = claims.owner_id;
+		}
+	}
+	async ensureValidToken() {
+		if (!this.isJwtToken) return;
+		try {
+			const freshToken = await getVercelOidcToken({
+				expirationBufferMs: 300 * 1e3,
+				team: this.teamId,
+				project: this.projectId
+			});
+			if (freshToken !== this.token) {
+				this.token = freshToken;
+				const claims = decodeUnverifiedToken(freshToken);
+				if (claims) this.teamId = claims.owner_id;
+			}
+		} catch {}
+	}
+	async request(path, params) {
+		await this.ensureValidToken();
+		return super.request(path, {
+			...params,
+			query: {
+				teamId: this.teamId,
+				...params?.query
+			},
+			headers: {
+				"content-type": "application/json",
+				"user-agent": `vercel/sandbox/${VERSION} (Node.js/${process.version}; ${os.platform()}/${os.arch()})`,
+				...params?.headers
+			}
+		});
+	}
+	async getSession(params) {
+		const privateParams = getPrivateParams(params);
+		let querystring = new URLSearchParams(privateParams).toString();
+		querystring = querystring ? `?${querystring}` : "";
+		return parseOrThrow(SessionAndRoutesResponse, await this.request(`/v2/sandboxes/sessions/${params.sessionId}${querystring}`, { signal: params.signal }));
+	}
+	async createSandbox(params) {
+		const privateParams = getPrivateParams(params);
+		return parseOrThrow(SandboxAndSessionResponse, await this.request("/v2/sandboxes", {
+			method: "POST",
+			body: JSON.stringify({
+				projectId: params.projectId,
+				ports: params.ports,
+				source: params.source,
+				timeout: params.timeout,
+				resources: params.resources,
+				runtime: params.runtime,
+				name: params.name,
+				persistent: params.persistent,
+				networkPolicy: params.networkPolicy ? toAPINetworkPolicy(params.networkPolicy) : void 0,
+				env: params.env,
+				tags: params.tags,
+				snapshotExpiration: params.snapshotExpiration,
+				...privateParams
+			}),
+			signal: params.signal
+		}));
+	}
+	async runCommand(params) {
+		if (params.wait) {
+			const response = await this.request(`/v2/sandboxes/sessions/${params.sessionId}/cmd`, {
+				method: "POST",
+				body: JSON.stringify({
+					command: params.command,
+					args: params.args,
+					cwd: params.cwd,
+					env: params.env,
+					sudo: params.sudo,
+					wait: true
+				}),
+				signal: params.signal
+			});
+			if (!response.ok) await parseOrThrow(z.any(), response);
+			if (response.headers.get("content-type") !== "application/x-ndjson") throw new APIError(response, {
+				message: "Expected a stream of command data",
+				sessionId: params.sessionId
+			});
+			if (response.body === null) throw new APIError(response, {
+				message: "No response body",
+				sessionId: params.sessionId
+			});
+			const jsonlinesStream = jsonlines.parse();
+			pipe(response.body, jsonlinesStream, { signal: params.signal }).catch((err) => {
+				console.error("Error piping command stream:", err);
+			});
+			const iterator = jsonlinesStream[Symbol.asyncIterator]();
+			const commandChunk = await iterator.next();
+			if (commandChunk.done) throw new StreamError("stream_ended_early", "Stream ended before command data was received", params.sessionId);
+			const { command } = CommandResponse.parse(commandChunk.value);
+			return {
+				command,
+				finished: (async () => {
+					const finishedChunk = await iterator.next();
+					if (finishedChunk.done) throw new StreamError("stream_ended_early", "Stream ended before command finished", params.sessionId);
+					const { command: command$1 } = CommandFinishedResponse.parse(finishedChunk.value);
+					return command$1;
+				})()
+			};
+		}
+		return parseOrThrow(CommandResponse, await this.request(`/v2/sandboxes/sessions/${params.sessionId}/cmd`, {
+			method: "POST",
+			body: JSON.stringify({
+				command: params.command,
+				args: params.args,
+				cwd: params.cwd,
+				env: params.env,
+				sudo: params.sudo
+			}),
+			signal: params.signal
+		}));
+	}
+	async getCommand(params) {
+		return params.wait ? parseOrThrow(CommandFinishedResponse, await this.request(`/v2/sandboxes/sessions/${params.sessionId}/cmd/${params.cmdId}`, {
+			signal: params.signal,
+			query: { wait: "true" }
+		})) : parseOrThrow(CommandResponse, await this.request(`/v2/sandboxes/sessions/${params.sessionId}/cmd/${params.cmdId}`, { signal: params.signal }));
+	}
+	async mkDir(params) {
+		return parseOrThrow(EmptyResponse, await this.request(`/v2/sandboxes/sessions/${params.sessionId}/fs/mkdir`, {
+			method: "POST",
+			body: JSON.stringify({
+				path: params.path,
+				cwd: params.cwd
+			}),
+			signal: params.signal
+		}));
+	}
+	getFileWriter(params) {
+		const writer = new FileWriter();
+		return {
+			response: (async () => {
+				return this.request(`/v2/sandboxes/sessions/${params.sessionId}/fs/write`, {
+					method: "POST",
+					headers: {
+						"content-type": "application/gzip",
+						"x-cwd": params.extractDir
+					},
+					body: await consumeReadable(writer.readable),
+					signal: params.signal
+				});
+			})(),
+			writer
+		};
+	}
+	async listSessions(params) {
+		return parseOrThrow(SessionsResponse, await this.request(`/v2/sandboxes/sessions`, {
+			query: {
+				project: params.projectId,
+				name: params.name,
+				limit: params.limit,
+				cursor: params.cursor,
+				sortOrder: params.sortOrder
+			},
+			method: "GET",
+			signal: params.signal
+		}));
+	}
+	async listSnapshots(params) {
+		return parseOrThrow(SnapshotsResponse, await this.request(`/v2/sandboxes/snapshots`, {
+			query: {
+				project: params.projectId,
+				name: params.name,
+				limit: params.limit,
+				cursor: params.cursor,
+				sortOrder: params.sortOrder
+			},
+			method: "GET",
+			signal: params.signal
+		}));
+	}
+	async writeFiles(params) {
+		const { writer, response } = this.getFileWriter({
+			sessionId: params.sessionId,
+			extractDir: params.extractDir,
+			signal: params.signal
+		});
+		for (const file of params.files) await writer.addFile({
+			name: normalizePath({
+				filePath: file.path,
+				extractDir: params.extractDir,
+				cwd: params.cwd
+			}),
+			content: file.content,
+			mode: file.mode
+		});
+		writer.end();
+		await parseOrThrow(EmptyResponse, await response);
+	}
+	async readFile(params) {
+		const response = await this.request(`/v2/sandboxes/sessions/${params.sessionId}/fs/read`, {
+			method: "POST",
+			body: JSON.stringify({
+				path: params.path,
+				cwd: params.cwd
+			}),
+			signal: params.signal
+		});
+		if (response.status === 404) return null;
+		if (!response.ok) await parseOrThrow(z.any(), response);
+		if (response.body === null) return null;
+		return Readable.fromWeb(response.body);
+	}
+	async killCommand(params) {
+		return parseOrThrow(CommandResponse, await this.request(`/v2/sandboxes/sessions/${params.sessionId}/cmd/${params.commandId}/kill`, {
+			method: "POST",
+			body: JSON.stringify({ signal: params.signal }),
+			signal: params.abortSignal
+		}));
+	}
+	getLogs(params) {
+		const self = this;
+		const disposer = new AbortController();
+		const signal = !params.signal ? disposer.signal : mergeSignals(params.signal, disposer.signal);
+		const generator = (async function* () {
+			const url = `/v2/sandboxes/sessions/${params.sessionId}/cmd/${params.cmdId}/logs`;
+			const response = await self.request(url, {
+				method: "GET",
+				signal
+			});
+			if (!response.ok) await parseOrThrow(z.any(), response);
+			if (response.headers.get("content-type") !== "application/x-ndjson") throw new APIError(response, {
+				message: "Expected a stream of logs",
+				sessionId: params.sessionId
+			});
+			if (response.body === null) throw new APIError(response, {
+				message: "No response body",
+				sessionId: params.sessionId
+			});
+			const jsonlinesStream = jsonlines.parse();
+			pipe(response.body, jsonlinesStream, { signal }).catch((err) => {
+				console.error("Error piping logs:", err);
+			});
+			for await (const chunk of jsonlinesStream) {
+				const parsed = LogLine.parse(chunk);
+				if (parsed.stream === "error") throw new StreamError(parsed.data.code, parsed.data.message, params.sessionId);
+				yield parsed;
+			}
+		})();
+		return Object.assign(generator, {
+			[Symbol.dispose]() {
+				disposer.abort("Disposed");
+			},
+			close: () => disposer.abort("Disposed")
+		});
+	}
+	async stopSession(params) {
+		const url = `/v2/sandboxes/sessions/${params.sessionId}/stop`;
+		return parseOrThrow(StopSessionResponse, await this.request(url, {
+			method: "POST",
+			signal: params.signal
+		}));
+	}
+	async updateNetworkPolicy(params) {
+		const url = `/v2/sandboxes/sessions/${params.sessionId}/network-policy`;
+		return parseOrThrow(SessionResponse, await this.request(url, {
+			method: "POST",
+			body: JSON.stringify(toAPINetworkPolicy(params.networkPolicy)),
+			signal: params.signal
+		}));
+	}
+	async extendTimeout(params) {
+		const url = `/v2/sandboxes/sessions/${params.sessionId}/extend-timeout`;
+		return parseOrThrow(SessionResponse, await this.request(url, {
+			method: "POST",
+			body: JSON.stringify({ duration: params.duration }),
+			signal: params.signal
+		}));
+	}
+	async createSnapshot(params) {
+		const url = `/v2/sandboxes/sessions/${params.sessionId}/snapshot`;
+		const body = params.expiration === void 0 ? void 0 : JSON.stringify({ expiration: params.expiration });
+		return parseOrThrow(CreateSnapshotResponse, await this.request(url, {
+			method: "POST",
+			body,
+			signal: params.signal
+		}));
+	}
+	async deleteSnapshot(params) {
+		const url = `/v2/sandboxes/snapshots/${params.snapshotId}`;
+		return parseOrThrow(SnapshotResponse, await this.request(url, {
+			method: "DELETE",
+			signal: params.signal
+		}));
+	}
+	async getSnapshot(params) {
+		const url = `/v2/sandboxes/snapshots/${params.snapshotId}`;
+		return parseOrThrow(SnapshotResponse, await this.request(url, { signal: params.signal }));
+	}
+	async getSandbox(params) {
+		const privateParams = getPrivateParams(params);
+		const query = {
+			projectId: params.projectId,
+			...privateParams
+		};
+		if (params.resume !== void 0) query.resume = String(params.resume);
+		return parseOrThrow(SandboxAndSessionResponse, await this.request(`/v2/sandboxes/${encodeURIComponent(params.name)}`, {
+			query,
+			signal: params.signal
+		}));
+	}
+	async listSandboxes(params) {
+		return parseOrThrow(SandboxesPaginationResponse, await this.request(`/v2/sandboxes`, {
+			query: {
+				project: params.projectId,
+				limit: params.limit,
+				sortBy: params.sortBy,
+				sortOrder: params.sortOrder,
+				namePrefix: params.namePrefix,
+				cursor: params.cursor,
+				tags: toTagsFilter(params.tags)
+			},
+			method: "GET",
+			signal: params.signal
+		}));
+	}
+	async updateSandbox(params) {
+		return parseOrThrow(UpdateSandboxResponse, await this.request(`/v2/sandboxes/${encodeURIComponent(params.name)}`, {
+			method: "PATCH",
+			query: { projectId: params.projectId },
+			body: JSON.stringify({
+				persistent: params.persistent,
+				resources: params.resources,
+				runtime: params.runtime,
+				timeout: params.timeout,
+				networkPolicy: params.networkPolicy ? toAPINetworkPolicy(params.networkPolicy) : void 0,
+				tags: params.tags,
+				ports: params.ports,
+				snapshotExpiration: params.snapshotExpiration,
+				currentSnapshotId: params.currentSnapshotId
+			}),
+			signal: params.signal
+		}));
+	}
+	async deleteSandbox(params) {
+		return parseOrThrow(UpdateSandboxResponse, await this.request(`/v2/sandboxes/${encodeURIComponent(params.name)}`, {
+			method: "DELETE",
+			query: { projectId: params.projectId },
+			signal: params.signal
+		}));
+	}
+};
+async function pipe(readable, output, options) {
+	const reader = readable.getReader();
+	let aborted = false;
+	const signal = options?.signal;
+	const onAbort = () => {
+		aborted = true;
+		const reason = signal?.reason ?? new DOMException("The operation was aborted.", "AbortError");
+		reader.cancel(reason).catch(() => {});
+		if ("destroy" in output && typeof output.destroy === "function") {
+			output.destroy(reason);
+			return;
+		}
+		output.emit("error", reason);
+		output.end();
+	};
+	if (signal) if (signal.aborted) onAbort();
+	else signal.addEventListener("abort", onAbort, { once: true });
+	try {
+		while (true) {
+			const read = await reader.read();
+			if (read.value) output.write(Buffer.from(read.value));
+			if (read.done) break;
+		}
+	} catch (err) {
+		if (!aborted) output.emit("error", err);
+	} finally {
+		signal?.removeEventListener("abort", onAbort);
+		if (!aborted) output.end();
+	}
 }
 function mergeSignals(...signals) {
-    const controller = new AbortController();
-    const onAbort = () => {
-        controller.abort();
-        for (const signal of signals) {
-            signal.removeEventListener("abort", onAbort);
-        }
-    };
-    for (const signal of signals) {
-        if (signal.aborted) {
-            controller.abort();
-            break;
-        }
-        signal.addEventListener("abort", onAbort);
-    }
-    return controller.signal;
+	const controller = new AbortController();
+	const onAbort = () => {
+		controller.abort();
+		for (const signal of signals) signal.removeEventListener("abort", onAbort);
+	};
+	for (const signal of signals) {
+		if (signal.aborted) {
+			controller.abort();
+			break;
+		}
+		signal.addEventListener("abort", onAbort);
+	}
+	return controller.signal;
+}
+function toTagsFilter(tags) {
+	if (tags === void 0) return void 0;
+	const entries = Object.entries(tags);
+	if (entries.length === 0) return void 0;
+	return entries.map(([key, value]) => `${key}:${value}`);
 }
+
+//#endregion
+export { APIClient };
 //# sourceMappingURL=api-client.js.map