withruntime 0.8.3 → 0.9.0

package/dist/e2b/sandbox.js

@@ -131,22 +131,21 @@ function unsupported(feature, alternative) {
 /** Where Runtime serves previews; getHost names a host under it. */
 const PREVIEW_DOMAIN = "runtimehost.com";
 export class Sandbox {
+    requestTimeoutMs;
     static defaultTemplate = "base";
     files;
     commands;
     #client;
     #runtime;
-    #envs;
     #home;
     /** Ports shared as public previews, by port: the one share each asked for. */
     #shares = new Map();
     /** Use Sandbox.create or Sandbox.connect. */
-    constructor(runtime, client, envs = {}) {
+    constructor(runtime, client, requestTimeoutMs = 60_000) {
+        this.requestTimeoutMs = requestTimeoutMs;
         this.#runtime = runtime;
         this.#client = client;
-        this.#envs = envs;
         const ctx = {
-            envs,
             ensureHome: (text) => this.#ensureHome(text),
         };
         // A getter, so the modules see the sandbox as it is after each refresh.
@@ -165,9 +164,6 @@ export class Sandbox {
     get client() {
         return this.#client;
     }
-    get envs() {
-        return this.#envs;
-    }
     /** E2B's home is /home/user and Runtime's is /workspace. The first time a
      * path or command names /home/user, it is made a link to /workspace (unless
      * something is already there), so paths written for E2B work. */
@@ -195,6 +191,9 @@ export class Sandbox {
             // asked (autoResume); Runtime's automatic wake is the same thing (0093).
             ...(opts.lifecycle ? { autoWake: opts.lifecycle.autoResume === true } : {}),
             ...(opts.metadata && Object.keys(opts.metadata).length ? { labels: opts.metadata } : {}),
+            // Runtime keeps them with the sandbox: every command, terminal and
+            // interpreter in it gets them, from this client or any other.
+            ...(opts.envs && Object.keys(opts.envs).length ? { env: opts.envs } : {}),
             ...(opts.allowInternetAccess === false ? { network: { internet: false } } : {}),
         };
         const source = await guard("other", () => resolveTemplate(client, template));
@@ -206,7 +205,7 @@ export class Sandbox {
             ...opts.runtime?.create,
         };
         const runtime = await guard("sandbox", () => client.sandboxes.create(create, request(opts)));
-        return new this(runtime, client, { ...opts.envs });
+        return new this(runtime, client, opts.requestTimeoutMs);
     }
     /** Connects to a sandbox by id, waking it if it is paused, as E2B does. A
      * `timeoutMs` moves a running sandbox's end later, never earlier. */
@@ -214,7 +213,7 @@ export class Sandbox {
         const client = clientFor(opts);
         const runtime = await guard("sandbox", () => client.sandboxes.get(sandboxId, request(opts)));
         await resume(runtime, opts);
-        return new this(runtime, client);
+        return new this(runtime, client, opts.requestTimeoutMs);
     }
     /** Wakes this sandbox if it is paused. */
     async connect(opts = {}) {
@@ -309,8 +308,9 @@ export class Sandbox {
             // honoured after the forks exist, so this is refused before any are made.
             throw new NotSupportedError("A timeout for forks (fork timeoutMs)", "Fork without it, then call setTimeout(ms) on each fork.");
         const copies = await guard("sandbox", () => this.#runtime.fork({ count: opts.count ?? 1, ...request(opts) }));
+        // Copies keep the source's environment on Runtime's side.
         const Kind = this.constructor;
-        return copies.map((copy) => new Kind(copy, this.#client, { ...this.#envs }));
+        return copies.map((copy) => new Kind(copy, this.#client));
     }
     /** Keeps the sandbox's whole machine as a Runtime snapshot; start from it
      * with Sandbox.create(snapshotId). */

package/dist/errors.d.ts

@@ -1,3 +1,11 @@
+/** Every failure the SDK raises. `code` is stable and machine-readable,
+ * `hint` says what to do next, and `requestId` is what to quote in a report
+ * (runtime.feedback.submit, `runtime feedback`, or support). */
+/** A product switched off on this deployment, or paused on purpose: the API
+ * answers these 503s in fixed words (`serverFault` "off" in
+ * packages/cloud/src/api/respond.ts) and retrying cannot change them.
+ * host_unavailable and busy pass, and are retried. */
+export declare const DELIBERATE: ReadonlySet<string>;
 /** Refusals of a create that clear when a sandbox stops or pauses, or a host
  * frees room: the trial's slots, an email domain's trial slots, the account's
  * quota and the region's capacity. `sandboxes.create` waits them out, retrying

package/dist/errors.js

@@ -1,8 +1,21 @@
 /** Every failure the SDK raises. `code` is stable and machine-readable,
  * `hint` says what to do next, and `requestId` is what to quote in a report
  * (runtime.feedback.submit, `runtime feedback`, or support). */
-/** Switched off on purpose: retrying cannot change them. */
-const DELIBERATE = new Set(["fork_unavailable", "previews_unavailable", "unavailable"]);
+/** A product switched off on this deployment, or paused on purpose: the API
+ * answers these 503s in fixed words (`serverFault` "off" in
+ * packages/cloud/src/api/respond.ts) and retrying cannot change them.
+ * host_unavailable and busy pass, and are retried. */
+export const DELIBERATE = new Set([
+    "unavailable",
+    "unsupported",
+    "fork_unavailable",
+    "previews_unavailable",
+    "network_unavailable",
+    "network_rules_unavailable",
+    "secrets_unavailable",
+    "identity_unavailable",
+    "env_unavailable",
+]);
 /** Refusals that pass on their own: a host frees room, a trial slot frees. */
 const PASSING = new Set(["no_capacity", "trial_busy"]);
 /** Refusals of a create that clear when a sandbox stops or pauses, or a host

package/dist/freestyle/index.d.ts

@@ -0,0 +1,301 @@
+import type { Runtime } from "../client.js";
+import type { Sandbox } from "../sandbox.js";
+import { CompatibilityError, type ClientOptions } from "../compat/core.js";
+export { CompatibilityError };
+export type VmState = "starting" | "running" | "pausing" | "paused" | "stopped";
+export interface FirewallRule {
+    action: "allow";
+    source: Record<string, never>;
+    destination: {
+        public: true;
+    };
+}
+export interface CreateVmOptions {
+    snapshotId?: string | null;
+    slug?: string | null;
+    displayName?: string | null;
+    idleTimeoutSeconds?: number | null;
+    metadata?: Record<string, string>;
+    firewall: {
+        rules: FirewallRule[];
+    };
+}
+export interface ExecOptions {
+    command: string;
+    linuxUser?: string;
+    timeoutMs?: number;
+    env?: Record<string, string>;
+    stdin?: string;
+}
+export declare class Freestyle {
+    readonly vms: VmsNamespace;
+    constructor(options?: ClientOptions);
+}
+export declare class VmsNamespace {
+    private readonly runtime;
+    readonly snapshots: {
+        get: (id: string) => Promise<{
+            id: string;
+            sourceVmId: string;
+            slug: string | null;
+            public: boolean;
+            createdAt: string;
+            updatedAt: string;
+            ttlSeconds: number;
+        }>;
+        delete: (id: string) => Promise<void>;
+        list: () => Promise<{
+            snapshots: {
+                id: string;
+                sourceVmId: string;
+                slug: string | null;
+                public: boolean;
+                createdAt: string;
+                updatedAt: string;
+                ttlSeconds: number;
+            }[];
+        }>;
+    };
+    constructor(runtime: Runtime);
+    private resolveSnapshot;
+    create(options: CreateVmOptions): Promise<{
+        vm: Vm;
+        vmId: string;
+        data: {
+            id: string;
+            state: "paused" | "stopped" | "stopping" | "starting" | "running" | "pausing" | "resuming";
+            slug: string | null;
+            displayName: string | null;
+            resources: {
+                cpu: number;
+                memory: number;
+                storage: number;
+            };
+            metadata: {
+                [k: string]: string;
+            };
+            idleTimeoutSeconds: number | undefined;
+            vpcs: never[];
+            networks: never[];
+            createdAt: string;
+            updatedAt: string;
+        };
+        firewallRules: {
+            id: string;
+            source: {
+                vmId: string;
+            };
+            action: "allow";
+            destination: {
+                public: true;
+            };
+        }[];
+        tlsRules: never[];
+    }>;
+    ref(id: string): Vm;
+    get(id: string): Promise<{
+        id: string;
+        state: "paused" | "stopped" | "stopping" | "starting" | "running" | "pausing" | "resuming";
+        slug: string | null;
+        displayName: string | null;
+        resources: {
+            cpu: number;
+            memory: number;
+            storage: number;
+        };
+        metadata: {
+            [k: string]: string;
+        };
+        idleTimeoutSeconds: number | undefined;
+        vpcs: never[];
+        networks: never[];
+        createdAt: string;
+        updatedAt: string;
+    }>;
+    delete(id: string): Promise<void>;
+    list(options?: {
+        state?: string;
+        slug?: string;
+        metadata?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        vms: {
+            id: string;
+            state: "paused" | "stopped" | "stopping" | "starting" | "running" | "pausing" | "resuming";
+            slug: string | null;
+            displayName: string | null;
+            resources: {
+                cpu: number;
+                memory: number;
+                storage: number;
+            };
+            metadata: {
+                [k: string]: string;
+            };
+            idleTimeoutSeconds: number | undefined;
+            vpcs: never[];
+            networks: never[];
+            createdAt: string;
+            updatedAt: string;
+        }[];
+        totalCount: number;
+        runningCount: number;
+        startingCount: number;
+        pausingCount: number;
+        pausedCount: number;
+        stoppedCount: number;
+    }>;
+}
+export interface ReadFileOptions {
+    offset?: number;
+    length?: number;
+    signal?: AbortSignal;
+}
+export interface WriteFileOptions {
+    mode?: number;
+    signal?: AbortSignal;
+    chunkSize?: number;
+    maxAttempts?: number;
+    onProgress?: (progress: {
+        completedBytes: number;
+        totalBytes: number;
+    }) => void;
+}
+export declare class VmFilesystem {
+    private readonly get;
+    private readonly files;
+    constructor(get: () => Promise<Sandbox>);
+    readFile(path: string, options?: ReadFileOptions): Promise<Uint8Array<ArrayBuffer>>;
+    readTextFile(path: string, options?: ReadFileOptions): Promise<string>;
+    readFileStream(path: string, options?: ReadFileOptions): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
+    writeFile(path: string, content: string | Uint8Array | Blob, options?: WriteFileOptions): Promise<void>;
+    writeTextFile(path: string, content: string, options?: WriteFileOptions): Promise<void>;
+    mkdir(path: string): Promise<void>;
+    remove(path: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    readDir(path: string): Promise<{
+        name: string;
+        kind: "file" | "directory" | "symlink" | "other";
+    }[]>;
+    stat(path: string): Promise<{
+        size: number;
+        isFile: boolean;
+        isDirectory: boolean;
+        isSymlink: boolean;
+        permissions: string;
+        owner: string;
+        group: string;
+        modified: string;
+    }>;
+}
+export declare class Vm {
+    private readonly runtime;
+    readonly id: string;
+    readonly fs: VmFilesystem;
+    constructor(runtime: Runtime, id: string);
+    data(): Promise<{
+        id: string;
+        state: "paused" | "stopped" | "stopping" | "starting" | "running" | "pausing" | "resuming";
+        slug: string | null;
+        displayName: string | null;
+        resources: {
+            cpu: number;
+            memory: number;
+            storage: number;
+        };
+        metadata: {
+            [k: string]: string;
+        };
+        idleTimeoutSeconds: number | undefined;
+        vpcs: never[];
+        networks: never[];
+        createdAt: string;
+        updatedAt: string;
+    }>;
+    start(): Promise<{
+        id: string;
+        state: "paused" | "stopped" | "stopping" | "starting" | "running" | "pausing" | "resuming";
+        slug: string | null;
+        displayName: string | null;
+        resources: {
+            cpu: number;
+            memory: number;
+            storage: number;
+        };
+        metadata: {
+            [k: string]: string;
+        };
+        idleTimeoutSeconds: number | undefined;
+        vpcs: never[];
+        networks: never[];
+        createdAt: string;
+        updatedAt: string;
+    }>;
+    pause(): Promise<{
+        id: string;
+        state: "paused" | "stopped" | "stopping" | "starting" | "running" | "pausing" | "resuming";
+        slug: string | null;
+        displayName: string | null;
+        resources: {
+            cpu: number;
+            memory: number;
+            storage: number;
+        };
+        metadata: {
+            [k: string]: string;
+        };
+        idleTimeoutSeconds: number | undefined;
+        vpcs: never[];
+        networks: never[];
+        createdAt: string;
+        updatedAt: string;
+    }>;
+    delete(): Promise<void>;
+    update(options: {
+        slug?: string;
+        displayName?: string;
+        idleTimeoutSeconds?: number;
+        metadata?: Record<string, string>;
+    }): Promise<{
+        id: string;
+        state: "paused" | "stopped" | "stopping" | "starting" | "running" | "pausing" | "resuming";
+        slug: string | null;
+        displayName: string | null;
+        resources: {
+            cpu: number;
+            memory: number;
+            storage: number;
+        };
+        metadata: {
+            [k: string]: string;
+        };
+        idleTimeoutSeconds: number | undefined;
+        vpcs: never[];
+        networks: never[];
+        createdAt: string;
+        updatedAt: string;
+    }>;
+    exec(options: string | ExecOptions): Promise<{
+        stdout: string;
+        stderr: string;
+        statusCode: number | null;
+    }>;
+    snapshot(options?: {
+        slug?: string;
+        displayName?: string;
+        ttlSeconds?: number;
+    }): Promise<{
+        snapshotId: string;
+        sourceVmId: string;
+        snapshot: {
+            id: string;
+            sourceVmId: string;
+            slug: string | null;
+            public: boolean;
+            createdAt: string;
+            updatedAt: string;
+            ttlSeconds: number;
+        };
+    }>;
+}