withruntime 0.4.0 → 0.5.0

package/dist/daytona/sandbox.d.ts

@@ -0,0 +1,196 @@
+import type { Runtime } from "../client.js";
+import type { RuntimeSandbox } from "./client.js";
+import { DaytonaNotFoundError } from "./errors.js";
+import { FileSystem } from "./filesystem.js";
+import { Git } from "./git.js";
+import { Process } from "./process.js";
+/** How the sandbox's lease follows Daytona's lifecycle settings. */
+export interface Lifecycle {
+    /** Seconds without a call from this client before the sandbox pauses
+     * (Daytona's autoStopInterval), 60 to 3600. */
+    windowSeconds: number;
+    /** Epoch ms past which the lease is never extended (ttlMinutes). */
+    deadline?: number;
+    /** stop() ends the sandbox instead of pausing it (ephemeral, or
+     * autoDeleteInterval 0). */
+    ephemeral: boolean;
+    autoStopInterval: number;
+    autoArchiveInterval: number;
+    autoDeleteInterval: number;
+}
+export interface SandboxOptions {
+    env: Record<string, string>;
+    language: string;
+    public: boolean;
+    lifecycle: Lifecycle;
+    snapshot?: string;
+}
+export type SandboxState = "started" | "starting" | "stopping" | "stopped" | "paused" | "destroying" | "destroyed";
+export interface PortPreviewUrl {
+    sandboxId: string;
+    port: number;
+    url: string;
+    /** Private previews: send it as the `x-runtime-preview-token` header
+     * (Daytona's header is x-daytona-preview-token). "" when public. */
+    token: string;
+}
+export interface InterpreterContext {
+    id: string;
+    cwd: string;
+    language: string;
+    active: boolean;
+}
+export interface OutputMessage {
+    output: string;
+}
+export interface ExecutionError {
+    name: string;
+    value: string;
+    traceback?: string;
+}
+export interface ExecutionResult {
+    stdout: string;
+    stderr: string;
+    error?: ExecutionError;
+}
+/** `sandbox.codeInterpreter`: Daytona's stateful Python over Runtime's
+ * interpreter. */
+export declare class CodeInterpreter {
+    #private;
+    constructor(sandbox: () => Promise<RuntimeSandbox>, env: () => Record<string, string>);
+    runCode(code: string, options?: {
+        context?: InterpreterContext;
+        envs?: Record<string, string>;
+        timeout?: number;
+        onStdout?: (message: OutputMessage) => unknown;
+        onStderr?: (message: OutputMessage) => unknown;
+        onError?: (error: ExecutionError) => unknown;
+    }): Promise<ExecutionResult>;
+    createContext(cwd?: string): Promise<InterpreterContext>;
+    listContexts(): Promise<InterpreterContext[]>;
+    deleteContext(context: InterpreterContext): Promise<void>;
+}
+/** A sandbox, with Daytona's fields and methods. `sandbox.withruntime` is the
+ * Runtime sandbox underneath, for anything Daytona has no name for. */
+export declare class Sandbox {
+    #private;
+    readonly fs: FileSystem;
+    readonly process: Process;
+    readonly git: Git;
+    readonly codeInterpreter: CodeInterpreter;
+    env: Record<string, string>;
+    readonly public: boolean;
+    readonly snapshot: string | undefined;
+    /** Use daytona.create or daytona.get. */
+    constructor(runtime: RuntimeSandbox, client: Runtime, options: SandboxOptions);
+    /** The Runtime sandbox underneath: previews, network, snapshots, desktop,
+     * terminal and the rest of Runtime's SDK. */
+    get withruntime(): RuntimeSandbox;
+    get id(): string;
+    get name(): string;
+    get organizationId(): string;
+    /** Daytona's user name, so `/home/${sandbox.user}` leads to the working
+     * directory. Commands run as Runtime's sandbox owner, with passwordless sudo. */
+    get user(): string;
+    get labels(): Record<string, string>;
+    get target(): string;
+    get cpu(): number;
+    get gpu(): number;
+    /** GiB. */
+    get memory(): number;
+    /** GiB. */
+    get disk(): number;
+    get state(): SandboxState;
+    get errorReason(): string | undefined;
+    get recoverable(): boolean;
+    get autoStopInterval(): number;
+    get autoArchiveInterval(): number;
+    get autoDeleteInterval(): number;
+    get createdAt(): string;
+    get updatedAt(): string;
+    /** Wakes a stopped (paused) sandbox, keeping its files and memory. */
+    start(_timeout?: number): Promise<void>;
+    /** Stops the sandbox: Runtime pauses it, keeping its files and memory, so
+     * start() carries on. An ephemeral sandbox ends instead. */
+    stop(_timeout?: number, _force?: boolean): Promise<void>;
+    /** Pauses the sandbox with its memory. */
+    pause(_timeout?: number): Promise<void>;
+    /** Runtime has no archive tier: a stopped sandbox stays paused, kept for
+     * its retention (30 days paid, 7 on the trial, or autoDeleteInterval). */
+    archive(): Promise<void>;
+    /** Ends the sandbox for good. */
+    delete(_timeout?: number): Promise<void>;
+    waitUntilStarted(timeout?: number): Promise<void>;
+    waitUntilStopped(timeout?: number): Promise<void>;
+    refreshData(): Promise<void>;
+    /** Counts as activity: moves the lease a full autoStop window on. */
+    refreshActivity(): Promise<void>;
+    /** The sandbox pauses after `interval` minutes without a call from this
+     * client (1 to 60; 0 is 60). */
+    setAutostopInterval(interval: number): Promise<void>;
+    setAutoPauseInterval(interval: number): Promise<void>;
+    /** Runtime has no archive tier; recorded only. */
+    setAutoArchiveInterval(interval: number): Promise<void>;
+    /** 0: stop() ends the sandbox. More: a stopped sandbox is kept that many
+     * minutes, rounded up to whole days (Runtime's retention). */
+    setAutoDeleteInterval(interval: number): Promise<void>;
+    setTtl(ttlMinutes: number): Promise<void>;
+    /** Changes the environment later commands get from this object. */
+    updateEnv(env: Record<string, string>, options?: {
+        unset?: string[];
+    }): Promise<void>;
+    updateNetworkSettings(settings: {
+        networkBlockAll?: boolean;
+        networkAllowList?: string;
+        domainAllowList?: string;
+    }): Promise<void>;
+    /** A preview address for `port`: public when the sandbox was created with
+     * `public: true`, else private with a token. */
+    getPreviewLink(port: number): Promise<PortPreviewUrl>;
+    getUserHomeDir(): Promise<string>;
+    getUserRootDir(): Promise<string>;
+    getWorkDir(): Promise<string>;
+    /** A copy of this sandbox with its files, memory and running processes. */
+    fork(params?: {
+        name?: string;
+    }, _timeout?: number): Promise<Sandbox>;
+    _experimental_fork(params?: {
+        name?: string;
+    }, timeout?: number): Promise<Sandbox>;
+    /** Keeps this sandbox (files, memory, processes) as a Runtime snapshot
+     * named `name`; `daytona.create({ snapshot: name })` starts from it. */
+    createSnapshot(name: string, _timeout?: number): Promise<void>;
+    _experimental_createSnapshot(name: string, timeout?: number): Promise<void>;
+    get computerUse(): never;
+    setLabels(): Promise<never>;
+    recover(): Promise<never>;
+    resize(): Promise<never>;
+    waitForResizeComplete(): Promise<never>;
+    getMetrics(): Promise<never>;
+    getMetricsLatest(): Promise<never>;
+    createLspServer(): never;
+    updateSecrets(): Promise<never>;
+    getSignedPreviewUrl(): Promise<never>;
+    expireSignedPreviewUrl(): Promise<never>;
+    rotateSigningKey(): Promise<never>;
+    uploadUrl(): Promise<never>;
+    downloadUrl(): Promise<never>;
+    createSshAccess(): Promise<never>;
+    revokeSshAccess(): Promise<never>;
+    validateSshAccess(): Promise<never>;
+}
+/** Daytona's autoStopInterval (minutes; 0 is off) as the lease window. */
+export declare function windowSeconds(autoStopMinutes: number): number;
+/** Minutes as Runtime's retention: whole days, 1 to 365. */
+export declare function retentionDays(minutes: number): number;
+/** Daytona's network settings as Runtime's rules, or undefined for the
+ * default (the public web). */
+export declare function networkRules(settings: {
+    networkBlockAll?: boolean;
+    networkAllowList?: string;
+    domainAllowList?: string;
+}): {
+    internet: boolean;
+    allow?: string[];
+} | undefined;
+export declare function notFound(what: string): DaytonaNotFoundError;

package/dist/daytona/sandbox.js

@@ -0,0 +1,448 @@
+import { RuntimeError } from "../errors.js";
+import { HOME, HOME_LINK } from "./context.js";
+import { DaytonaError, DaytonaNotFoundError, guard, NotSupportedError } from "./errors.js";
+import { FileSystem } from "./filesystem.js";
+import { Git } from "./git.js";
+import { Process } from "./process.js";
+function refusal(feature, alternative) {
+    return Promise.reject(new NotSupportedError(feature, alternative));
+}
+/** `sandbox.codeInterpreter`: Daytona's stateful Python over Runtime's
+ * interpreter. */
+export class CodeInterpreter {
+    #sandbox;
+    #env;
+    #envContext;
+    constructor(sandbox, env) {
+        this.#sandbox = sandbox;
+        this.#env = env;
+    }
+    /** The sandbox's envVars reach code through one context made for them. */
+    async #defaultContext() {
+        const env = this.#env();
+        if (!Object.keys(env).length)
+            return "python";
+        this.#envContext ??= (async () => {
+            const runtime = await this.#sandbox();
+            const made = await guard("sandbox", () => runtime.interpreter.contexts.create({ language: "python", cwd: HOME, env }));
+            return made.id;
+        })();
+        return this.#envContext;
+    }
+    async runCode(code, options = {}) {
+        if (options.envs && Object.keys(options.envs).length)
+            throw new NotSupportedError("Per-run environment variables (runCode envs)", "Pass envVars when creating the sandbox, or set os.environ in the code.");
+        const runtime = await this.#sandbox();
+        const context = options.context?.id ?? (await this.#defaultContext());
+        const execution = await guard("sandbox", () => runtime.interpreter.run(code, {
+            language: "python",
+            context,
+            ...(options.timeout ? { timeoutMs: options.timeout * 1000 } : {}),
+            ...(options.onStdout
+                ? { onStdout: (output) => void options.onStdout({ output }) }
+                : {}),
+            ...(options.onStderr
+                ? { onStderr: (output) => void options.onStderr({ output }) }
+                : {}),
+            ...(options.onError
+                ? { onError: (error) => void options.onError(error) }
+                : {}),
+        }));
+        return {
+            stdout: execution.stdout,
+            stderr: execution.stderr,
+            ...(execution.error ? { error: execution.error } : {}),
+        };
+    }
+    async createContext(cwd) {
+        const runtime = await this.#sandbox();
+        const env = this.#env();
+        const made = await guard("sandbox", () => runtime.interpreter.contexts.create({
+            language: "python",
+            cwd: cwd ?? HOME,
+            ...(Object.keys(env).length ? { env } : {}),
+        }));
+        return { id: made.id, cwd: made.cwd, language: made.language, active: true };
+    }
+    async listContexts() {
+        const runtime = await this.#sandbox();
+        const all = await guard("sandbox", () => runtime.interpreter.contexts.list());
+        return all.map((one) => ({ id: one.id, cwd: one.cwd, language: one.language, active: true }));
+    }
+    async deleteContext(context) {
+        const runtime = await this.#sandbox();
+        await guard("sandbox", () => runtime.interpreter.contexts.remove(context.id));
+    }
+}
+/** A sandbox, with Daytona's fields and methods. `sandbox.withruntime` is the
+ * Runtime sandbox underneath, for anything Daytona has no name for. */
+export class Sandbox {
+    fs;
+    process;
+    git;
+    codeInterpreter;
+    env;
+    public;
+    snapshot;
+    #rt;
+    #client;
+    #options;
+    #home;
+    #pausedByPause = false;
+    /** Use daytona.create or daytona.get. */
+    constructor(runtime, client, options) {
+        this.#rt = runtime;
+        this.#client = client;
+        this.#options = options;
+        this.env = { ...options.env };
+        this.public = options.public;
+        this.snapshot = options.snapshot;
+        const ctx = {
+            live: () => this.#live(),
+            language: options.language,
+            ensureHome: (text) => this.#ensureHome(text),
+        };
+        // A getter, so the modules see the environment updateEnv sets.
+        Object.defineProperty(ctx, "env", { get: () => this.env });
+        this.fs = new FileSystem(ctx);
+        this.process = new Process(ctx);
+        this.git = new Git(ctx);
+        this.codeInterpreter = new CodeInterpreter(() => this.#live(), () => this.env);
+    }
+    /** The Runtime sandbox underneath: previews, network, snapshots, desktop,
+     * terminal and the rest of Runtime's SDK. */
+    get withruntime() {
+        return this.#rt;
+    }
+    get id() {
+        return this.#rt.id;
+    }
+    get name() {
+        return this.#rt.info.name ?? this.#rt.id;
+    }
+    get organizationId() {
+        return "";
+    }
+    /** Daytona's user name, so `/home/${sandbox.user}` leads to the working
+     * directory. Commands run as Runtime's sandbox owner, with passwordless sudo. */
+    get user() {
+        return "daytona";
+    }
+    get labels() {
+        return { ...this.#rt.info.labels };
+    }
+    get target() {
+        return "us";
+    }
+    get cpu() {
+        return this.#rt.info.vcpu;
+    }
+    get gpu() {
+        return 0;
+    }
+    /** GiB. */
+    get memory() {
+        return this.#rt.info.memoryMiB / 1024;
+    }
+    /** GiB. */
+    get disk() {
+        return this.#rt.info.diskMiB / 1024;
+    }
+    get state() {
+        switch (this.#rt.state) {
+            case "running":
+                return "started";
+            case "starting":
+            case "resuming":
+                return "starting";
+            case "pausing":
+                return "stopping";
+            case "paused":
+                return this.#pausedByPause ? "paused" : "stopped";
+            case "stopping":
+                return "destroying";
+            default:
+                return "destroyed";
+        }
+    }
+    get errorReason() {
+        return this.#rt.info.stopReason ?? undefined;
+    }
+    get recoverable() {
+        return false;
+    }
+    get autoStopInterval() {
+        return this.#options.lifecycle.autoStopInterval;
+    }
+    get autoArchiveInterval() {
+        return this.#options.lifecycle.autoArchiveInterval;
+    }
+    get autoDeleteInterval() {
+        return this.#options.lifecycle.autoDeleteInterval;
+    }
+    get createdAt() {
+        return this.#rt.info.createdAt;
+    }
+    get updatedAt() {
+        return this.#rt.info.pausedAt ?? this.#rt.info.readyAt ?? this.#rt.info.createdAt;
+    }
+    /** The sandbox, its lease moved on when less than half of the autoStop
+     * window is left: every call through this object counts as activity, as
+     * Daytona's API calls do. */
+    async #live(force = false) {
+        const lifecycle = this.#options.lifecycle;
+        if (this.#rt.state !== "running")
+            return this.#rt;
+        const left = Date.parse(this.#rt.info.expiresAt) - Date.now();
+        if (!force && left > lifecycle.windowSeconds * 500)
+            return this.#rt;
+        let seconds = Math.ceil(lifecycle.windowSeconds - left / 1000);
+        if (lifecycle.deadline !== undefined)
+            seconds = Math.min(seconds, Math.floor((lifecycle.deadline - Date.now() - left) / 1000));
+        if (seconds < 1)
+            return this.#rt;
+        try {
+            await this.#rt.extend(seconds);
+        }
+        catch (error) {
+            // The lease may have ended since this object last looked; the call
+            // itself then says what state the sandbox is in.
+            if (!(error instanceof RuntimeError && error.status === 409))
+                throw error;
+            await this.#rt.refresh().catch(() => undefined);
+        }
+        return this.#rt;
+    }
+    #ensureHome(text) {
+        if (this.#home || !text?.includes("/home/daytona"))
+            return this.#home ?? Promise.resolve();
+        this.#home = (async () => {
+            const runtime = await this.#live();
+            await guard("sandbox", () => runtime.exec(HOME_LINK)).catch(() => undefined);
+        })();
+        return this.#home;
+    }
+    // ---- lifecycle ----------------------------------------------------------
+    /** Wakes a stopped (paused) sandbox, keeping its files and memory. */
+    async start(_timeout) {
+        await guard("sandbox", () => this.#rt.refresh());
+        const state = this.#rt.state;
+        if (state === "stopped" || state === "stopping")
+            throw new DaytonaError(`Sandbox ${this.id} was deleted and cannot start.`, 410);
+        if (state === "paused" || state === "pausing")
+            await guard("sandbox", () => this.#rt.wake({ timeoutSeconds: this.#options.lifecycle.windowSeconds }));
+        this.#pausedByPause = false;
+    }
+    /** Stops the sandbox: Runtime pauses it, keeping its files and memory, so
+     * start() carries on. An ephemeral sandbox ends instead. */
+    async stop(_timeout, _force) {
+        await guard("sandbox", () => this.#rt.refresh());
+        const state = this.#rt.state;
+        if (state === "stopped" || state === "stopping")
+            return;
+        if (this.#options.lifecycle.ephemeral) {
+            await guard("sandbox", () => this.#rt.stop());
+            return;
+        }
+        if (state !== "paused")
+            await guard("sandbox", () => this.#rt.pause());
+        this.#pausedByPause = false;
+    }
+    /** Pauses the sandbox with its memory. */
+    async pause(_timeout) {
+        await guard("sandbox", () => this.#rt.refresh());
+        if (this.#rt.state === "running")
+            await guard("sandbox", () => this.#rt.pause());
+        this.#pausedByPause = true;
+    }
+    /** Runtime has no archive tier: a stopped sandbox stays paused, kept for
+     * its retention (30 days paid, 7 on the trial, or autoDeleteInterval). */
+    async archive() {
+        await this.stop();
+    }
+    /** Ends the sandbox for good. */
+    async delete(_timeout) {
+        await guard("sandbox", () => this.#rt.refresh());
+        if (this.#rt.state !== "stopped")
+            await guard("sandbox", () => this.#rt.stop({ wait: false }));
+    }
+    async waitUntilStarted(timeout = 60) {
+        await guard("sandbox", () => this.#rt.waitFor("running", { timeoutSeconds: timeout || 60 }));
+        if (this.#rt.state !== "running")
+            throw new DaytonaError(`Sandbox ${this.id} is ${this.state}, not started.`);
+    }
+    async waitUntilStopped(timeout = 60) {
+        await guard("sandbox", () => this.#rt.waitFor("paused", { timeoutSeconds: timeout || 60 }));
+    }
+    async refreshData() {
+        await guard("sandbox", () => this.#rt.refresh());
+    }
+    /** Counts as activity: moves the lease a full autoStop window on. */
+    async refreshActivity() {
+        await guard("sandbox", () => this.#live(true));
+    }
+    /** The sandbox pauses after `interval` minutes without a call from this
+     * client (1 to 60; 0 is 60). */
+    async setAutostopInterval(interval) {
+        const lifecycle = this.#options.lifecycle;
+        lifecycle.autoStopInterval = interval;
+        lifecycle.windowSeconds = windowSeconds(interval);
+        await guard("sandbox", () => this.#live());
+    }
+    setAutoPauseInterval(interval) {
+        return this.setAutostopInterval(interval);
+    }
+    /** Runtime has no archive tier; recorded only. */
+    async setAutoArchiveInterval(interval) {
+        this.#options.lifecycle.autoArchiveInterval = interval;
+    }
+    /** 0: stop() ends the sandbox. More: a stopped sandbox is kept that many
+     * minutes, rounded up to whole days (Runtime's retention). */
+    async setAutoDeleteInterval(interval) {
+        const lifecycle = this.#options.lifecycle;
+        lifecycle.autoDeleteInterval = interval;
+        lifecycle.ephemeral = interval === 0;
+        if (interval > 0)
+            await guard("sandbox", () => this.#rt.setRetention(retentionDays(interval)));
+    }
+    async setTtl(ttlMinutes) {
+        if (ttlMinutes === 0) {
+            delete this.#options.lifecycle.deadline;
+            return;
+        }
+        const deadline = Date.parse(this.#rt.info.createdAt) + ttlMinutes * 60_000;
+        if (Date.parse(this.#rt.info.expiresAt) > deadline)
+            throw new NotSupportedError("A time to live shorter than the current lease", "Runtime leases only move later; call stop() or delete() when the work is done.");
+        this.#options.lifecycle.deadline = deadline;
+    }
+    // ---- settings -----------------------------------------------------------
+    /** Changes the environment later commands get from this object. */
+    async updateEnv(env, options = {}) {
+        this.env = { ...this.env, ...env };
+        for (const name of options.unset ?? [])
+            delete this.env[name];
+    }
+    async updateNetworkSettings(settings) {
+        const rules = networkRules(settings);
+        const runtime = await this.#live();
+        await guard("sandbox", () => runtime.network.set(rules ?? { internet: true }));
+    }
+    /** A preview address for `port`: public when the sandbox was created with
+     * `public: true`, else private with a token. */
+    async getPreviewLink(port) {
+        const runtime = await this.#live();
+        const preview = await guard("sandbox", () => runtime.previews.create(port, { visibility: this.public ? "public" : "private" }));
+        return {
+            sandboxId: this.id,
+            port,
+            url: preview.url.replace(/\/$/, ""),
+            token: preview.token ?? "",
+        };
+    }
+    getUserHomeDir() {
+        return Promise.resolve(HOME);
+    }
+    getUserRootDir() {
+        return Promise.resolve(HOME);
+    }
+    getWorkDir() {
+        return Promise.resolve(HOME);
+    }
+    // ---- forks and snapshots --------------------------------------------------
+    /** A copy of this sandbox with its files, memory and running processes. */
+    async fork(params = {}, _timeout) {
+        const copy = await guard("sandbox", () => this.#rt.fork({ ...(params.name ? { name: params.name } : {}) }));
+        return new Sandbox(copy, this.#client, {
+            ...this.#options,
+            env: this.env,
+            lifecycle: { ...this.#options.lifecycle },
+        });
+    }
+    _experimental_fork(params = {}, timeout) {
+        return this.fork(params, timeout);
+    }
+    /** Keeps this sandbox (files, memory, processes) as a Runtime snapshot
+     * named `name`; `daytona.create({ snapshot: name })` starts from it. */
+    async createSnapshot(name, _timeout) {
+        await guard("sandbox", () => this.#rt.snapshot({ name }));
+    }
+    _experimental_createSnapshot(name, timeout) {
+        return this.createSnapshot(name, timeout);
+    }
+    // ---- what Runtime does differently -----------------------------------------
+    get computerUse() {
+        throw new NotSupportedError("Daytona's computer use", "Use Runtime's desktop: `await sandbox.withruntime.desktop.start()` (see the desktop guide).");
+    }
+    setLabels() {
+        return refusal("Changing a sandbox's labels", "Runtime sets labels once, at create: pass labels to daytona.create.");
+    }
+    recover() {
+        return refusal("Recovering a failed sandbox", "Create a new sandbox, or start one from a snapshot.");
+    }
+    resize() {
+        return refusal("Resizing a sandbox", "Create a new one with the resources you need; fork() or createSnapshot() carries the state.");
+    }
+    waitForResizeComplete() {
+        return this.resize();
+    }
+    getMetrics() {
+        return refusal("Sandbox metrics", "Runtime reports CPU, memory and charges per sandbox in `npx withruntime usage` and runtime.usage().");
+    }
+    getMetricsLatest() {
+        return this.getMetrics();
+    }
+    createLspServer() {
+        throw new NotSupportedError("Daytona's language servers", "Start one in a session: process.executeSessionCommand(id, { command: 'pyright-langserver --stdio', runAsync: true }).");
+    }
+    updateSecrets() {
+        return refusal("Daytona secrets", "Pass credentials as envVars or per command, never in the command text.");
+    }
+    getSignedPreviewUrl() {
+        return refusal("Signed preview URLs", "Use getPreviewLink(port) and send its token as the x-runtime-preview-token header, or create the sandbox with public: true.");
+    }
+    expireSignedPreviewUrl() {
+        return this.getSignedPreviewUrl();
+    }
+    rotateSigningKey() {
+        return refusal("Rotating the preview signing key", "Use `await sandbox.withruntime.previews.rotate(port)`, which refuses every token issued for that port.");
+    }
+    uploadUrl() {
+        return refusal("Signed upload URLs", "Use sandbox.fs.uploadFile(data, path).");
+    }
+    downloadUrl() {
+        return refusal("Signed download URLs", "Use sandbox.fs.downloadFile(path).");
+    }
+    createSshAccess() {
+        return refusal("SSH access", "Use `npx withruntime sandbox shell <id>` or sandbox.withruntime.terminal().");
+    }
+    revokeSshAccess() {
+        return this.createSshAccess();
+    }
+    validateSshAccess() {
+        return this.createSshAccess();
+    }
+}
+/** Daytona's autoStopInterval (minutes; 0 is off) as the lease window. */
+export function windowSeconds(autoStopMinutes) {
+    if (autoStopMinutes <= 0)
+        return 3600;
+    return Math.min(3600, Math.max(60, Math.round(autoStopMinutes * 60)));
+}
+/** Minutes as Runtime's retention: whole days, 1 to 365. */
+export function retentionDays(minutes) {
+    return Math.min(365, Math.max(1, Math.ceil(minutes / 1440)));
+}
+/** Daytona's network settings as Runtime's rules, or undefined for the
+ * default (the public web). */
+export function networkRules(settings) {
+    if (settings.networkBlockAll)
+        return { internet: false };
+    const allow = [settings.networkAllowList, settings.domainAllowList]
+        .flatMap((list) => (list ?? "").split(","))
+        .map((one) => one.trim())
+        .filter(Boolean);
+    return allow.length ? { internet: true, allow } : undefined;
+}
+export function notFound(what) {
+    return new DaytonaNotFoundError(`${what} was not found.`, 404);
+}

package/dist/e2b/sandbox.d.ts

@@ -165,8 +165,13 @@ export declare class Sandbox {
     getPublicHost(port: number): Promise<string>;
     get pty(): never;
     get git(): never;
-    getMetrics(): Promise<never>;
-    static getMetrics(): Promise<never>;
+    /** E2B's metrics, from Runtime's measured readings (`sbx.metrics()`): CPU
+     * as a percent of the sandbox's vCPUs and resident memory, one entry per
+     * host reading (every minute by default) between `start` and `end`, kept
+     * 24 hours at that resolution. Disk use inside the sandbox is not measured:
+     * `diskUsed` is null and `diskTotal` is the disk's size. */
+    getMetrics(opts?: MetricsOpts): Promise<E2BSandboxMetrics[]>;
+    static getMetrics(sandboxId: string, opts?: MetricsOpts & SandboxApiOpts): Promise<E2BSandboxMetrics[]>;
     updateNetwork(): Promise<never>;
     uploadUrl(): Promise<never>;
     downloadUrl(): Promise<never>;
@@ -181,3 +186,18 @@ export declare class SandboxPaginator {
     get nextToken(): string | undefined;
     nextItems(): Promise<SandboxInfo[]>;
 }
+type MetricsOpts = {
+    start?: Date | number;
+    end?: Date | number;
+};
+export type E2BSandboxMetrics = {
+    timestamp: Date;
+    cpuUsedPct: number;
+    cpuCount: number;
+    memUsed: number;
+    memTotal: number;
+    /** Not measured by Runtime: null. */
+    diskUsed: number | null;
+    diskTotal: number;
+};
+export {};