withruntime 0.3.1 → 0.5.0

package/dist/daytona/image.js

@@ -0,0 +1,140 @@
+import { createHash } from "node:crypto";
+import { NotSupportedError } from "./errors.js";
+const PYTHON = ["3.9", "3.10", "3.11", "3.12", "3.13"];
+/** Daytona's declarative image, kept as the Dockerfile it stands for and
+ * built as a Runtime image (`runtime.images.build`) when a sandbox or a
+ * snapshot is created from it. Local files go with the build as its context. */
+export class Image {
+    #lines;
+    #files = [];
+    #dockerfilePath;
+    constructor(lines) {
+        this.#lines = lines;
+    }
+    /** The Dockerfile so far. */
+    get dockerfile() {
+        return `${this.#lines.join("\n")}\n`;
+    }
+    static base(image) {
+        return new Image([`FROM ${image}`]);
+    }
+    static debianSlim(pythonVersion = "3.12") {
+        if (!PYTHON.includes(pythonVersion))
+            throw new NotSupportedError(`Python ${pythonVersion}`, `Use one of ${PYTHON.join(", ")}.`);
+        return new Image([
+            `FROM python:${pythonVersion}-slim-bookworm`,
+            "RUN apt-get update && apt-get install -y --no-install-recommends gcc gfortran build-essential && rm -rf /var/lib/apt/lists/*",
+            "RUN pip install --upgrade pip",
+        ]);
+    }
+    /** A local Dockerfile; files it copies come from its directory. */
+    static fromDockerfile(path) {
+        const image = new Image([]);
+        image.#dockerfilePath = path;
+        return image;
+    }
+    pipInstall(packages, options = {}) {
+        const list = [packages].flat();
+        if (!list.length)
+            return this;
+        const flags = [
+            ...(options.indexUrl ? [`--index-url ${options.indexUrl}`] : []),
+            ...(options.extraIndexUrls ?? []).map((url) => `--extra-index-url ${url}`),
+            ...(options.findLinks ?? []).map((url) => `--find-links ${url}`),
+            ...(options.pre ? ["--pre"] : []),
+            ...(options.extraOptions ? [options.extraOptions] : []),
+        ];
+        this.#lines.push(`RUN python -m pip install ${list.map((one) => JSON.stringify(one)).join(" ")} ${flags.join(" ")}`.trim());
+        return this;
+    }
+    pipInstallFromRequirements(requirementsTxt) {
+        const remote = `/.requirements/${createHash("sha256").update(requirementsTxt).digest("hex").slice(0, 12)}.txt`;
+        this.#files.push({ local: requirementsTxt, remote, dir: false });
+        this.#lines.push(`COPY ${remote.slice(1)} ${remote}`, `RUN python -m pip install -r ${remote}`);
+        return this;
+    }
+    pipInstallFromPyproject() {
+        throw new NotSupportedError("Installing from pyproject.toml (pipInstallFromPyproject)", "Export requirements (`uv export > requirements.txt`) and use pipInstallFromRequirements.");
+    }
+    addLocalFile(localPath, remotePath) {
+        const source = `ctx/${this.#files.length}`;
+        this.#files.push({ local: localPath, remote: source, dir: false });
+        this.#lines.push(`COPY ${source} ${remotePath}`);
+        return this;
+    }
+    addLocalDir(localPath, remotePath) {
+        const source = `ctx/${this.#files.length}`;
+        this.#files.push({ local: localPath, remote: source, dir: true });
+        this.#lines.push(`COPY ${source} ${remotePath}`);
+        return this;
+    }
+    runCommands(...commands) {
+        for (const command of commands)
+            this.#lines.push(`RUN ${Array.isArray(command) ? JSON.stringify(command) : command}`);
+        return this;
+    }
+    env(envVars) {
+        for (const [key, value] of Object.entries(envVars))
+            this.#lines.push(`ENV ${key}=${JSON.stringify(value)}`);
+        return this;
+    }
+    workdir(dirPath) {
+        this.#lines.push(`WORKDIR ${dirPath}`);
+        return this;
+    }
+    entrypoint(entrypointCommands) {
+        this.#lines.push(`ENTRYPOINT ${JSON.stringify(entrypointCommands)}`);
+        return this;
+    }
+    cmd(cmd) {
+        this.#lines.push(`CMD ${JSON.stringify(cmd)}`);
+        return this;
+    }
+    dockerfileCommands(dockerfileCommands) {
+        this.#lines.push(...dockerfileCommands);
+        return this;
+    }
+    /** The Dockerfile and its context files, read from the local disk. */
+    async build() {
+        const { readFile, readdir, stat } = await import("node:fs/promises");
+        const paths = await import("node:path");
+        const files = [];
+        const add = async (local, remote) => {
+            const info = await stat(local);
+            if (info.isDirectory()) {
+                for (const entry of await readdir(local, { recursive: true, withFileTypes: true })) {
+                    if (!entry.isFile())
+                        continue;
+                    const full = paths.join(entry.parentPath, entry.name);
+                    files.push({
+                        path: `${remote}/${paths.relative(local, full)}`,
+                        content: (await readFile(full)).toString("base64"),
+                        encoding: "base64",
+                    });
+                }
+            }
+            else
+                files.push({
+                    path: remote,
+                    content: (await readFile(local)).toString("base64"),
+                    encoding: "base64",
+                    mode: info.mode & 0o777,
+                });
+        };
+        let dockerfile = this.dockerfile;
+        if (this.#dockerfilePath) {
+            dockerfile = await readFile(this.#dockerfilePath, "utf8");
+            const context = paths.dirname(this.#dockerfilePath);
+            for (const match of dockerfile.matchAll(/^\s*(?:COPY|ADD)\s+(?:--\S+\s+)*(.+?)\s+\S+\s*$/gim))
+                for (const source of match[1].split(/\s+/))
+                    if (!/^[a-z]+:\/\//.test(source))
+                        await add(paths.join(context, source), source.replace(/^\.\//, ""));
+        }
+        for (const file of this.#files)
+            await add(file.local, file.remote);
+        const digest = createHash("sha256").update(dockerfile);
+        for (const file of files)
+            digest.update(file.path).update(file.content);
+        return { dockerfile, files, name: `daytona-image-${digest.digest("hex").slice(0, 16)}` };
+    }
+}

package/dist/daytona/index.d.ts

@@ -0,0 +1,50 @@
+export { Daytona, CodeLanguage, SnapshotService, VolumeService, DEFAULT_RESOURCES, DEFAULT_AUTO_STOP_MINUTES, lifecycleOf, type CreateSandboxBaseParams, type CreateSandboxFromImageParams, type CreateSandboxFromSnapshotParams, type CreateSnapshotParams, type ForkSandboxParams, type ListSandboxesQuery, type PaginatedSnapshots, type Resources, type Snapshot, type Volume, type VolumeMount, } from "./daytona.js";
+export { Sandbox, CodeInterpreter, networkRules, windowSeconds, type ExecutionError, type ExecutionResult, type InterpreterContext, type OutputMessage, type PortPreviewUrl, } from "./sandbox.js";
+export { Process, CodeRunParams, type Command, type ExecuteResponse, type Session, type SessionCommandLogsResponse, type SessionExecuteRequest, type SessionExecuteResponse, } from "./process.js";
+export { FileSystem, type FileDownloadRequest, type FileDownloadResponse, type FileInfo, type FilePermissionsParams, type FileUpload, type Match, type ReplaceResult, type SearchFilesResponse, type UploadSource, } from "./filesystem.js";
+export { Git, type GitStatus, type ListBranchResponse } from "./git.js";
+export { Image } from "./image.js";
+export { resolvePath } from "./context.js";
+export type { DaytonaConfig, WithRuntime } from "./client.js";
+export * from "./errors.js";
+/** Daytona's sandbox states, as strings. */
+export declare const SandboxState: {
+    readonly STARTED: "started";
+    readonly STARTING: "starting";
+    readonly STOPPING: "stopping";
+    readonly STOPPED: "stopped";
+    readonly PAUSED: "paused";
+    readonly DESTROYING: "destroying";
+    readonly DESTROYED: "destroyed";
+};
+export type SandboxState = (typeof SandboxState)[keyof typeof SandboxState];
+export declare const ComputerUse: {
+    (...args: unknown[]): never;
+    new (...args: unknown[]): never;
+    readonly [key: string]: (...args: unknown[]) => never;
+};
+export declare const Mouse: {
+    (...args: unknown[]): never;
+    new (...args: unknown[]): never;
+    readonly [key: string]: (...args: unknown[]) => never;
+};
+export declare const Keyboard: {
+    (...args: unknown[]): never;
+    new (...args: unknown[]): never;
+    readonly [key: string]: (...args: unknown[]) => never;
+};
+export declare const Screenshot: {
+    (...args: unknown[]): never;
+    new (...args: unknown[]): never;
+    readonly [key: string]: (...args: unknown[]) => never;
+};
+export declare const Display: {
+    (...args: unknown[]): never;
+    new (...args: unknown[]): never;
+    readonly [key: string]: (...args: unknown[]) => never;
+};
+export declare const LspLanguageId: {
+    (...args: unknown[]): never;
+    new (...args: unknown[]): never;
+    readonly [key: string]: (...args: unknown[]) => never;
+};

package/dist/daytona/index.js

@@ -0,0 +1,50 @@
+/** Code written for Daytona's SDK, on Runtime Cloud. Change the import:
+ *
+ *   import { Daytona } from "withruntime/daytona"; // was: from "@daytona/sdk" or "@daytonaio/sdk"
+ *
+ * and set RUNTIME_API_KEY (or put a Runtime key in DAYTONA_API_KEY), or run
+ * `npx withruntime login` once. A Daytona key is never sent anywhere. What
+ * Runtime cannot do the way Daytona does throws NotSupportedError, naming what
+ * to use. */
+import { NotSupportedError } from "./errors.js";
+export { Daytona, CodeLanguage, SnapshotService, VolumeService, DEFAULT_RESOURCES, DEFAULT_AUTO_STOP_MINUTES, lifecycleOf, } from "./daytona.js";
+export { Sandbox, CodeInterpreter, networkRules, windowSeconds, } from "./sandbox.js";
+export { Process, CodeRunParams, } from "./process.js";
+export { FileSystem, } from "./filesystem.js";
+export { Git } from "./git.js";
+export { Image } from "./image.js";
+export { resolvePath } from "./context.js";
+export * from "./errors.js";
+/** Daytona's sandbox states, as strings. */
+export const SandboxState = {
+    STARTED: "started",
+    STARTING: "starting",
+    STOPPING: "stopping",
+    STOPPED: "stopped",
+    PAUSED: "paused",
+    DESTROYING: "destroying",
+    DESTROYED: "destroyed",
+};
+/** A stand-in for a Daytona export Runtime has no counterpart for. Importing
+ * it works; using it throws NotSupportedError naming the alternative. */
+function unsupportedExport(name, alternative) {
+    const fail = () => {
+        throw new NotSupportedError(`Daytona's ${name}`, alternative);
+    };
+    return new Proxy(function unsupported() { }, {
+        apply: fail,
+        construct: fail,
+        get: (_target, property) => {
+            if (typeof property === "symbol" || property === "then" || property === "prototype")
+                return undefined;
+            return fail();
+        },
+    });
+}
+const DESKTOP = "Use Runtime's desktop: `await sandbox.withruntime.desktop.start()`.";
+export const ComputerUse = unsupportedExport("computer use", DESKTOP);
+export const Mouse = unsupportedExport("computer use (Mouse)", DESKTOP);
+export const Keyboard = unsupportedExport("computer use (Keyboard)", DESKTOP);
+export const Screenshot = unsupportedExport("computer use (Screenshot)", DESKTOP);
+export const Display = unsupportedExport("computer use (Display)", DESKTOP);
+export const LspLanguageId = unsupportedExport("language servers", "Start one in a session with process.executeSessionCommand(..., { runAsync: true }).");

package/dist/daytona/process.d.ts

@@ -0,0 +1,86 @@
+import { quote, type SandboxContext } from "./context.js";
+/** Daytona's ExecuteResponse. `result` is the command's stdout and stderr
+ * together, in the order they were written. */
+export interface ExecuteResponse {
+    exitCode: number;
+    result: string;
+    artifacts?: {
+        stdout: string;
+        charts?: unknown[];
+    };
+}
+export declare class CodeRunParams {
+    argv?: string[];
+    env?: Record<string, string>;
+}
+export interface SessionExecuteRequest {
+    command: string;
+    runAsync?: boolean;
+    /** @deprecated Daytona's older name for runAsync. */
+    async?: boolean;
+    suppressInputEcho?: boolean;
+}
+export interface SessionExecuteResponse {
+    cmdId?: string;
+    output?: string;
+    stdout?: string;
+    stderr?: string;
+    exitCode?: number;
+}
+export interface SessionCommandLogsResponse {
+    output?: string;
+    stdout?: string;
+    stderr?: string;
+}
+export interface Command {
+    id: string;
+    command: string;
+    exitCode?: number;
+}
+export interface Session {
+    sessionId: string;
+    commands: Command[];
+}
+/** `sandbox.process`: Daytona's commands, code runs and sessions over
+ * Runtime's exec and processes. */
+export declare class Process {
+    #private;
+    constructor(ctx: SandboxContext);
+    /** Runs a shell command and resolves with its exit code and output. A
+     * non-zero exit is a result, not an error. `timeout` is in seconds; past
+     * it the command is killed and DaytonaProcessExecutionTimeoutError is
+     * thrown. */
+    executeCommand(command: string, cwd?: string, env?: Record<string, string>, timeout?: number): Promise<ExecuteResponse>;
+    /** Runs code in the sandbox's language (python by default, or javascript or
+     * typescript as given at create) as a fresh process. `artifacts.charts` is
+     * always empty on Runtime. */
+    codeRun(code: string, params?: CodeRunParams, timeout?: number): Promise<ExecuteResponse>;
+    /** Starts a session: a bash that keeps its directory and variables from
+     * one command to the next. Runs one command at a time; a command sent while
+     * another runs waits for it, as it would typed into a shell. */
+    createSession(sessionId: string): Promise<void>;
+    getSession(sessionId: string): Promise<Session>;
+    getSessionCommand(sessionId: string, commandId: string): Promise<Command>;
+    /** Runs a command in the session. It waits and returns the output and exit
+     * code, or with `runAsync: true` returns the cmdId at once. */
+    executeSessionCommand(sessionId: string, req: SessionExecuteRequest, _timeout?: number): Promise<SessionExecuteResponse>;
+    /** A command's output so far, or with callbacks, its output from the start
+     * as it happens until it ends. */
+    getSessionCommandLogs(sessionId: string, commandId: string): Promise<SessionCommandLogsResponse>;
+    getSessionCommandLogs(sessionId: string, commandId: string, onStdout: (chunk: string) => void, onStderr: (chunk: string) => void): Promise<void>;
+    /** Types `data` into the session, where the running command reads it. */
+    sendSessionCommandInput(sessionId: string, commandId: string, data: string): Promise<void>;
+    /** Sessions this object made or found. */
+    listSessions(): Promise<Session[]>;
+    /** Ends the session's shell and everything it runs. */
+    deleteSession(sessionId: string): Promise<void>;
+    getEntrypointSession(): Promise<never>;
+    getEntrypointLogs(): Promise<never>;
+    createPty(): Promise<never>;
+    connectPty(): Promise<never>;
+    listPtySessions(): Promise<never>;
+    getPtySessionInfo(): Promise<never>;
+    killPtySession(): Promise<never>;
+    resizePtySession(): Promise<never>;
+}
+export { quote };

package/dist/daytona/process.js

@@ -0,0 +1,339 @@
+import { randomUUID } from "node:crypto";
+import { HOME, LONGEST_MS, quote, resolvePath } from "./context.js";
+import { DaytonaCommandAlreadyCompletedError, DaytonaConflictError, DaytonaNotFoundError, DaytonaProcessExecutionTimeoutError, DaytonaSessionEndedError, guard, NotSupportedError, } from "./errors.js";
+export class CodeRunParams {
+    argv;
+    env;
+}
+const MARK = "\x1e";
+/* Each session command is one line to the session's bash, which bash reads
+   whole before running it, so input sent later reaches the command, not bash.
+   The command travels base64-encoded and runs through eval, keeping the
+   shell's directory, variables and functions from one command to the next;
+   the markers say where its output ends and what it exited with. */
+const PRELUDE = '__rt_run() { eval "$(printf %s "$1" | base64 -d)"; __rt_c=$?; ' +
+    'printf \'\\036RT%s:%s\\036\' "$2" "$__rt_c"; printf \'\\036RT%s\\036\' "$2" >&2; return $__rt_c; }\n';
+const TAG = "daytona-session:";
+class SessionCommand {
+    id;
+    command;
+    exitCode;
+    stdout = "";
+    stderr = "";
+    output = "";
+    done = Promise.resolve();
+    /** Settles once the command's line has reached the session's shell: input
+     * sent before then would be read by the shell, not the command. */
+    written = Promise.resolve();
+    listeners = new Set();
+    constructor(id, command) {
+        this.id = id;
+        this.command = command;
+    }
+    emit(stream, text) {
+        if (!text)
+            return;
+        this[stream] += text;
+        this.output += text;
+        for (const listener of this.listeners)
+            (stream === "stdout" ? listener.onStdout : listener.onStderr)(text);
+    }
+}
+class ShellSession {
+    id;
+    process;
+    cursor;
+    commands = [];
+    tail = Promise.resolve();
+    ended = false;
+    constructor(id, process, cursor) {
+        this.id = id;
+        this.process = process;
+        this.cursor = cursor;
+    }
+}
+/** `sandbox.process`: Daytona's commands, code runs and sessions over
+ * Runtime's exec and processes. */
+export class Process {
+    #ctx;
+    #sessions = new Map();
+    constructor(ctx) {
+        this.#ctx = ctx;
+    }
+    #env(extra) {
+        const merged = { ...this.#ctx.env, ...extra };
+        return Object.keys(merged).length ? { env: merged } : {};
+    }
+    /** Runs a shell command and resolves with its exit code and output. A
+     * non-zero exit is a result, not an error. `timeout` is in seconds; past
+     * it the command is killed and DaytonaProcessExecutionTimeoutError is
+     * thrown. */
+    async executeCommand(command, cwd, env, timeout) {
+        await this.#ctx.ensureHome(`${command}\n${cwd ?? ""}`);
+        const runtime = await this.#ctx.live();
+        const timeoutMs = timeout ? timeout * 1000 : LONGEST_MS;
+        const result = await guard("sandbox", () => runtime.exec(`{ ${command}\n} 2>&1`, {
+            cwd: cwd === undefined ? HOME : resolvePath(cwd),
+            ...this.#env(env),
+            timeoutMs,
+        }));
+        if (result.timedOut)
+            throw new DaytonaProcessExecutionTimeoutError(`Command timed out after ${timeout} s. Pass a larger timeout, or 0 for none.`, 408);
+        const output = result.stdout + result.stderr;
+        return { exitCode: result.exitCode ?? -1, result: output, artifacts: { stdout: output } };
+    }
+    /** Runs code in the sandbox's language (python by default, or javascript or
+     * typescript as given at create) as a fresh process. `artifacts.charts` is
+     * always empty on Runtime. */
+    async codeRun(code, params = {}, timeout) {
+        const runtime = await this.#ctx.live();
+        const interpreter = this.#ctx.language === "python"
+            ? ["python3", "-c", code]
+            : this.#ctx.language === "typescript"
+                ? ["bun", "-e", code]
+                : ["node", "-e", code];
+        const timeoutMs = timeout ? timeout * 1000 : LONGEST_MS;
+        const result = await guard("sandbox", () => runtime.exec(["sh", "-c", 'exec "$@" 2>&1', "sh", ...interpreter, ...(params.argv ?? [])], {
+            cwd: HOME,
+            ...this.#env(params.env),
+            timeoutMs,
+        }));
+        if (result.timedOut)
+            throw new DaytonaProcessExecutionTimeoutError(`Code run timed out after ${timeout} s.`, 408);
+        return {
+            exitCode: result.exitCode ?? -1,
+            result: result.stdout,
+            artifacts: { stdout: result.stdout, charts: [] },
+        };
+    }
+    // ---- sessions ----------------------------------------------------------
+    /** Starts a session: a bash that keeps its directory and variables from
+     * one command to the next. Runs one command at a time; a command sent while
+     * another runs waits for it, as it would typed into a shell. */
+    async createSession(sessionId) {
+        if (this.#sessions.has(sessionId) || (await this.#discover(sessionId)))
+            throw new DaytonaConflictError(`Session ${sessionId} already exists.`, 409);
+        const runtime = await this.#ctx.live();
+        const process = await guard("sandbox", () => runtime.spawn(["bash", "--noprofile", "--norc", "-s", `${TAG}${sessionId}`], {
+            cwd: HOME,
+            ...this.#env(),
+            stdin: "pipe",
+            timeoutMs: LONGEST_MS,
+        }));
+        await guard("process", () => process.write(PRELUDE));
+        this.#sessions.set(sessionId, new ShellSession(sessionId, process, 0));
+    }
+    /** A session made by another client (another Daytona object on this
+     * sandbox): found by its tag among the running processes. Its output from
+     * now on is followed; earlier commands are not known here. */
+    async #discover(sessionId) {
+        const runtime = await this.#ctx.live();
+        const list = await guard("sandbox", () => runtime.processes.list());
+        const info = list.find((one) => one.state === "running" && one.command.split(" ").includes(`${TAG}${sessionId}`));
+        if (!info)
+            return undefined;
+        const process = await guard("process", () => runtime.processes.get(info.id));
+        const session = new ShellSession(sessionId, process, info.outputBytes);
+        this.#sessions.set(sessionId, session);
+        return session;
+    }
+    async #session(sessionId) {
+        const session = this.#sessions.get(sessionId) ?? (await this.#discover(sessionId));
+        if (!session)
+            throw new DaytonaNotFoundError(`Session ${sessionId} was not found.`, 404);
+        if (session.ended)
+            throw new DaytonaSessionEndedError(`Session ${sessionId} has ended.`, 410);
+        return session;
+    }
+    #command(session, commandId) {
+        const found = session.commands.find((one) => one.id === commandId);
+        if (!found)
+            throw new DaytonaNotFoundError(`Command ${commandId} was not found in session ${session.id} (commands run from another client are not known here).`, 404);
+        return found;
+    }
+    async getSession(sessionId) {
+        const session = await this.#session(sessionId);
+        return { sessionId, commands: session.commands.map(describe) };
+    }
+    async getSessionCommand(sessionId, commandId) {
+        return describe(this.#command(await this.#session(sessionId), commandId));
+    }
+    /** Runs a command in the session. It waits and returns the output and exit
+     * code, or with `runAsync: true` returns the cmdId at once. */
+    async executeSessionCommand(sessionId, req, _timeout) {
+        const session = await this.#session(sessionId);
+        await this.#ctx.ensureHome(req.command);
+        await this.#ctx.live();
+        const command = new SessionCommand(randomUUID(), req.command);
+        session.commands.push(command);
+        const previous = session.tail;
+        let release;
+        session.tail = new Promise((resolve) => (release = resolve));
+        let sent;
+        command.written = new Promise((resolve) => (sent = resolve));
+        command.done = (async () => {
+            try {
+                await previous;
+                if (session.ended)
+                    throw new DaytonaSessionEndedError(`Session ${sessionId} has ended.`, 410);
+                const encoded = Buffer.from(req.command).toString("base64");
+                await guard("process", () => session.process.write(`__rt_run ${encoded} ${command.id}\n`));
+                sent();
+                await this.#follow(session, command);
+            }
+            finally {
+                sent();
+                release();
+            }
+        })();
+        if (req.runAsync || req.async) {
+            command.done.catch(() => undefined);
+            return { cmdId: command.id };
+        }
+        await command.done;
+        return {
+            cmdId: command.id,
+            output: command.output,
+            stdout: command.stdout,
+            stderr: command.stderr,
+            ...(command.exitCode === undefined ? {} : { exitCode: command.exitCode }),
+        };
+    }
+    async #follow(session, command) {
+        const outMark = `${MARK}RT${command.id}:`;
+        const errMark = `${MARK}RT${command.id}${MARK}`;
+        const buffer = { stdout: "", stderr: "" };
+        const sent = { stdout: 0, stderr: 0 };
+        let outDone = false;
+        let errDone = false;
+        // Sends what is certainly the command's: everything before a marker, or
+        // before a marker's first byte that may still be arriving.
+        const flush = (stream, end) => {
+            command.emit(stream, buffer[stream].slice(sent[stream], end));
+            sent[stream] = Math.max(sent[stream], end);
+        };
+        await guard("process", async () => {
+            for await (const event of session.process.output({ cursor: session.cursor })) {
+                if (event.type === "exit") {
+                    session.ended = true;
+                    flush("stdout", buffer.stdout.length);
+                    flush("stderr", buffer.stderr.length);
+                    command.exitCode = event.exitCode ?? -1;
+                    return;
+                }
+                if (event.type !== "stdout" && event.type !== "stderr")
+                    continue;
+                session.cursor = event.offset + Buffer.byteLength(event.data);
+                buffer[event.type] += event.data;
+                if (event.type === "stdout" && !outDone) {
+                    const at = buffer.stdout.indexOf(outMark);
+                    const end = at < 0 ? -1 : buffer.stdout.indexOf(MARK, at + outMark.length);
+                    if (end >= 0) {
+                        flush("stdout", at);
+                        command.exitCode = Number(buffer.stdout.slice(at + outMark.length, end));
+                        outDone = true;
+                    }
+                    else {
+                        const pending = buffer.stdout.lastIndexOf(MARK);
+                        flush("stdout", pending < 0 ? buffer.stdout.length : pending);
+                    }
+                }
+                if (event.type === "stderr" && !errDone) {
+                    const at = buffer.stderr.indexOf(errMark);
+                    if (at >= 0) {
+                        flush("stderr", at);
+                        errDone = true;
+                    }
+                    else {
+                        const pending = buffer.stderr.lastIndexOf(MARK);
+                        flush("stderr", pending < 0 ? buffer.stderr.length : pending);
+                    }
+                }
+                if (outDone && errDone)
+                    return;
+            }
+            session.ended = true;
+        });
+    }
+    async getSessionCommandLogs(sessionId, commandId, onStdout, onStderr) {
+        const command = this.#command(await this.#session(sessionId), commandId);
+        if (!onStdout && !onStderr)
+            return { output: command.output, stdout: command.stdout, stderr: command.stderr };
+        const listener = {
+            onStdout: onStdout ?? (() => undefined),
+            onStderr: onStderr ?? (() => undefined),
+        };
+        if (command.stdout)
+            listener.onStdout(command.stdout);
+        if (command.stderr)
+            listener.onStderr(command.stderr);
+        command.listeners.add(listener);
+        try {
+            await command.done;
+        }
+        finally {
+            command.listeners.delete(listener);
+        }
+    }
+    /** Types `data` into the session, where the running command reads it. */
+    async sendSessionCommandInput(sessionId, commandId, data) {
+        const session = await this.#session(sessionId);
+        const command = this.#command(session, commandId);
+        await command.written;
+        if (command.exitCode !== undefined)
+            throw new DaytonaCommandAlreadyCompletedError(`Command ${commandId} has already completed.`, 410);
+        await guard("process", () => session.process.write(data));
+    }
+    /** Sessions this object made or found. */
+    async listSessions() {
+        return [...this.#sessions.values()]
+            .filter((one) => !one.ended)
+            .map((one) => ({ sessionId: one.id, commands: one.commands.map(describe) }));
+    }
+    /** Ends the session's shell and everything it runs. */
+    async deleteSession(sessionId) {
+        const session = await this.#session(sessionId);
+        session.ended = true;
+        this.#sessions.delete(sessionId);
+        await guard("process", () => session.process.kill("SIGKILL"));
+    }
+    getEntrypointSession() {
+        return entrypoint();
+    }
+    getEntrypointLogs() {
+        return entrypoint();
+    }
+    // ---- terminals ---------------------------------------------------------
+    createPty() {
+        return pty();
+    }
+    connectPty() {
+        return pty();
+    }
+    listPtySessions() {
+        return pty();
+    }
+    getPtySessionInfo() {
+        return pty();
+    }
+    killPtySession() {
+        return pty();
+    }
+    resizePtySession() {
+        return pty();
+    }
+}
+function describe(command) {
+    return {
+        id: command.id,
+        command: command.command,
+        ...(command.exitCode === undefined ? {} : { exitCode: command.exitCode }),
+    };
+}
+function pty() {
+    return Promise.reject(new NotSupportedError("Daytona's PTY sessions", "Use `await sandbox.withruntime.terminal({ cols, rows, onData })` for an interactive terminal, or a session for commands."));
+}
+function entrypoint() {
+    return Promise.reject(new NotSupportedError("The image entrypoint session", "A Runtime image does not run an entrypoint; start it with process.createSession and executeSessionCommand."));
+}
+export { quote };