withruntime 0.9.0 → 0.11.0

package/dist/daytona/sandbox.js

@@ -1,4 +1,5 @@
-import { RuntimeError } from "../errors.js";
+import { LeaseKeeper } from "../compat/lease.js";
+import { ComputerUse } from "./computer-use.js";
 import { HOME, HOME_LINK } from "./context.js";
 import { DaytonaError, DaytonaNotFoundError, guard, NotSupportedError } from "./errors.js";
 import { FileSystem } from "./filesystem.js";
@@ -22,11 +23,18 @@ export class CodeInterpreter {
         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;
-        })();
+        if (!this.#envContext) {
+            const pending = (async () => {
+                const runtime = await this.#sandbox();
+                const made = await guard("sandbox", () => runtime.interpreter.contexts.create({ language: "python", cwd: HOME, env }));
+                return made.id;
+            })();
+            this.#envContext = pending;
+            pending.catch(() => {
+                if (this.#envContext === pending)
+                    this.#envContext = undefined;
+            });
+        }
         return this.#envContext;
     }
     async runCode(code, options = {}) {
@@ -89,6 +97,10 @@ export class Sandbox {
     #options;
     #home;
     #pausedByPause = false;
+    #computerUse;
+    /** When this client last made a call: autoStopInterval counts from it. */
+    #lastActive = Date.now();
+    #keeper;
     /** Use daytona.create or daytona.get. */
     constructor(runtime, client, options) {
         this.#rt = runtime;
@@ -97,9 +109,20 @@ export class Sandbox {
         this.env = { ...options.env };
         this.public = options.public;
         this.snapshot = options.snapshot;
+        this.#keeper = new LeaseKeeper({
+            sandbox: () => this.#rt,
+            until: () => {
+                const lifecycle = this.#options.lifecycle;
+                return Math.min(this.#lastActive + (lifecycle.idleSeconds ?? lifecycle.windowSeconds) * 1000, lifecycle.deadline ?? Infinity);
+            },
+            // Renewed when less than half the window is left, so a run of calls
+            // costs one extend per half window.
+            marginMs: () => this.#options.lifecycle.windowSeconds * 500,
+        });
         const ctx = {
             live: () => this.#live(),
             language: options.language,
+            ...(options.user ? { user: options.user } : {}),
             ensureHome: (text) => this.#ensureHome(text),
         };
         // A getter, so the modules see the environment updateEnv sets.
@@ -124,9 +147,10 @@ export class Sandbox {
         return "";
     }
     /** Daytona's user name, so `/home/${sandbox.user}` leads to the working
-     * directory. Commands run as Runtime's sandbox owner, with passwordless sudo. */
+     * directory, and commands run as Runtime's sandbox owner, with passwordless
+     * sudo; or the user given at create, whose commands run through sudo. */
     get user() {
-        return "daytona";
+        return this.#options.user ?? "daytona";
     }
     get labels() {
         return { ...this.#rt.info.labels };
@@ -188,29 +212,13 @@ export class Sandbox {
     }
     /** 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. */
+     * Daytona's API calls do. An autoStopInterval past an hour, or 0, is kept
+     * by renewing the lease while this object lives. */
     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);
-        }
+        this.#lastActive = Date.now();
+        await this.#keeper.check(force);
         return this.#rt;
     }
     #ensureHome(text) {
@@ -241,6 +249,7 @@ export class Sandbox {
         if (state === "stopped" || state === "stopping")
             return;
         if (this.#options.lifecycle.ephemeral) {
+            this.#keeper.end();
             await guard("sandbox", () => this.#rt.stop());
             return;
         }
@@ -262,6 +271,7 @@ export class Sandbox {
     }
     /** Ends the sandbox for good. */
     async delete(_timeout) {
+        this.#keeper.end();
         await guard("sandbox", () => this.#rt.refresh());
         if (this.#rt.state !== "stopped")
             await guard("sandbox", () => this.#rt.stop({ wait: false }));
@@ -282,11 +292,12 @@ export class Sandbox {
         await guard("sandbox", () => this.#live(true));
     }
     /** The sandbox pauses after `interval` minutes without a call from this
-     * client (1 to 60; 0 is 60). */
+     * client; 0 never. Past an hour, while this object lives. */
     async setAutostopInterval(interval) {
         const lifecycle = this.#options.lifecycle;
         lifecycle.autoStopInterval = interval;
         lifecycle.windowSeconds = windowSeconds(interval);
+        lifecycle.idleSeconds = idleSeconds(interval);
         await guard("sandbox", () => this.#live());
     }
     setAutoPauseInterval(interval) {
@@ -370,11 +381,16 @@ export class Sandbox {
         return this.createSnapshot(name, timeout);
     }
     // ---- what Runtime does differently -----------------------------------------
+    /** Daytona's computer use over Runtime's desktop: `await
+     * sandbox.computerUse.start()`, then the mouse, keyboard and screenshots. */
     get computerUse() {
-        throw new NotSupportedError("Daytona's computer use", "Use Runtime's desktop: `await sandbox.withruntime.desktop.start()` (see the desktop guide).");
+        this.#computerUse ??= new ComputerUse(() => this.#live());
+        return this.#computerUse;
     }
-    setLabels() {
-        return refusal("Changing a sandbox's labels", "Runtime sets labels once, at create: pass labels to daytona.create.");
+    async setLabels(labels) {
+        const internal = Object.fromEntries(Object.entries(this.#rt.info.labels).filter(([key]) => key === "code-toolbox-language" || key.startsWith("compat.")));
+        await guard("sandbox", () => this.#rt.update({ labels: { ...labels, ...internal } }));
+        return this.labels;
     }
     recover() {
         return refusal("Recovering a failed sandbox", "Create a new sandbox, or start one from a snapshot.");
@@ -428,6 +444,13 @@ export function windowSeconds(autoStopMinutes) {
         return 3600;
     return Math.min(3600, Math.max(60, Math.round(autoStopMinutes * 60)));
 }
+/** Daytona's autoStopInterval (minutes; 0 is never) as seconds without a
+ * call before the sandbox pauses. */
+export function idleSeconds(autoStopMinutes) {
+    if (autoStopMinutes <= 0)
+        return Infinity;
+    return 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)));

package/dist/e2b/client.d.ts

@@ -3,6 +3,8 @@ import { Runtime } from "../client.js";
 export type RuntimeSandbox = Awaited<ReturnType<Runtime["sandboxes"]["create"]>>;
 /** What `Sandbox.create` sends to Runtime. */
 export type RuntimeCreate = NonNullable<Parameters<Runtime["sandboxes"]["create"]>[0]>;
+/** E2B's HTTP version for its API and sandboxes (e2b 2.52.0). */
+export type HttpVersion = "1.1" | "2";
 /** E2B's connection options, as far as they mean anything on Runtime. */
 export interface ConnectionOpts {
     /** A Runtime key. Default: RUNTIME_API_KEY, then E2B_API_KEY if it holds a
@@ -18,6 +20,9 @@ export interface ConnectionOpts {
     retries?: number;
     /** Accepted and ignored: Runtime's SDK does not take a logger. */
     logger?: unknown;
+    /** Checked as E2B checks it (and E2B_HTTP_VERSION), then left to Runtime's
+     * SDK, which picks its own transport. */
+    httpVersion?: HttpVersion;
     /** E2B endpoints. Refused: this package only talks to Runtime. */
     domain?: string;
     apiUrl?: string;

package/dist/e2b/client.js

@@ -1,5 +1,5 @@
 import { Runtime } from "../client.js";
-import { AuthenticationError, NotSupportedError } from "./errors.js";
+import { AuthenticationError, InvalidArgumentError, NotSupportedError } from "./errors.js";
 const env = (name) => typeof process === "undefined" ? undefined : process.env[name];
 const isE2BKey = (key) => key.startsWith("e2b_");
 /** Refuses the E2B-only connection options: they point at E2B, and quietly
@@ -18,6 +18,10 @@ export function refuseE2BConnection(opts = {}) {
                 ? "Set HTTPS_PROXY in the environment instead; Runtime's SDK reads it."
                 : "Remove it: this package talks only to Runtime (RUNTIME_API_URL overrides the API origin).");
     }
+    // E2B refuses any other version, from the option or the environment.
+    const version = opts.httpVersion ?? (env("E2B_HTTP_VERSION") || undefined);
+    if (version !== undefined && version !== "1.1" && version !== "2")
+        throw new InvalidArgumentError(`${opts.httpVersion === undefined ? "E2B_HTTP_VERSION" : "httpVersion"} must be '1.1' or '2', got '${version}'`);
     if (opts.debug)
         throw new NotSupportedError("E2B's debug mode (a local envd)", "Remove debug: true; there is no local Runtime guest to connect to.");
 }
@@ -60,7 +64,7 @@ export function resetClients() {
 /** Request options for a Runtime call from E2B's. */
 export function request(opts = {}) {
     return {
-        ...(opts.requestTimeoutMs ? { timeoutMs: opts.requestTimeoutMs } : {}),
+        ...(opts.requestTimeoutMs === undefined ? {} : { timeoutMs: opts.requestTimeoutMs }),
         ...(opts.signal ? { signal: opts.signal } : {}),
     };
 }

package/dist/e2b/commands.d.ts

@@ -1,6 +1,8 @@
 import type { Process } from "../sandbox.js";
+import type { OutputEvent, ProcessInfo as RuntimeProcessInfo } from "../types.js";
+import type { RequestOptions } from "../transport.js";
 import type { RuntimeSandbox } from "./client.js";
-import { type CommandResult } from "./errors.js";
+import { TimeoutError, type CommandResult } from "./errors.js";
 export type { CommandResult };
 export type Username = "user" | "root" | (string & {});
 export interface CommandRequestOpts {
@@ -10,9 +12,9 @@ export interface CommandRequestOpts {
 export interface CommandStartOpts extends CommandRequestOpts {
     background?: boolean;
     cwd?: string;
-    /** Only the default user. Runtime runs commands as `runtime`, the sandbox's
-     * owner, with passwordless sudo; E2B's `root` is refused rather than
-     * silently run as someone else. */
+    /** "user" (the default) is the sandbox's own user, `runtime`; any other
+     * user that exists in the sandbox, `root` included, runs it through
+     * `sudo -u`. An unknown user is refused, never created. */
     user?: Username;
     envs?: Record<string, string>;
     onStdout?: (data: string) => void | Promise<void>;
@@ -37,13 +39,28 @@ export interface ProcessInfo {
  * keep: it is the sandbox's own `env`, added to every command there. */
 export interface SandboxContext {
     readonly runtime: RuntimeSandbox;
+    readonly requestTimeoutMs?: number;
     /** Makes /home/user (E2B's home) lead to /workspace (Runtime's), once, when
      * something names it. */
-    ensureHome(text: string | undefined): Promise<void>;
+    ensureHome(text: string | undefined, options?: RequestOptions): Promise<void>;
 }
 /** E2B's pids are numbers; Runtime's process ids are strings. The number is a
  * 31-bit FNV-1a hash of the id, so every client derives the same one. */
 export declare function pidOf(processId: string): number;
+export declare function timeoutFor(timeoutMs: number | undefined): number;
+/** One budget for lookup and mutation, including retries and queued input. */
+export declare function commandRequest(opts: CommandRequestOpts, defaultTimeoutMs?: number): RequestOptions;
+export declare function findProcess(ctx: SandboxContext, pid: number, options: RequestOptions): Promise<RuntimeProcessInfo | undefined>;
+export declare function resolveProcess(ctx: SandboxContext, pid: number, options: RequestOptions): Promise<Process>;
+export declare function killProcess(ctx: SandboxContext, pid: number, options: RequestOptions): Promise<boolean>;
+export declare function timedOut(timeoutMs: number): TimeoutError;
+/** The subscription deadline includes the opening handshake. */
+export declare function connectionRequest(opts: CommandConnectOpts, defaultTimeoutMs?: number): {
+    timeoutMs: number;
+    deadline: number | undefined;
+    request: RequestOptions;
+    failure: (error: unknown) => never;
+};
 /** `sandbox.commands`: E2B's command module over Runtime's exec and processes. */
 export declare class Commands {
     #private;
@@ -61,28 +78,42 @@ export declare class Commands {
         background?: boolean;
     }): Promise<CommandHandle | CommandResult>;
     /** Running commands. */
-    list(_opts?: CommandRequestOpts): Promise<ProcessInfo[]>;
+    list(opts?: CommandRequestOpts): Promise<ProcessInfo[]>;
     /** Kills a command with SIGKILL, as E2B does. False when there is none. */
-    kill(pid: number, _opts?: CommandRequestOpts): Promise<boolean>;
+    kill(pid: number, opts?: CommandRequestOpts): Promise<boolean>;
     /** Sends input to a command started with `stdin: true`. */
-    sendStdin(pid: number, data: string | Uint8Array, _opts?: CommandRequestOpts): Promise<void>;
-    closeStdin(pid: number, _opts?: CommandRequestOpts): Promise<void>;
+    sendStdin(pid: number, data: string | Uint8Array, opts?: CommandRequestOpts): Promise<void>;
+    closeStdin(pid: number, opts?: CommandRequestOpts): Promise<void>;
     /** Attaches to a running command; output from now on reaches the handle. */
     connect(pid: number, opts?: CommandConnectOpts): Promise<CommandHandle>;
 }
+/** A command whose output this handle reads from the request that started
+ * it: its process id, the rest of its events, the controller that ends the
+ * read, and the Runtime process, fetched only when something needs it. */
+export interface StartedStream {
+    started: true;
+    id: string;
+    events: AsyncIterator<OutputEvent>;
+    abort: AbortController;
+    process: () => Promise<Process>;
+}
 /** A command started in the background: E2B's CommandHandle over a Runtime
  * process. Output streams into `stdout`/`stderr` and the callbacks as it
  * arrives. */
 export declare class CommandHandle {
     #private;
     readonly pid: number;
-    constructor(process: Process, options: {
+    constructor(source: Process | StartedStream, options: {
         stdin: boolean;
         timeoutMs: number;
         cursor?: number;
         signal?: AbortSignal;
         onStdout?: (data: string) => void | Promise<void>;
         onStderr?: (data: string) => void | Promise<void>;
+        onData?: (data: Uint8Array) => void | Promise<void>;
+        pty?: boolean;
+        requestTimeoutMs?: number;
+        deadline?: number;
     });
     /** The exit code, or undefined while the command runs. */
     get exitCode(): number | undefined;
@@ -96,6 +127,6 @@ export declare class CommandHandle {
     disconnect(): Promise<void>;
     /** Kills the command with SIGKILL. False when it had already ended. */
     kill(): Promise<boolean>;
-    sendStdin(data: string | Uint8Array, _opts?: CommandRequestOpts): Promise<void>;
-    closeStdin(_opts?: CommandRequestOpts): Promise<void>;
+    sendStdin(data: string | Uint8Array, opts?: CommandRequestOpts): Promise<void>;
+    closeStdin(opts?: CommandRequestOpts): Promise<void>;
 }