@vercel/sandbox 1.9.0 → 1.9.2

package/dist/command.js

@@ -1,229 +1,326 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommandFinished = exports.Command = void 0;
-const resolveSignal_1 = require("./utils/resolveSignal");
+import { APIClient } from "./api-client/api-client.js";
+import "./api-client/index.js";
+import { getCredentials } from "./utils/get-credentials.js";
+import { resolveSignal } from "./utils/resolveSignal.js";
+import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from "@workflow/serde";
+
+//#region src/command.ts
 /**
- * A command executed in a Sandbox.
- *
- * For detached commands, you can {@link wait} to get a {@link CommandFinished} instance
- * with the populated exit code. For non-detached commands, {@link Sandbox.runCommand}
- * automatically waits and returns a {@link CommandFinished} instance.
- *
- * You can iterate over command output with {@link logs}.
- *
- * @see {@link Sandbox.runCommand} to start a command.
- *
- * @hideconstructor
- */
-class Command {
-    /**
-     * ID of the command execution.
-     */
-    get cmdId() {
-        return this.cmd.id;
-    }
-    get cwd() {
-        return this.cmd.cwd;
-    }
-    get startedAt() {
-        return this.cmd.startedAt;
-    }
-    /**
-     * @param params - Object containing the client, sandbox ID, and command ID.
-     * @param params.client - API client used to interact with the backend.
-     * @param params.sandboxId - The ID of the sandbox where the command is running.
-     * @param params.cmdId - The ID of the command execution.
-     */
-    constructor({ client, sandboxId, cmd, }) {
-        this.outputCache = null;
-        this.client = client;
-        this.sandboxId = sandboxId;
-        this.cmd = cmd;
-        this.exitCode = cmd.exitCode ?? null;
-    }
-    /**
-     * Iterate over the output of this command.
-     *
-     * ```
-     * for await (const log of cmd.logs()) {
-     *   if (log.stream === "stdout") {
-     *     process.stdout.write(log.data);
-     *   } else {
-     *     process.stderr.write(log.data);
-     *   }
-     * }
-     * ```
-     *
-     * @param opts - Optional parameters.
-     * @param opts.signal - An AbortSignal to cancel log streaming.
-     * @returns An async iterable of log entries from the command output.
-     *
-     * @see {@link Command.stdout}, {@link Command.stderr}, and {@link Command.output}
-     * to access output as a string.
-     */
-    logs(opts) {
-        return this.client.getLogs({
-            sandboxId: this.sandboxId,
-            cmdId: this.cmd.id,
-            signal: opts?.signal,
-        });
-    }
-    /**
-     * Wait for a command to exit and populate its exit code.
-     *
-     * This method is useful for detached commands where you need to wait
-     * for completion. For non-detached commands, {@link Sandbox.runCommand}
-     * automatically waits and returns a {@link CommandFinished} instance.
-     *
-     * ```
-     * const detachedCmd = await sandbox.runCommand({ cmd: 'sleep', args: ['5'], detached: true });
-     * const result = await detachedCmd.wait();
-     * if (result.exitCode !== 0) {
-     *   console.error("Something went wrong...")
-     * }
-     * ```
-     *
-     * @param params - Optional parameters.
-     * @param params.signal - An AbortSignal to cancel waiting.
-     * @returns A {@link CommandFinished} instance with populated exit code.
-     */
-    async wait(params) {
-        params?.signal?.throwIfAborted();
-        const command = await this.client.getCommand({
-            sandboxId: this.sandboxId,
-            cmdId: this.cmd.id,
-            wait: true,
-            signal: params?.signal,
-        });
-        return new CommandFinished({
-            client: this.client,
-            sandboxId: this.sandboxId,
-            cmd: command.json.command,
-            exitCode: command.json.command.exitCode,
-        });
-    }
-    /**
-     * Get cached output, fetching logs only once and reusing for concurrent calls.
-     * This prevents race conditions when stdout() and stderr() are called in parallel.
-     */
-    async getCachedOutput(opts) {
-        if (!this.outputCache) {
-            this.outputCache = (async () => {
-                try {
-                    let stdout = "";
-                    let stderr = "";
-                    let both = "";
-                    for await (const log of this.logs({ signal: opts?.signal })) {
-                        both += log.data;
-                        if (log.stream === "stdout") {
-                            stdout += log.data;
-                        }
-                        else {
-                            stderr += log.data;
-                        }
-                    }
-                    return { stdout, stderr, both };
-                }
-                catch (err) {
-                    // Clear the promise so future calls can retry
-                    this.outputCache = null;
-                    throw err;
-                }
-            })();
-        }
-        return this.outputCache;
-    }
-    /**
-     * Get the output of `stdout`, `stderr`, or both as a string.
-     *
-     * NOTE: This may throw string conversion errors if the command does
-     * not output valid Unicode.
-     *
-     * @param stream - The output stream to read: "stdout", "stderr", or "both".
-     * @param opts - Optional parameters.
-     * @param opts.signal - An AbortSignal to cancel output streaming.
-     * @returns The output of the specified stream(s) as a string.
-     */
-    async output(stream = "both", opts) {
-        const cached = await this.getCachedOutput(opts);
-        return cached[stream];
-    }
-    /**
-     * Get the output of `stdout` as a string.
-     *
-     * NOTE: This may throw string conversion errors if the command does
-     * not output valid Unicode.
-     *
-     * @param opts - Optional parameters.
-     * @param opts.signal - An AbortSignal to cancel output streaming.
-     * @returns The standard output of the command.
-     */
-    async stdout(opts) {
-        return this.output("stdout", opts);
-    }
-    /**
-     * Get the output of `stderr` as a string.
-     *
-     * NOTE: This may throw string conversion errors if the command does
-     * not output valid Unicode.
-     *
-     * @param opts - Optional parameters.
-     * @param opts.signal - An AbortSignal to cancel output streaming.
-     * @returns The standard error output of the command.
-     */
-    async stderr(opts) {
-        return this.output("stderr", opts);
-    }
-    /**
-     * Kill a running command in a sandbox.
-     *
-     * @param signal - The signal to send the running process. Defaults to SIGTERM.
-     * @param opts - Optional parameters.
-     * @param opts.abortSignal - An AbortSignal to cancel the kill operation.
-     * @returns Promise<void>.
-     */
-    async kill(signal, opts) {
-        await this.client.killCommand({
-            sandboxId: this.sandboxId,
-            commandId: this.cmd.id,
-            signal: (0, resolveSignal_1.resolveSignal)(signal ?? "SIGTERM"),
-            abortSignal: opts?.abortSignal,
-        });
-    }
-}
-exports.Command = Command;
+* A command executed in a Sandbox.
+*
+* For detached commands, you can {@link wait} to get a {@link CommandFinished} instance
+* with the populated exit code. For non-detached commands, {@link Sandbox.runCommand}
+* automatically waits and returns a {@link CommandFinished} instance.
+*
+* You can iterate over command output with {@link logs}.
+*
+* @see {@link Sandbox.runCommand} to start a command.
+*
+* @hideconstructor
+*/
+var Command = class Command {
+	/**
+	* Lazily resolve credentials and construct an API client.
+	* @internal
+	*/
+	async ensureClient() {
+		"use step";
+		if (this._client) return this._client;
+		const credentials = await getCredentials();
+		this._client = new APIClient({
+			teamId: credentials.teamId,
+			token: credentials.token
+		});
+		return this._client;
+	}
+	/**
+	* ID of the command execution.
+	*/
+	get cmdId() {
+		return this.cmd.id;
+	}
+	get cwd() {
+		return this.cmd.cwd;
+	}
+	get startedAt() {
+		return this.cmd.startedAt;
+	}
+	/**
+	* @param params - Object containing the client, sandbox ID, and command data.
+	* @param params.client - Optional API client. If not provided, will be lazily created using global credentials.
+	* @param params.sandboxId - The ID of the sandbox where the command is running.
+	* @param params.cmd - The command data.
+	* @param params.output - Optional cached output to restore (used during deserialization).
+	*/
+	constructor({ client, sandboxId, cmd, output }) {
+		this._client = null;
+		this.outputCache = null;
+		this._resolvedOutput = null;
+		this._client = client ?? null;
+		this.sandboxId = sandboxId;
+		this.cmd = cmd;
+		this.exitCode = cmd.exitCode ?? null;
+		if (output) {
+			this._resolvedOutput = output;
+			this.outputCache = Promise.resolve({
+				stdout: output.stdout,
+				stderr: output.stderr,
+				both: output.stdout + output.stderr
+			});
+		}
+	}
+	/**
+	* Serialize a Command instance to plain data for @workflow/serde.
+	*
+	* @param instance - The Command instance to serialize
+	* @returns A plain object containing the sandbox ID, command data, and output if fetched
+	*/
+	static [WORKFLOW_SERIALIZE](instance) {
+		const serialized = {
+			sandboxId: instance.sandboxId,
+			cmd: instance.cmd
+		};
+		if (instance._resolvedOutput) serialized.output = instance._resolvedOutput;
+		return serialized;
+	}
+	/**
+	* Deserialize plain data back into a Command instance for @workflow/serde.
+	*
+	* The deserialized instance will lazily create an API client using
+	* OIDC or environment credentials when needed.
+	*
+	* @param data - The serialized command data
+	* @returns The reconstructed Command instance
+	*/
+	static [WORKFLOW_DESERIALIZE](data) {
+		return new Command({
+			sandboxId: data.sandboxId,
+			cmd: data.cmd,
+			output: data.output
+		});
+	}
+	/**
+	* Iterate over the output of this command.
+	*
+	* ```
+	* for await (const log of cmd.logs()) {
+	*   if (log.stream === "stdout") {
+	*     process.stdout.write(log.data);
+	*   } else {
+	*     process.stderr.write(log.data);
+	*   }
+	* }
+	* ```
+	*
+	* @param opts - Optional parameters.
+	* @param opts.signal - An AbortSignal to cancel log streaming.
+	* @returns An async iterable of log entries from the command output.
+	*
+	* @see {@link Command.stdout}, {@link Command.stderr}, and {@link Command.output}
+	* to access output as a string.
+	*/
+	logs(opts) {
+		if (!this._client) throw new Error("logs() requires an API client. Call an async method first to initialize the client.");
+		return this._client.getLogs({
+			sandboxId: this.sandboxId,
+			cmdId: this.cmd.id,
+			signal: opts?.signal
+		});
+	}
+	/**
+	* Wait for a command to exit and populate its exit code.
+	*
+	* This method is useful for detached commands where you need to wait
+	* for completion. For non-detached commands, {@link Sandbox.runCommand}
+	* automatically waits and returns a {@link CommandFinished} instance.
+	*
+	* ```
+	* const detachedCmd = await sandbox.runCommand({ cmd: 'sleep', args: ['5'], detached: true });
+	* const result = await detachedCmd.wait();
+	* if (result.exitCode !== 0) {
+	*   console.error("Something went wrong...")
+	* }
+	* ```
+	*
+	* @param params - Optional parameters.
+	* @param params.signal - An AbortSignal to cancel waiting.
+	* @returns A {@link CommandFinished} instance with populated exit code.
+	*/
+	async wait(params) {
+		"use step";
+		const client = await this.ensureClient();
+		params?.signal?.throwIfAborted();
+		const command = await client.getCommand({
+			sandboxId: this.sandboxId,
+			cmdId: this.cmd.id,
+			wait: true,
+			signal: params?.signal
+		});
+		return new CommandFinished({
+			client,
+			sandboxId: this.sandboxId,
+			cmd: command.json.command,
+			exitCode: command.json.command.exitCode
+		});
+	}
+	/**
+	* Get cached output, fetching logs only once and reusing for concurrent calls.
+	* This prevents race conditions when stdout() and stderr() are called in parallel.
+	*/
+	async getCachedOutput(opts) {
+		if (!this.outputCache) this.outputCache = (async () => {
+			try {
+				opts?.signal?.throwIfAborted();
+				await this.ensureClient();
+				let stdout = "";
+				let stderr = "";
+				let both = "";
+				for await (const log of this.logs({ signal: opts?.signal })) {
+					both += log.data;
+					if (log.stream === "stdout") stdout += log.data;
+					else stderr += log.data;
+				}
+				this._resolvedOutput = {
+					stdout,
+					stderr
+				};
+				return {
+					stdout,
+					stderr,
+					both
+				};
+			} catch (err) {
+				this.outputCache = null;
+				throw err;
+			}
+		})();
+		return this.outputCache;
+	}
+	/**
+	* Get the output of `stdout`, `stderr`, or both as a string.
+	*
+	* NOTE: This may throw string conversion errors if the command does
+	* not output valid Unicode.
+	*
+	* @param stream - The output stream to read: "stdout", "stderr", or "both".
+	* @param opts - Optional parameters.
+	* @param opts.signal - An AbortSignal to cancel output streaming.
+	* @returns The output of the specified stream(s) as a string.
+	*/
+	async output(stream = "both", opts) {
+		"use step";
+		return (await this.getCachedOutput(opts))[stream];
+	}
+	/**
+	* Get the output of `stdout` as a string.
+	*
+	* NOTE: This may throw string conversion errors if the command does
+	* not output valid Unicode.
+	*
+	* @param opts - Optional parameters.
+	* @param opts.signal - An AbortSignal to cancel output streaming.
+	* @returns The standard output of the command.
+	*/
+	async stdout(opts) {
+		"use step";
+		return this.output("stdout", opts);
+	}
+	/**
+	* Get the output of `stderr` as a string.
+	*
+	* NOTE: This may throw string conversion errors if the command does
+	* not output valid Unicode.
+	*
+	* @param opts - Optional parameters.
+	* @param opts.signal - An AbortSignal to cancel output streaming.
+	* @returns The standard error output of the command.
+	*/
+	async stderr(opts) {
+		"use step";
+		return this.output("stderr", opts);
+	}
+	/**
+	* Kill a running command in a sandbox.
+	*
+	* @param signal - The signal to send the running process. Defaults to SIGTERM.
+	* @param opts - Optional parameters.
+	* @param opts.abortSignal - An AbortSignal to cancel the kill operation.
+	* @returns Promise<void>.
+	*/
+	async kill(signal, opts) {
+		"use step";
+		await (await this.ensureClient()).killCommand({
+			sandboxId: this.sandboxId,
+			commandId: this.cmd.id,
+			signal: resolveSignal(signal ?? "SIGTERM"),
+			abortSignal: opts?.abortSignal
+		});
+	}
+};
 /**
- * A command that has finished executing.
- *
- * The exit code is immediately available and populated upon creation.
- * Unlike {@link Command}, you don't need to call wait() - the command
- * has already completed execution.
- *
- * @hideconstructor
- */
-class CommandFinished extends Command {
-    /**
-     * @param params - Object containing client, sandbox ID, command ID, and exit code.
-     * @param params.client - API client used to interact with the backend.
-     * @param params.sandboxId - The ID of the sandbox where the command ran.
-     * @param params.cmdId - The ID of the command execution.
-     * @param params.exitCode - The exit code of the completed command.
-     */
-    constructor(params) {
-        super({ ...params });
-        this.exitCode = params.exitCode;
-    }
-    /**
-     * The wait method is not needed for CommandFinished instances since
-     * the command has already completed and exitCode is populated.
-     *
-     * @deprecated This method is redundant for CommandFinished instances.
-     * The exitCode is already available.
-     * @returns This CommandFinished instance.
-     */
-    async wait() {
-        return this;
-    }
-}
-exports.CommandFinished = CommandFinished;
+* A command that has finished executing.
+*
+* The exit code is immediately available and populated upon creation.
+* Unlike {@link Command}, you don't need to call wait() - the command
+* has already completed execution.
+*
+* @hideconstructor
+*/
+var CommandFinished = class CommandFinished extends Command {
+	/**
+	* @param params - Object containing client, sandbox ID, command data, and exit code.
+	* @param params.client - Optional API client. If not provided, will be lazily created using global credentials.
+	* @param params.sandboxId - The ID of the sandbox where the command ran.
+	* @param params.cmd - The command data.
+	* @param params.exitCode - The exit code of the completed command.
+	* @param params.output - Optional cached output to restore (used during deserialization).
+	*/
+	constructor(params) {
+		super({ ...params });
+		this.exitCode = params.exitCode;
+	}
+	/**
+	* Serialize a CommandFinished instance to plain data for @workflow/serde.
+	*
+	* @param instance - The CommandFinished instance to serialize
+	* @returns A plain object containing the sandbox ID, command data, exit code, and output if fetched
+	*/
+	static [WORKFLOW_SERIALIZE](instance) {
+		return {
+			...Command[WORKFLOW_SERIALIZE](instance),
+			exitCode: instance.exitCode
+		};
+	}
+	/**
+	* Deserialize plain data back into a CommandFinished instance for @workflow/serde.
+	*
+	* The deserialized instance will lazily create an API client using
+	* OIDC or environment credentials when needed.
+	*
+	* @param data - The serialized command finished data
+	* @returns The reconstructed CommandFinished instance
+	*/
+	static [WORKFLOW_DESERIALIZE](data) {
+		return new CommandFinished({
+			sandboxId: data.sandboxId,
+			cmd: data.cmd,
+			exitCode: data.exitCode,
+			output: data.output
+		});
+	}
+	/**
+	* The wait method is not needed for CommandFinished instances since
+	* the command has already completed and exitCode is populated.
+	*
+	* @deprecated This method is redundant for CommandFinished instances.
+	* The exitCode is already available.
+	* @returns This CommandFinished instance.
+	*/
+	async wait() {
+		return this;
+	}
+};
+
+//#endregion
+export { Command, CommandFinished };
 //# sourceMappingURL=command.js.map

package/dist/command.js.map

@@ -1 +1 @@
-{"version":3,"file":"command.js","sourceRoot":"","sources":["../src/command.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"command.js","names":["serialized: SerializedCommand"],"sources":["../src/command.ts"],"sourcesContent":["import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from \"@workflow/serde\";\nimport { APIClient, type CommandData } from \"./api-client/index.js\";\nimport { getCredentials } from \"./utils/get-credentials.js\";\nimport { resolveSignal, type Signal } from \"./utils/resolveSignal.js\";\n\n/**\n * Cached output from a command execution.\n */\nexport interface CommandOutput {\n  stdout: string;\n  stderr: string;\n}\n\n/**\n * Serialized representation of a Command for @workflow/serde.\n */\nexport interface SerializedCommand {\n  sandboxId: string;\n  cmd: CommandData;\n  /** Cached output, included if output was fetched before serialization */\n  output?: CommandOutput;\n}\n\n/**\n * Serialized representation of a CommandFinished for @workflow/serde.\n */\nexport interface SerializedCommandFinished extends SerializedCommand {\n  exitCode: number;\n}\n\n/**\n * A command executed in a Sandbox.\n *\n * For detached commands, you can {@link wait} to get a {@link CommandFinished} instance\n * with the populated exit code. For non-detached commands, {@link Sandbox.runCommand}\n * automatically waits and returns a {@link CommandFinished} instance.\n *\n * You can iterate over command output with {@link logs}.\n *\n * @see {@link Sandbox.runCommand} to start a command.\n *\n * @hideconstructor\n */\nexport class Command {\n  /**\n   * Cached API client instance.\n   * @internal\n   */\n  protected _client: APIClient | null = null;\n\n  /**\n   * Lazily resolve credentials and construct an API client.\n   * @internal\n   */\n  protected async ensureClient(): Promise<APIClient> {\n    \"use step\";\n    if (this._client) return this._client;\n    const credentials = await getCredentials();\n    this._client = new APIClient({\n      teamId: credentials.teamId,\n      token: credentials.token,\n    });\n    return this._client;\n  }\n\n  /**\n   * ID of the sandbox this command is running in.\n   */\n  protected sandboxId: string;\n\n  /**\n   * Data for the command execution.\n   */\n  protected cmd: CommandData;\n\n  public exitCode: number | null;\n\n  protected outputCache: Promise<{\n    stdout: string;\n    stderr: string;\n    both: string;\n  }> | null = null;\n\n  /**\n   * Synchronously accessible resolved output, populated after output is fetched.\n   * Used for serialization.\n   * @internal\n   */\n  protected _resolvedOutput: CommandOutput | null = null;\n\n  /**\n   * ID of the command execution.\n   */\n  get cmdId() {\n    return this.cmd.id;\n  }\n\n  get cwd() {\n    return this.cmd.cwd;\n  }\n\n  get startedAt() {\n    return this.cmd.startedAt;\n  }\n\n  /**\n   * @param params - Object containing the client, sandbox ID, and command data.\n   * @param params.client - Optional API client. If not provided, will be lazily created using global credentials.\n   * @param params.sandboxId - The ID of the sandbox where the command is running.\n   * @param params.cmd - The command data.\n   * @param params.output - Optional cached output to restore (used during deserialization).\n   */\n  constructor({\n    client,\n    sandboxId,\n    cmd,\n    output,\n  }: {\n    client?: APIClient;\n    sandboxId: string;\n    cmd: CommandData;\n    output?: CommandOutput;\n  }) {\n    this._client = client ?? null;\n    this.sandboxId = sandboxId;\n    this.cmd = cmd;\n    this.exitCode = cmd.exitCode ?? null;\n    if (output) {\n      this._resolvedOutput = output;\n      // Note: `both` is reconstructed as stdout + stderr concatenation,\n      // which loses the original interleaved order of the streams.\n      this.outputCache = Promise.resolve({\n        stdout: output.stdout,\n        stderr: output.stderr,\n        both: output.stdout + output.stderr,\n      });\n    }\n  }\n\n  /**\n   * Serialize a Command instance to plain data for @workflow/serde.\n   *\n   * @param instance - The Command instance to serialize\n   * @returns A plain object containing the sandbox ID, command data, and output if fetched\n   */\n  static [WORKFLOW_SERIALIZE](instance: Command): SerializedCommand {\n    const serialized: SerializedCommand = {\n      sandboxId: instance.sandboxId,\n      cmd: instance.cmd,\n    };\n    if (instance._resolvedOutput) {\n      serialized.output = instance._resolvedOutput;\n    }\n    return serialized;\n  }\n\n  /**\n   * Deserialize plain data back into a Command instance for @workflow/serde.\n   *\n   * The deserialized instance will lazily create an API client using\n   * OIDC or environment credentials when needed.\n   *\n   * @param data - The serialized command data\n   * @returns The reconstructed Command instance\n   */\n  static [WORKFLOW_DESERIALIZE](data: SerializedCommand): Command {\n    return new Command({\n      sandboxId: data.sandboxId,\n      cmd: data.cmd,\n      output: data.output,\n    });\n  }\n\n  /**\n   * Iterate over the output of this command.\n   *\n   * ```\n   * for await (const log of cmd.logs()) {\n   *   if (log.stream === \"stdout\") {\n   *     process.stdout.write(log.data);\n   *   } else {\n   *     process.stderr.write(log.data);\n   *   }\n   * }\n   * ```\n   *\n   * @param opts - Optional parameters.\n   * @param opts.signal - An AbortSignal to cancel log streaming.\n   * @returns An async iterable of log entries from the command output.\n   *\n   * @see {@link Command.stdout}, {@link Command.stderr}, and {@link Command.output}\n   * to access output as a string.\n   */\n  logs(opts?: { signal?: AbortSignal }) {\n    if (!this._client) {\n      throw new Error(\n        \"logs() requires an API client. Call an async method first to initialize the client.\",\n      );\n    }\n    return this._client.getLogs({\n      sandboxId: this.sandboxId,\n      cmdId: this.cmd.id,\n      signal: opts?.signal,\n    });\n  }\n\n  /**\n   * Wait for a command to exit and populate its exit code.\n   *\n   * This method is useful for detached commands where you need to wait\n   * for completion. For non-detached commands, {@link Sandbox.runCommand}\n   * automatically waits and returns a {@link CommandFinished} instance.\n   *\n   * ```\n   * const detachedCmd = await sandbox.runCommand({ cmd: 'sleep', args: ['5'], detached: true });\n   * const result = await detachedCmd.wait();\n   * if (result.exitCode !== 0) {\n   *   console.error(\"Something went wrong...\")\n   * }\n   * ```\n   *\n   * @param params - Optional parameters.\n   * @param params.signal - An AbortSignal to cancel waiting.\n   * @returns A {@link CommandFinished} instance with populated exit code.\n   */\n  async wait(params?: { signal?: AbortSignal }) {\n    \"use step\";\n    const client = await this.ensureClient();\n    params?.signal?.throwIfAborted();\n\n    const command = await client.getCommand({\n      sandboxId: this.sandboxId,\n      cmdId: this.cmd.id,\n      wait: true,\n      signal: params?.signal,\n    });\n\n    return new CommandFinished({\n      client,\n      sandboxId: this.sandboxId,\n      cmd: command.json.command,\n      exitCode: command.json.command.exitCode,\n    });\n  }\n\n  /**\n   * Get cached output, fetching logs only once and reusing for concurrent calls.\n   * This prevents race conditions when stdout() and stderr() are called in parallel.\n   */\n  protected async getCachedOutput(opts?: { signal?: AbortSignal }): Promise<{\n    stdout: string;\n    stderr: string;\n    both: string;\n  }> {\n    if (!this.outputCache) {\n      this.outputCache = (async () => {\n        try {\n          opts?.signal?.throwIfAborted();\n          // Ensure the API client is initialized before calling logs(),\n          // since logs() is synchronous and requires _client to be set.\n          await this.ensureClient();\n          let stdout = \"\";\n          let stderr = \"\";\n          let both = \"\";\n          for await (const log of this.logs({ signal: opts?.signal })) {\n            both += log.data;\n            if (log.stream === \"stdout\") {\n              stdout += log.data;\n            } else {\n              stderr += log.data;\n            }\n          }\n          // Store resolved output for serialization\n          this._resolvedOutput = { stdout, stderr };\n          return { stdout, stderr, both };\n        } catch (err) {\n          // Clear the promise so future calls can retry\n          this.outputCache = null;\n          throw err;\n        }\n      })();\n    }\n\n    return this.outputCache;\n  }\n\n  /**\n   * Get the output of `stdout`, `stderr`, or both as a string.\n   *\n   * NOTE: This may throw string conversion errors if the command does\n   * not output valid Unicode.\n   *\n   * @param stream - The output stream to read: \"stdout\", \"stderr\", or \"both\".\n   * @param opts - Optional parameters.\n   * @param opts.signal - An AbortSignal to cancel output streaming.\n   * @returns The output of the specified stream(s) as a string.\n   */\n  async output(\n    stream: \"stdout\" | \"stderr\" | \"both\" = \"both\",\n    opts?: { signal?: AbortSignal },\n  ) {\n    \"use step\";\n    const cached = await this.getCachedOutput(opts);\n    return cached[stream];\n  }\n\n  /**\n   * Get the output of `stdout` as a string.\n   *\n   * NOTE: This may throw string conversion errors if the command does\n   * not output valid Unicode.\n   *\n   * @param opts - Optional parameters.\n   * @param opts.signal - An AbortSignal to cancel output streaming.\n   * @returns The standard output of the command.\n   */\n  async stdout(opts?: { signal?: AbortSignal }) {\n    \"use step\";\n    return this.output(\"stdout\", opts);\n  }\n\n  /**\n   * Get the output of `stderr` as a string.\n   *\n   * NOTE: This may throw string conversion errors if the command does\n   * not output valid Unicode.\n   *\n   * @param opts - Optional parameters.\n   * @param opts.signal - An AbortSignal to cancel output streaming.\n   * @returns The standard error output of the command.\n   */\n  async stderr(opts?: { signal?: AbortSignal }) {\n    \"use step\";\n    return this.output(\"stderr\", opts);\n  }\n\n  /**\n   * Kill a running command in a sandbox.\n   *\n   * @param signal - The signal to send the running process. Defaults to SIGTERM.\n   * @param opts - Optional parameters.\n   * @param opts.abortSignal - An AbortSignal to cancel the kill operation.\n   * @returns Promise<void>.\n   */\n  async kill(signal?: Signal, opts?: { abortSignal?: AbortSignal }) {\n    \"use step\";\n    const client = await this.ensureClient();\n    await client.killCommand({\n      sandboxId: this.sandboxId,\n      commandId: this.cmd.id,\n      signal: resolveSignal(signal ?? \"SIGTERM\"),\n      abortSignal: opts?.abortSignal,\n    });\n  }\n}\n\n/**\n * A command that has finished executing.\n *\n * The exit code is immediately available and populated upon creation.\n * Unlike {@link Command}, you don't need to call wait() - the command\n * has already completed execution.\n *\n * @hideconstructor\n */\nexport class CommandFinished extends Command {\n  /**\n   * The exit code of the command. This is always populated for\n   * CommandFinished instances.\n   */\n  public exitCode: number;\n\n  /**\n   * @param params - Object containing client, sandbox ID, command data, and exit code.\n   * @param params.client - Optional API client. If not provided, will be lazily created using global credentials.\n   * @param params.sandboxId - The ID of the sandbox where the command ran.\n   * @param params.cmd - The command data.\n   * @param params.exitCode - The exit code of the completed command.\n   * @param params.output - Optional cached output to restore (used during deserialization).\n   */\n  constructor(params: {\n    client?: APIClient;\n    sandboxId: string;\n    cmd: CommandData;\n    exitCode: number;\n    output?: CommandOutput;\n  }) {\n    super({ ...params });\n    this.exitCode = params.exitCode;\n  }\n\n  /**\n   * Serialize a CommandFinished instance to plain data for @workflow/serde.\n   *\n   * @param instance - The CommandFinished instance to serialize\n   * @returns A plain object containing the sandbox ID, command data, exit code, and output if fetched\n   */\n  static [WORKFLOW_SERIALIZE](\n    instance: CommandFinished,\n  ): SerializedCommandFinished {\n    return {\n      ...Command[WORKFLOW_SERIALIZE](instance),\n      exitCode: instance.exitCode,\n    };\n  }\n\n  /**\n   * Deserialize plain data back into a CommandFinished instance for @workflow/serde.\n   *\n   * The deserialized instance will lazily create an API client using\n   * OIDC or environment credentials when needed.\n   *\n   * @param data - The serialized command finished data\n   * @returns The reconstructed CommandFinished instance\n   */\n  static [WORKFLOW_DESERIALIZE](\n    data: SerializedCommandFinished,\n  ): CommandFinished {\n    return new CommandFinished({\n      sandboxId: data.sandboxId,\n      cmd: data.cmd,\n      exitCode: data.exitCode,\n      output: data.output,\n    });\n  }\n\n  /**\n   * The wait method is not needed for CommandFinished instances since\n   * the command has already completed and exitCode is populated.\n   *\n   * @deprecated This method is redundant for CommandFinished instances.\n   * The exitCode is already available.\n   * @returns This CommandFinished instance.\n   */\n  async wait(): Promise<CommandFinished> {\n    return this;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA2CA,IAAa,UAAb,MAAa,QAAQ;;;;;CAWnB,MAAgB,eAAmC;AACjD;AACA,MAAI,KAAK,QAAS,QAAO,KAAK;EAC9B,MAAM,cAAc,MAAM,gBAAgB;AAC1C,OAAK,UAAU,IAAI,UAAU;GAC3B,QAAQ,YAAY;GACpB,OAAO,YAAY;GACpB,CAAC;AACF,SAAO,KAAK;;;;;CA+Bd,IAAI,QAAQ;AACV,SAAO,KAAK,IAAI;;CAGlB,IAAI,MAAM;AACR,SAAO,KAAK,IAAI;;CAGlB,IAAI,YAAY;AACd,SAAO,KAAK,IAAI;;;;;;;;;CAUlB,YAAY,EACV,QACA,WACA,KACA,UAMC;OA1EO,UAA4B;OA6B5B,cAIE;OAOF,kBAAwC;AAmChD,OAAK,UAAU,UAAU;AACzB,OAAK,YAAY;AACjB,OAAK,MAAM;AACX,OAAK,WAAW,IAAI,YAAY;AAChC,MAAI,QAAQ;AACV,QAAK,kBAAkB;AAGvB,QAAK,cAAc,QAAQ,QAAQ;IACjC,QAAQ,OAAO;IACf,QAAQ,OAAO;IACf,MAAM,OAAO,SAAS,OAAO;IAC9B,CAAC;;;;;;;;;CAUN,QAAQ,oBAAoB,UAAsC;EAChE,MAAMA,aAAgC;GACpC,WAAW,SAAS;GACpB,KAAK,SAAS;GACf;AACD,MAAI,SAAS,gBACX,YAAW,SAAS,SAAS;AAE/B,SAAO;;;;;;;;;;;CAYT,QAAQ,sBAAsB,MAAkC;AAC9D,SAAO,IAAI,QAAQ;GACjB,WAAW,KAAK;GAChB,KAAK,KAAK;GACV,QAAQ,KAAK;GACd,CAAC;;;;;;;;;;;;;;;;;;;;;;CAuBJ,KAAK,MAAiC;AACpC,MAAI,CAAC,KAAK,QACR,OAAM,IAAI,MACR,sFACD;AAEH,SAAO,KAAK,QAAQ,QAAQ;GAC1B,WAAW,KAAK;GAChB,OAAO,KAAK,IAAI;GAChB,QAAQ,MAAM;GACf,CAAC;;;;;;;;;;;;;;;;;;;;;CAsBJ,MAAM,KAAK,QAAmC;AAC5C;EACA,MAAM,SAAS,MAAM,KAAK,cAAc;AACxC,UAAQ,QAAQ,gBAAgB;EAEhC,MAAM,UAAU,MAAM,OAAO,WAAW;GACtC,WAAW,KAAK;GAChB,OAAO,KAAK,IAAI;GAChB,MAAM;GACN,QAAQ,QAAQ;GACjB,CAAC;AAEF,SAAO,IAAI,gBAAgB;GACzB;GACA,WAAW,KAAK;GAChB,KAAK,QAAQ,KAAK;GAClB,UAAU,QAAQ,KAAK,QAAQ;GAChC,CAAC;;;;;;CAOJ,MAAgB,gBAAgB,MAI7B;AACD,MAAI,CAAC,KAAK,YACR,MAAK,eAAe,YAAY;AAC9B,OAAI;AACF,UAAM,QAAQ,gBAAgB;AAG9B,UAAM,KAAK,cAAc;IACzB,IAAI,SAAS;IACb,IAAI,SAAS;IACb,IAAI,OAAO;AACX,eAAW,MAAM,OAAO,KAAK,KAAK,EAAE,QAAQ,MAAM,QAAQ,CAAC,EAAE;AAC3D,aAAQ,IAAI;AACZ,SAAI,IAAI,WAAW,SACjB,WAAU,IAAI;SAEd,WAAU,IAAI;;AAIlB,SAAK,kBAAkB;KAAE;KAAQ;KAAQ;AACzC,WAAO;KAAE;KAAQ;KAAQ;KAAM;YACxB,KAAK;AAEZ,SAAK,cAAc;AACnB,UAAM;;MAEN;AAGN,SAAO,KAAK;;;;;;;;;;;;;CAcd,MAAM,OACJ,SAAuC,QACvC,MACA;AACA;AAEA,UADe,MAAM,KAAK,gBAAgB,KAAK,EACjC;;;;;;;;;;;;CAahB,MAAM,OAAO,MAAiC;AAC5C;AACA,SAAO,KAAK,OAAO,UAAU,KAAK;;;;;;;;;;;;CAapC,MAAM,OAAO,MAAiC;AAC5C;AACA,SAAO,KAAK,OAAO,UAAU,KAAK;;;;;;;;;;CAWpC,MAAM,KAAK,QAAiB,MAAsC;AAChE;AAEA,SADe,MAAM,KAAK,cAAc,EAC3B,YAAY;GACvB,WAAW,KAAK;GAChB,WAAW,KAAK,IAAI;GACpB,QAAQ,cAAc,UAAU,UAAU;GAC1C,aAAa,MAAM;GACpB,CAAC;;;;;;;;;;;;AAaN,IAAa,kBAAb,MAAa,wBAAwB,QAAQ;;;;;;;;;CAe3C,YAAY,QAMT;AACD,QAAM,EAAE,GAAG,QAAQ,CAAC;AACpB,OAAK,WAAW,OAAO;;;;;;;;CASzB,QAAQ,oBACN,UAC2B;AAC3B,SAAO;GACL,GAAG,QAAQ,oBAAoB,SAAS;GACxC,UAAU,SAAS;GACpB;;;;;;;;;;;CAYH,QAAQ,sBACN,MACiB;AACjB,SAAO,IAAI,gBAAgB;GACzB,WAAW,KAAK;GAChB,KAAK,KAAK;GACV,UAAU,KAAK;GACf,QAAQ,KAAK;GACd,CAAC;;;;;;;;;;CAWJ,MAAM,OAAiC;AACrC,SAAO"}

package/dist/constants.d.cts

@@ -0,0 +1,5 @@
+//#region src/constants.d.ts
+type RUNTIMES = "node24" | "node22" | "python3.13";
+//#endregion
+export { RUNTIMES };
+//# sourceMappingURL=constants.d.cts.map

package/dist/constants.d.ts

@@ -1 +1,5 @@
-export type RUNTIMES = "node24" | "node22" | "python3.13";
+//#region src/constants.d.ts
+type RUNTIMES = "node24" | "node22" | "python3.13";
+//#endregion
+export { RUNTIMES };
+//# sourceMappingURL=constants.d.ts.map

package/dist/index.cjs

@@ -0,0 +1,11 @@
+const require_api_error = require('./api-client/api-error.cjs');
+const require_command = require('./command.cjs');
+const require_snapshot = require('./snapshot.cjs');
+const require_sandbox = require('./sandbox.cjs');
+
+exports.APIError = require_api_error.APIError;
+exports.Command = require_command.Command;
+exports.CommandFinished = require_command.CommandFinished;
+exports.Sandbox = require_sandbox.Sandbox;
+exports.Snapshot = require_snapshot.Snapshot;
+exports.StreamError = require_api_error.StreamError;

package/dist/index.d.cts

@@ -0,0 +1,6 @@
+import { APIError, StreamError } from "./api-client/api-error.cjs";
+import { NetworkPolicy, NetworkPolicyRule, NetworkTransformer } from "./network-policy.cjs";
+import { Command, CommandFinished, CommandOutput, SerializedCommand, SerializedCommandFinished } from "./command.cjs";
+import { Snapshot } from "./snapshot.cjs";
+import { Sandbox, SerializedSandbox } from "./sandbox.cjs";
+export { APIError, Command, CommandFinished, type CommandOutput, type NetworkPolicy, type NetworkPolicyRule, type NetworkTransformer, Sandbox, type SerializedCommand, type SerializedCommandFinished, type SerializedSandbox, Snapshot, StreamError };