withruntime 0.11.0 → 0.11.2

package/dist/e2b/filesystem.js

@@ -20,17 +20,51 @@ const HOME = "/workspace";
 function absolute(path) {
     return path.startsWith("/") ? path : `${HOME}/${path.replace(/^\.\//, "")}`;
 }
+/** E2B's home, which E2B code expects in the paths it gets back. */
+const E2B_HOME = "/home/user";
+/** A path as E2B gives it back: one the caller asked for relative to the home
+ * is shown under /home/user, as E2B shows it, when /home/user leads to
+ * /workspace (`linked`), so it names the same file. A path the caller gave in
+ * full comes back as given. */
+function shown(path, asked, linked) {
+    if (asked.startsWith("/") || !linked)
+        return path;
+    if (path === HOME)
+        return E2B_HOME;
+    return path.startsWith(`${HOME}/`) ? E2B_HOME + path.slice(HOME.length) : path;
+}
 function refuse(opts) {
     if (opts.metadata && Object.keys(opts.metadata).length)
         throw new NotSupportedError("File metadata (user.e2b.* extended attributes)", "Keep the metadata beside the file, for example in a JSON file.");
 }
 const PERMISSIONS = ["---", "--x", "-w-", "-wx", "r--", "r-x", "rw-", "rwx"];
-function entryInfo(entry) {
+/** The first letter of envd's permissions, Go's FileMode string. */
+const KIND_LETTER = { directory: "d", symlink: "L" };
+/** The sandbox user as E2B names it: Runtime's is `runtime`, E2B's `user`. */
+function e2bUser(name) {
+    return name === "runtime" ? "user" : (name ?? "");
+}
+/** A link's target as envd gives it: absolute, a relative one taken from the
+ * link's own directory. */
+function linkTarget(path, target) {
+    if (target.startsWith("/"))
+        return target;
+    const parts = path.split("/").slice(0, -1);
+    for (const part of target.split("/")) {
+        if (part === "..")
+            parts.pop();
+        else if (part && part !== ".")
+            parts.push(part);
+    }
+    return `/${parts.filter(Boolean).join("/")}`;
+}
+function entryInfo(entry, asked, linked) {
     const mode = parseInt(entry.mode, 8) || 0;
     const bits = mode & 0o777;
+    const path = shown(entry.path, asked, linked);
     return {
         name: entry.name,
-        path: entry.path,
+        path,
         ...(entry.type === "file"
             ? { type: FileType.FILE }
             : entry.type === "directory"
@@ -40,10 +74,15 @@ function entryInfo(entry) {
                     : {}),
         size: entry.size,
         mode,
-        permissions: PERMISSIONS[(bits >> 6) & 7] + PERMISSIONS[(bits >> 3) & 7] + PERMISSIONS[bits & 7],
-        owner: entry.owner ?? "",
-        group: entry.group ?? "",
-        ...(entry.symlinkTarget ? { symlinkTarget: entry.symlinkTarget } : {}),
+        permissions: (KIND_LETTER[entry.type] ?? "-") +
+            PERMISSIONS[(bits >> 6) & 7] +
+            PERMISSIONS[(bits >> 3) & 7] +
+            PERMISSIONS[bits & 7],
+        owner: e2bUser(entry.owner),
+        group: e2bUser(entry.group),
+        ...(entry.symlinkTarget
+            ? { symlinkTarget: shown(linkTarget(entry.path, entry.symlinkTarget), asked, linked) }
+            : {}),
         modifiedTime: new Date(entry.modifiedAt),
     };
 }
@@ -63,7 +102,7 @@ async function bytesOf(data) {
 const basename = (path) => path.split("/").filter(Boolean).pop() ?? path;
 /** `sandbox.files`: E2B's filesystem module over Runtime's files API. Relative
  * paths resolve against the home directory, as in E2B (Runtime's is
- * /workspace). */
+ * /workspace), and come back under /home/user, as E2B gives them. */
 export class Filesystem {
     #ctx;
     constructor(ctx) {
@@ -79,6 +118,11 @@ export class Filesystem {
         opts.signal?.throwIfAborted();
         return absolute(path);
     }
+    /** Whether a path asked relative to the home may be shown under /home/user.
+     * Asked at the start of a call, it is learned beside the call itself. */
+    #linked(path) {
+        return path.startsWith("/") ? Promise.resolve(false) : this.#ctx.homeIsWorkspace();
+    }
     /** The calls as another Linux user, or undefined for the sandbox's own. */
     async #as(opts) {
         if (opts.user === undefined || opts.user === "user")
@@ -121,22 +165,27 @@ export class Filesystem {
     }
     async #writeOne(path, data, opts) {
         const file = await this.#path(path, opts);
+        const linked = this.#linked(path);
         const as = await this.#as(opts);
         const bytes = await bytesOf(data);
         if (as)
             await as.write(file, bytes);
         else
             await guard("file", () => this.#files.write(file, bytes, request(opts)));
-        return { name: basename(file), type: FileType.FILE, path: file };
+        return { name: basename(file), type: FileType.FILE, path: shown(file, path, await linked) };
     }
     /** A directory's entries, hidden ones included; `depth` goes deeper. */
     async list(path, opts = {}) {
+        if (opts.depth !== undefined && opts.depth < 1)
+            throw new InvalidArgumentError("depth should be at least one");
         const dir = await this.#path(path, opts);
+        const linked = this.#linked(path);
         const as = await this.#as(opts);
-        if (as)
-            return (await as.list(dir, opts.depth ?? 1)).map(entryInfo);
-        const entries = await guard("file", () => this.#files.list(dir, { depth: opts.depth ?? 1, hidden: true, ...request(opts) }));
-        return entries.map(entryInfo);
+        const entries = as
+            ? await as.list(dir, opts.depth ?? 1)
+            : await guard("file", () => this.#files.list(dir, { depth: opts.depth ?? 1, hidden: true, ...request(opts) }));
+        const home = await linked;
+        return entries.map((entry) => entryInfo(entry, path, home));
     }
     /** Makes a directory and its parents. False when it already existed. */
     async makeDir(path, opts = {}) {
@@ -158,7 +207,7 @@ export class Filesystem {
             await as.rename(from, to);
         else
             await guard("file", () => this.#files.rename(from, to, { overwrite: true, ...request(opts) }));
-        return this.getInfo(to, opts);
+        return this.getInfo(newPath, opts);
     }
     /** Removes a file, or a directory with everything in it. */
     async remove(path, opts = {}) {
@@ -177,13 +226,14 @@ export class Filesystem {
     }
     async getInfo(path, opts = {}) {
         const target = await this.#path(path, opts);
+        const linked = this.#linked(path);
         const as = await this.#as(opts);
         if (as)
-            return entryInfo(await as.stat(target));
+            return entryInfo(await as.stat(target), path, await linked);
         const stat = await guard("file", () => this.#files.stat(target, request(opts)));
         if (!stat.exists)
             throw new FileNotFoundError(`${target} does not exist.`);
-        return entryInfo(stat);
+        return entryInfo(stat, path, await linked);
     }
     /** E2B's watchDir on Runtime's file watch. A local deadline preserves
      * subsecond subscriptions; 0 runs until stopped or the sandbox ends. */
@@ -197,6 +247,10 @@ export class Filesystem {
         if (!Number.isFinite(lifetime) || lifetime < 0)
             throw new InvalidArgumentError("timeoutMs must be a nonnegative finite number.");
         const target = await this.#path(path, opts);
+        // envd watches only a directory; Runtime's watch also takes a file.
+        const stat = await guard("file", () => this.#files.stat(target, request(opts)));
+        if (stat.exists && stat.type !== "directory")
+            throw new InvalidArgumentError(`${target} is not a directory; watchDir watches a directory.`);
         const prefix = target.endsWith("/") ? target : `${target}/`;
         let exited = false;
         let native;
@@ -277,12 +331,24 @@ export class Filesystem {
                             throw error;
                     }
                 }
+                const name = event.path.startsWith(prefix)
+                    ? event.path.slice(prefix.length)
+                    : event.path;
                 if (!exited)
                     await onEvent({
-                        name: event.path.startsWith(prefix) ? event.path.slice(prefix.length) : event.path,
+                        name,
                         type: event.type,
                         ...(entry ? { entry } : {}),
                     });
+                // Runtime writes a file whole, by a rename into place, which the
+                // watch sees as a create; envd writes in place, which is a write.
+                // Code written for E2B waits for the write (5 October 2026).
+                if (!exited && event.type === "create" && !event.isDir)
+                    await onEvent({
+                        name,
+                        type: FilesystemEventType.WRITE,
+                        ...(entry ? { entry } : {}),
+                    });
             }, {
                 recursive: opts.recursive === true,
                 timeoutMs: 0,

package/dist/e2b/index.d.ts

@@ -10,10 +10,10 @@ import { Sandbox } from "./sandbox.js";
 export { Sandbox, SandboxPaginator, DEFAULT_SHAPE, DEFAULT_TIMEOUT_MS, type SandboxOpts, type SandboxConnectOpts, type SandboxApiOpts, type SandboxInfo, type SandboxListOpts, type SandboxState, type SandboxLifecycle, type SandboxOnTimeout, type SnapshotInfo, } from "./sandbox.js";
 export { Commands, CommandHandle, pidOf, type CommandStartOpts, type CommandConnectOpts, type CommandRequestOpts, type ProcessInfo, type Username, } from "./commands.js";
 export { Filesystem, FileType, type EntryInfo, type WriteInfo, type WriteEntry, type FilesystemRequestOpts, type FilesystemReadOpts, type FilesystemWriteOpts, type FilesystemListOpts, FilesystemEventType, type FilesystemEvent, type WatchOpts, type E2BWatchHandle as WatchHandle, } from "./filesystem.js";
-export { SandboxError, TimeoutError, InvalidArgumentError, NotEnoughSpaceError, NotFoundError, FileNotFoundError, SandboxNotFoundError, TemplateError, RateLimitError, AuthenticationError, ServiceBusyError, CommandExitError, NotSupportedError, PublicPreviewNotAllowedError, type CommandResult, } from "./errors.js";
+export { SandboxError, TimeoutError, InvalidArgumentError, NotEnoughSpaceError, NotFoundError, FileNotFoundError, SandboxNotFoundError, TemplateError, RateLimitError, AuthenticationError, ServiceBusyError, CommandExitError, NotSupportedError, PublicPreviewNotAllowedError, GitAuthError, GitUpstreamError, BuildError, FileUploadError, VolumeError, VolumeNotFoundError, VolumePathNotFoundError, SecretError, SecretNotFoundError, type CommandResult, } from "./errors.js";
 export type { ConnectionOpts, HttpVersion, RuntimeOpts } from "./client.js";
 export { Pty, type PtyCreateOpts, type PtyConnectOpts } from "./pty.js";
-export { Template, TemplateBase, Volume, Secret, waitForPort, waitForURL, waitForProcess, waitForFile, waitForTimeout, } from "./unsupported.js";
+export { Template, TemplateBase, Volume, Secret, waitForPort, waitForURL, waitForProcess, waitForFile, waitForTimeout, SecretPaginator, Git, ReadyCmd, LogEntry, LogEntryStart, LogEntryEnd, defaultBuildLogger, ConnectionConfig, ApiClient, getSignature, ALL_TRAFFIC, VolumeFileType, } from "./unsupported.js";
 export default Sandbox;
 /** E2B's client with bound options: `new E2B({ apiKey }).Sandbox.create()`. */
 export declare class E2B {

package/dist/e2b/index.js

@@ -3,9 +3,9 @@ import { Sandbox } from "./sandbox.js";
 export { Sandbox, SandboxPaginator, DEFAULT_SHAPE, DEFAULT_TIMEOUT_MS, } from "./sandbox.js";
 export { Commands, CommandHandle, pidOf, } from "./commands.js";
 export { Filesystem, FileType, FilesystemEventType, } from "./filesystem.js";
-export { SandboxError, TimeoutError, InvalidArgumentError, NotEnoughSpaceError, NotFoundError, FileNotFoundError, SandboxNotFoundError, TemplateError, RateLimitError, AuthenticationError, ServiceBusyError, CommandExitError, NotSupportedError, PublicPreviewNotAllowedError, } from "./errors.js";
+export { SandboxError, TimeoutError, InvalidArgumentError, NotEnoughSpaceError, NotFoundError, FileNotFoundError, SandboxNotFoundError, TemplateError, RateLimitError, AuthenticationError, ServiceBusyError, CommandExitError, NotSupportedError, PublicPreviewNotAllowedError, GitAuthError, GitUpstreamError, BuildError, FileUploadError, VolumeError, VolumeNotFoundError, VolumePathNotFoundError, SecretError, SecretNotFoundError, } from "./errors.js";
 export { Pty } from "./pty.js";
-export { Template, TemplateBase, Volume, Secret, waitForPort, waitForURL, waitForProcess, waitForFile, waitForTimeout, } from "./unsupported.js";
+export { Template, TemplateBase, Volume, Secret, waitForPort, waitForURL, waitForProcess, waitForFile, waitForTimeout, SecretPaginator, Git, ReadyCmd, LogEntry, LogEntryStart, LogEntryEnd, defaultBuildLogger, ConnectionConfig, ApiClient, getSignature, ALL_TRAFFIC, VolumeFileType, } from "./unsupported.js";
 export default Sandbox;
 /** E2B's client with bound options: `new E2B({ apiKey }).Sandbox.create()`. */
 export class E2B {

package/dist/e2b/sandbox.d.ts

@@ -9,8 +9,14 @@ export declare const DEFAULT_SHAPE: {
     readonly vcpu: 2;
     readonly memoryMiB: 512;
 };
-/** E2B's default sandbox timeout, 300 s. */
+/** E2B's default sandbox timeout, 300 s. A sandbox created without timeoutMs
+ * gets it, and is paused when it runs out rather than killed, since nobody
+ * asked for it to end: nothing in it is lost, and the next call wakes it. On
+ * a pilot account the server keeps every sandbox running instead (0254). */
 export declare const DEFAULT_TIMEOUT_MS = 300000;
+/** The label that keeps the template a sandbox was made from, so getInfo
+ * and list name it whichever client asks; it is not shown in `metadata`. */
+export declare const TEMPLATE_LABEL = "e2b-template";
 export type SandboxState = "running" | "paused";
 export type SandboxOnTimeout = "pause" | "kill" | {
     action: "pause" | "kill";
@@ -30,7 +36,8 @@ export interface SandboxOpts extends ConnectionOpts {
     /** The sandbox's own environment: every command, terminal and code run in it
      * gets these, whoever connects. Values are never shown again. */
     envs?: Record<string, string>;
-    /** Default 300 000, at most 24 hours. Runtime's leases run 60 s to 1 hour:
+    /** When it ends, at most 24 hours. Leave it out for no time limit: it runs
+     * while it works and pauses when idle. Runtime's limits run 60 s to 1 hour:
      * shorter rounds up to 60 s (with a warning); longer gets an hour, moved on
      * while this process runs, up to the time asked for. */
     timeoutMs?: number;
@@ -89,10 +96,10 @@ export type SandboxListOpts = SandboxApiOpts & {
     limit?: number;
     nextToken?: string;
 };
-/** Test hook: renew every kept lease now, as the five-minute timer would. */
-export declare function renewLeases(): Promise<void>;
-/** Test hook: the end each kept sandbox is kept until. */
-export declare function keptLeases(): Map<string, number>;
+/** The Runtime image name an E2B template name stands for: E2B's
+ * `team/name:tag` without the team, since a Runtime account's images are its
+ * own. `name`, `name:tag` and `name@version` are Runtime image names too. */
+export declare function imageNameFor(template: string): string;
 export declare class Sandbox {
     #private;
     protected readonly requestTimeoutMs: number;
@@ -109,8 +116,7 @@ export declare class Sandbox {
     protected get client(): Runtime;
     /** Creates a sandbox from `template` (default "base", Runtime's stock image)
      * with E2B's default machine, 2 vCPU and 512 MiB, and waits until it runs.
-     * Funding is left to Runtime: the free trial while the account has trial
-     * time, then prepaid credit, exactly as withruntime's own create. */
+     * Funding is left to Runtime: the included usage first, then prepaid credit, exactly as withruntime's own create. */
     static create<S extends typeof Sandbox>(this: S, opts?: SandboxOpts): Promise<InstanceType<S>>;
     static create<S extends typeof Sandbox>(this: S, template: string, opts?: SandboxOpts): Promise<InstanceType<S>>;
     /** Connects to a sandbox by id, waking it if it is paused, as E2B does. A
@@ -120,16 +126,23 @@ export declare class Sandbox {
     connect(opts?: SandboxConnectOpts): Promise<this>;
     /** Running and paused sandboxes, a page at a time, as E2B's paginator. */
     static list(opts?: SandboxListOpts): SandboxPaginator;
-    /** Stops the sandbox. False when it was not found or had already ended. */
+    /** Deletes the sandbox for good, as E2B's kill destroys it: its disk,
+     * memory and shared ports go. False when it was not found or was already
+     * deleted. */
     static kill(sandboxId: string, opts?: SandboxApiOpts): Promise<boolean>;
     kill(opts?: Pick<ConnectionOpts, "requestTimeoutMs" | "signal">): Promise<boolean>;
-    /** Sets the sandbox to end `timeoutMs` from now, up to 24 hours; past an
-     * hour the lease is moved on while this process runs. Runtime cannot end a
-     * lease early, so an end sooner than the lease's is refused. */
+    /** Sets the sandbox to end `timeoutMs` from now, up to 24 hours, as E2B
+     * does; the server keeps the deadline. Runtime cannot bring an end
+     * sooner, so that is refused. A sandbox with no time limit (one on a pilot
+     * account, kept running by the server) has no end to move, and nothing
+     * changes. */
     static setTimeout(sandboxId: string, timeoutMs: number, opts?: SandboxApiOpts): Promise<void>;
     setTimeout(timeoutMs: number, opts?: Pick<ConnectionOpts, "requestTimeoutMs" | "signal">): Promise<void>;
     static getInfo(sandboxId: string, opts?: SandboxApiOpts): Promise<SandboxInfo>;
     getInfo(opts?: Pick<ConnectionOpts, "requestTimeoutMs" | "signal">): Promise<SandboxInfo>;
+    /** Whether the sandbox answers calls, as E2B's health check says: true
+     * while it runs, and while Runtime has paused it for being idle, since the
+     * next call wakes it. False once paused on request, ended or deleted. */
     isRunning(opts?: Pick<ConnectionOpts, "requestTimeoutMs" | "signal">): Promise<boolean>;
     /** Pauses the sandbox, keeping memory and files. False when it was paused. */
     static pause(sandboxId: string, opts?: SandboxApiOpts & {