withruntime 0.11.2 → 0.12.0

package/dist/compat/core.d.ts

@@ -13,6 +13,24 @@ export declare class CompatibilityError extends Error {
     readonly code = "unsupported_compatibility_option";
     constructor(provider: string, feature: string);
 }
+/** The error for a vendor feature an adapter does not provide, naming
+ * Runtime's alternative. */
+export declare function refusal(provider: string, feature: string, alternative: string): CompatibilityError;
+/** A vendor method an adapter does not provide: declare it on the class as
+ * `declare readonly name: Refused` (or `RefusedAsync` where the vendor's
+ * method returns a promise), and `refuse` installs it. A call fails with a
+ * CompatibilityError naming Runtime's alternative, never "is not a function". */
+export type Refused = (...args: unknown[]) => never;
+export type RefusedAsync = (...args: unknown[]) => Promise<never>;
+export declare function refuse(provider: string, owner: string, target: {
+    prototype: object;
+}, members: Record<string, string>, { sync }?: {
+    sync?: boolean;
+}): void;
+/** A vendor export (a function, or a class nobody can obtain here) that an
+ * adapter does not provide: `export const Name: Refused = refused(...)`.
+ * Calling it, or `new` on it, throws. */
+export declare function refused(provider: string, name: string, alternative: string): Refused;
 export declare function only(provider: string, value: object, keys: readonly string[]): void;
 export declare function region(provider: string, value?: string | null): string | undefined;
 export declare const quote: (value: string) => string;

package/dist/compat/core.js

@@ -27,6 +27,35 @@ export class CompatibilityError extends Error {
         this.name = "CompatibilityError";
     }
 }
+/** The error for a vendor feature an adapter does not provide, naming
+ * Runtime's alternative. */
+export function refusal(provider, feature, alternative) {
+    const error = new CompatibilityError(provider, feature);
+    error.message = `${error.message.slice(0, -1)}; ${alternative}.`;
+    return error;
+}
+export function refuse(provider, owner, target, members, { sync = false } = {}) {
+    for (const [member, alternative] of Object.entries(members)) {
+        const error = () => refusal(provider, `${owner}.${member}`, alternative);
+        Object.defineProperty(target.prototype, member, {
+            configurable: true,
+            writable: true,
+            value: sync
+                ? () => {
+                    throw error();
+                }
+                : () => Promise.reject(error()),
+        });
+    }
+}
+/** A vendor export (a function, or a class nobody can obtain here) that an
+ * adapter does not provide: `export const Name: Refused = refused(...)`.
+ * Calling it, or `new` on it, throws. */
+export function refused(provider, name, alternative) {
+    return function refusedExport() {
+        throw refusal(provider, name, alternative);
+    };
+}
 export function only(provider, value, keys) {
     for (const [key, item] of Object.entries(value))
         if (item !== undefined && item !== null && !keys.includes(key))

package/dist/compat/files.d.ts

@@ -1,6 +1,7 @@
 import type { Sandbox } from "../sandbox.js";
 /** Guest operations use argv, never interpolated shell paths. */
 export declare class GuestFiles {
+    #private;
     private readonly get;
     readonly cwd: string;
     constructor(get: () => Promise<Sandbox>, cwd?: string);

package/dist/compat/files.js

@@ -3,6 +3,9 @@ import { checked, missing, pathAt } from "./core.js";
 export class GuestFiles {
     get;
     cwd;
+    /** Staging copies whose removal failed; the next staged write or
+     * append tries them again. */
+    #leftover = new Set();
     constructor(get, cwd = "/workspace") {
         this.get = get;
         this.cwd = cwd;
@@ -10,6 +13,24 @@ export class GuestFiles {
     path(path) {
         return pathAt(path, this.cwd);
     }
+    /** Removes a staging copy, and remembers it for the next staged call if the
+     * removal fails. It never throws: the write's outcome, including its
+     * original failure, stands, and a successful destination write must not
+     * invite a replay. */
+    async #discard(sandbox, staging) {
+        try {
+            await sandbox.files.remove(staging);
+            this.#leftover.delete(staging);
+        }
+        catch {
+            this.#leftover.add(staging);
+        }
+    }
+    /** Tries again every staging copy an earlier call could not remove. */
+    async #sweep(sandbox) {
+        for (const staging of [...this.#leftover])
+            await this.#discard(sandbox, staging);
+    }
     async readFile(path) {
         return (await this.get()).files.read(this.path(path));
     }
@@ -24,6 +45,7 @@ export class GuestFiles {
             await sandbox.files.write(target, content, options);
             return;
         }
+        await this.#sweep(sandbox);
         const staging = `/workspace/.runtime-compat/write-${crypto.randomUUID()}`;
         try {
             await sandbox.files.write(staging, bytes, { mode: 0o600, signal: options.signal });
@@ -39,9 +61,7 @@ export class GuestFiles {
             ], { signal: options.signal });
         }
         finally {
-            // Cleanup must preserve the write's outcome, including its original
-            // failure; a successful destination write must not invite a replay.
-            await sandbox.files.remove(staging).catch(() => undefined);
+            await this.#discard(sandbox, staging);
         }
     }
     writeTextFile(path, content) {
@@ -117,6 +137,7 @@ export class GuestFiles {
             });
             return;
         }
+        await this.#sweep(sandbox);
         const staging = `/workspace/.runtime-compat/append-${crypto.randomUUID()}`;
         try {
             await sandbox.files.write(staging, bytes, { mode: 0o600 });
@@ -130,8 +151,7 @@ export class GuestFiles {
             ]);
         }
         finally {
-            // A cleanup failure after success must not invite appending twice.
-            await sandbox.files.remove(staging).catch(() => undefined);
+            await this.#discard(sandbox, staging);
         }
     }
 }

package/dist/daytona/computer-use.d.ts

@@ -73,10 +73,16 @@ export declare class Mouse {
     constructor(live: Live);
     getPosition(): Promise<Position>;
     move(x: number, y: number): Promise<Position>;
-    click(x: number, y: number, button?: string, double?: boolean): Promise<Position>;
-    drag(startX: number, startY: number, endX: number, endY: number, button?: string): Promise<Position>;
-    /** `amount` wheel clicks up or down at (x, y). */
-    scroll(x: number, y: number, direction: "up" | "down", amount?: number): Promise<boolean>;
+    /** Presses and holds `button`, first moving to (x, y) if both are given,
+     * until `up()`. */
+    down(x?: number, y?: number, button?: string): Promise<Position>;
+    /** Releases a held `button`, first moving to (x, y) if both are given. */
+    up(x?: number, y?: number, button?: string): Promise<Position>;
+    /** One click, or two with `double`; `clicks` (1 or 2 here) wins over `double`. */
+    click(x: number, y: number, button?: string, double?: boolean, clicks?: number, modifiers?: string[]): Promise<Position>;
+    drag(startX: number, startY: number, endX: number, endY: number, button?: string, modifiers?: string[]): Promise<Position>;
+    /** `amount` wheel clicks up, down, left or right at (x, y). */
+    scroll(x: number, y: number, direction: "up" | "down" | "left" | "right", amount?: number, modifiers?: string[]): Promise<boolean>;
 }
 /** `sandbox.computerUse.keyboard`. Key names are Daytona's (enter, esc,
  * ctrl, cmd, pageup, f5) or xdotool's (Return, Escape, Prior). */
@@ -89,6 +95,9 @@ export declare class Keyboard {
     press(key: string, modifiers?: string[]): Promise<void>;
     /** A combination such as "ctrl+c" or "ctrl+shift+t". */
     hotkey(keys: string): Promise<void>;
+    /** Runtime's desktop presses keys and lets go at once; it cannot hold one. */
+    down(_key: string): Promise<void>;
+    up(_key: string): Promise<void>;
 }
 /** `sandbox.computerUse.screenshot`: the whole screen, PNG or JPEG. */
 export declare class Screenshot {

package/dist/daytona/computer-use.js

@@ -21,12 +21,44 @@ export class Mouse {
         await guard("other", async () => (await desktop(this.#live)).move(x, y));
         return { x, y };
     }
-    async click(x, y, button = "left", double = false) {
-        await guard("other", async () => (await desktop(this.#live)).click(x, y, { button: buttonOf(button), double }));
+    /** Presses and holds `button`, first moving to (x, y) if both are given,
+     * until `up()`. */
+    down(x, y, button = "left") {
+        return this.#hold("mouseDown", x, y, button);
+    }
+    /** Releases a held `button`, first moving to (x, y) if both are given. */
+    up(x, y, button = "left") {
+        return this.#hold("mouseUp", x, y, button);
+    }
+    async #hold(action, x, y, button) {
+        const which = buttonOf(button);
+        return guard("other", async () => {
+            const screen = await desktop(this.#live);
+            const at = x !== undefined && y !== undefined;
+            if (at)
+                await screen.move(x, y);
+            await screen[action](which);
+            if (at)
+                return { x, y };
+            const where = await screen.cursor();
+            return { x: where.x, y: where.y };
+        });
+    }
+    /** One click, or two with `double`; `clicks` (1 or 2 here) wins over `double`. */
+    async click(x, y, button = "left", double = false, clicks, modifiers) {
+        const which = buttonOf(button);
+        held(modifiers, "click");
+        const count = clicks ?? (double ? 2 : 1);
+        if (!Number.isInteger(count) || count < 1 || count > 10)
+            throw new RangeError(`clicks is a whole number from 1 to 10, not ${JSON.stringify(clicks)}.`);
+        if (count > 2)
+            throw new NotSupportedError(`${count} clicks at once (clicks)`, "Click once or twice (double: true); to select a line, click once and press shift+End.");
+        await guard("other", async () => (await desktop(this.#live)).click(x, y, { button: which, double: count === 2 }));
         return { x, y };
     }
-    async drag(startX, startY, endX, endY, button = "left") {
+    async drag(startX, startY, endX, endY, button = "left", modifiers) {
         const which = buttonOf(button);
+        held(modifiers, "drag");
         await guard("other", async () => {
             const screen = await desktop(this.#live);
             if (which === "left")
@@ -38,11 +70,14 @@ export class Mouse {
         });
         return { x: endX, y: endY };
     }
-    /** `amount` wheel clicks up or down at (x, y). */
-    async scroll(x, y, direction, amount = 1) {
-        if (direction !== "up" && direction !== "down")
-            throw new RangeError(`direction is "up" or "down", not ${JSON.stringify(direction)}.`);
-        await guard("other", async () => (await desktop(this.#live)).scroll(direction === "down" ? amount : -amount, { x, y }));
+    /** `amount` wheel clicks up, down, left or right at (x, y). */
+    async scroll(x, y, direction, amount = 1, modifiers) {
+        const step = SCROLL[direction];
+        if (!step)
+            throw new RangeError(`direction is "up", "down", "left" or "right", not ${JSON.stringify(direction)}.`);
+        held(modifiers, "scroll");
+        const [dy, dx] = [step[0] * amount, step[1] * amount];
+        await guard("other", async () => (await desktop(this.#live)).scroll(dy, dx ? { dx, x, y } : { x, y }));
         return true;
     }
 }
@@ -65,6 +100,13 @@ export class Keyboard {
     async hotkey(keys) {
         await guard("other", async () => (await desktop(this.#live)).press(keys.split("+").map(keyOf).join("+")));
     }
+    /** Runtime's desktop presses keys and lets go at once; it cannot hold one. */
+    down(_key) {
+        return Promise.reject(holding());
+    }
+    up(_key) {
+        return Promise.reject(holding());
+    }
 }
 /** `sandbox.computerUse.screenshot`: the whole screen, PNG or JPEG. */
 export class Screenshot {
@@ -248,6 +290,22 @@ function processes() {
 function region() {
     return new NotSupportedError("Screenshots of part of the screen", "Take the whole screen with takeFullScreen() or takeCompressed() and crop it yourself.");
 }
+/** [dy, dx] per wheel click: positive is down and right. */
+const SCROLL = {
+    up: [-1, 0],
+    down: [1, 0],
+    left: [0, -1],
+    right: [0, 1],
+};
+function holding() {
+    return new NotSupportedError("Holding a key down (keyboard.down and keyboard.up)", 'Press the key with its modifiers at once: keyboard.press("t", ["ctrl", "shift"]) or keyboard.hotkey("ctrl+shift+t").');
+}
+/** Keys held through a click, drag or scroll need a key held down, which
+ * Runtime's desktop cannot do; refused before anything happens. */
+function held(modifiers, what) {
+    if (modifiers?.length)
+        throw new NotSupportedError(`Holding keys through a ${what} (modifiers)`, `Leave out modifiers; for a shortcut, keyboard.press(key, modifiers) or keyboard.hotkey("ctrl+a").`);
+}
 function buttonOf(button) {
     if (button === "left" || button === "middle" || button === "right")
         return button;

package/dist/daytona/daytona.d.ts

@@ -46,7 +46,13 @@ export type CreateSandboxBaseParams = {
     autoArchiveInterval?: number;
     autoDeleteInterval?: number;
     ttlMinutes?: number;
+    /** Minutes the create may wait for room before it fails with
+     * DaytonaQueueTimeoutError: Runtime's own wait for capacity, which is two
+     * minutes when not given. */
+    queueTimeout?: number;
     volumes?: VolumeMount[];
+    /** Refused: a Runtime sandbox has no /dev/kvm. */
+    kvm?: boolean;
     networkBlockAll?: boolean;
     networkAllowList?: string;
     domainAllowList?: string;

package/dist/daytona/daytona.js

@@ -1,5 +1,6 @@
 import { clientFor, } from "./client.js";
-import { DaytonaError, DaytonaNotFoundError, guard, NotSupportedError } from "./errors.js";
+import { DaytonaError, DaytonaInvalidArgumentError, DaytonaNotFoundError, DaytonaQueueTimeoutError, guard, NotSupportedError, } from "./errors.js";
+import { RuntimeError } from "../errors.js";
 import { LEASE_MAX_SECONDS } from "../compat/lease.js";
 import { idlePauseOf, idleSeconds, networkRules, notFound, retentionDays, Sandbox, windowSeconds, } from "./sandbox.js";
 /* Daytona's client over Runtime's. `new Daytona()` then `daytona.create()`
@@ -186,6 +187,9 @@ export class Daytona {
      * is left to Runtime: the included usage first, then prepaid credit, exactly as withruntime's own create. */
     async create(params = {}, options = {}) {
         refuseCreate(params);
+        const timeout = options.timeout;
+        if (timeout !== undefined && timeout !== null && !(timeout >= 0))
+            throw new DaytonaInvalidArgumentError("Timeout must be a non-negative number");
         const client = params.withruntime?.client ?? this.#client;
         const lifecycle = lifecycleOf(params);
         const resources = { ...DEFAULT_RESOURCES, ...params.resources };
@@ -229,7 +233,25 @@ export class Daytona {
             ...this.#create,
             ...params.withruntime?.create,
         };
-        const runtime = await guard("sandbox", () => client.sandboxes.create(input));
+        // Daytona's timeout bounds the create and its wait to run (0: none);
+        // queueTimeout bounds the wait for room, which Runtime counts apart.
+        let refused;
+        const runtime = await guard("sandbox", () => client.sandboxes.create(input, {
+            ...(timeout ? { timeoutMs: timeout * 1000 } : {}),
+            ...(params.queueTimeout !== undefined
+                ? {
+                    waitForCapacityMs: params.queueTimeout * 60_000,
+                    onCapacityWait: (refusal) => {
+                        refused = refusal.code;
+                    },
+                }
+                : {}),
+        })).catch((error) => {
+            const cause = error.cause;
+            if (refused !== undefined && cause instanceof RuntimeError && cause.code === refused)
+                throw new DaytonaQueueTimeoutError(`No room for the sandbox within its queueTimeout of ${params.queueTimeout} minutes. ${cause.message}`, cause.status, undefined, cause.code);
+            throw error;
+        });
         if (user)
             await asUser(runtime, user);
         if (lifecycle.autoDeleteInterval > 0)
@@ -279,7 +301,7 @@ export class Daytona {
             return { snapshot: snapshot.id };
         throw new DaytonaNotFoundError(`No Runtime image or snapshot is named "${name}". Daytona snapshots do not move to Runtime; build the same ` +
             `environment as a Runtime image with that name: daytona.snapshot.create({ name: "${name}", image }) with this ` +
-            `package, or \`npx withruntime image build --dockerfile Dockerfile --name ${imageName(name)}\`.`, 404);
+            `package, or \`npx withruntime images build --dockerfile Dockerfile --name ${imageName(name)}\`.`, 404);
     }
     async #volumes(client, mounts) {
         const out = [];
@@ -413,6 +435,11 @@ function refuseCreate(params) {
         throw new NotSupportedError("GPUs", "Runtime runs sandboxes on CPUs; remove gpu and gpuType from resources.");
     if (params.volumes?.some((mount) => mount.subpath))
         throw new NotSupportedError("Mounting part of a volume (subpath)", "Mount the whole volume.");
+    if (params.kvm)
+        throw new NotSupportedError("Nested virtualization (kvm)", "Remove kvm: a Runtime sandbox is a microVM without /dev/kvm. Run the workload directly in the sandbox, or in a container with `sudo enable-docker`.");
+    if (params.queueTimeout !== undefined &&
+        (!Number.isInteger(params.queueTimeout) || params.queueTimeout < 1))
+        throw new DaytonaInvalidArgumentError("queueTimeout must be a positive integer");
     const refusals = [
         ["spot", "Spot GPU sandboxes (spot)", "Remove it: Runtime runs sandboxes on CPUs."],
         [

package/dist/daytona/errors.d.ts

@@ -20,7 +20,11 @@ export declare class DaytonaForbiddenError extends DaytonaError {
 }
 export declare class DaytonaNotFoundError extends DaytonaError {
 }
+/** A 408 or 504. As in Daytona, `instanceof DaytonaTimeoutError` also
+ * matches a DaytonaConnectionTimeoutError, the class a call's own deadline
+ * raises, though that one sits under DaytonaConnectionError. */
 export declare class DaytonaTimeoutError extends DaytonaError {
+    static [Symbol.hasInstance](value: unknown): boolean;
 }
 export declare class DaytonaConflictError extends DaytonaError {
 }
@@ -46,6 +50,13 @@ export declare class DaytonaConnectionError extends DaytonaError {
 }
 export declare class DaytonaConnectionTimeoutError extends DaytonaConnectionError {
 }
+/** The create waited its queueTimeout for room and none came. */
+export declare class DaytonaQueueTimeoutError extends DaytonaTimeoutError {
+}
+/** Daytona's spot preemption; Runtime has no spot sandboxes, so it never
+ * comes, and exists for code that names it. */
+export declare class DaytonaSpotEvictedError extends DaytonaError {
+}
 export declare class DaytonaGitAuthFailedError extends DaytonaAuthenticationError {
 }
 export declare class DaytonaGitRepoNotFoundError extends DaytonaNotFoundError {

package/dist/daytona/errors.js

@@ -38,7 +38,16 @@ export class DaytonaForbiddenError extends DaytonaError {
 }
 export class DaytonaNotFoundError extends DaytonaError {
 }
+/** A 408 or 504. As in Daytona, `instanceof DaytonaTimeoutError` also
+ * matches a DaytonaConnectionTimeoutError, the class a call's own deadline
+ * raises, though that one sits under DaytonaConnectionError. */
 export class DaytonaTimeoutError extends DaytonaError {
+    static [Symbol.hasInstance](value) {
+        // Only the base class widens; its subclasses keep the prototype chain.
+        if (this === DaytonaTimeoutError && value instanceof DaytonaConnectionTimeoutError)
+            return true;
+        return Function.prototype[Symbol.hasInstance].call(this, value);
+    }
 }
 export class DaytonaConflictError extends DaytonaError {
 }
@@ -64,6 +73,13 @@ export class DaytonaConnectionError extends DaytonaError {
 }
 export class DaytonaConnectionTimeoutError extends DaytonaConnectionError {
 }
+/** The create waited its queueTimeout for room and none came. */
+export class DaytonaQueueTimeoutError extends DaytonaTimeoutError {
+}
+/** Daytona's spot preemption; Runtime has no spot sandboxes, so it never
+ * comes, and exists for code that names it. */
+export class DaytonaSpotEvictedError extends DaytonaError {
+}
 export class DaytonaGitAuthFailedError extends DaytonaAuthenticationError {
 }
 export class DaytonaGitRepoNotFoundError extends DaytonaNotFoundError {
@@ -156,6 +172,8 @@ export function translate(error, subject = "other") {
         out = new DaytonaProcessNotFoundError(message);
     else if (error.code === "command_timeout")
         out = new DaytonaProcessExecutionTimeoutError(message);
+    else if (error.status === 0 && error.code === "timeout")
+        out = new DaytonaConnectionTimeoutError(message);
     else if (error.status === 0)
         out = new DaytonaConnectionError(message);
     else

package/dist/daytona/filesystem.js

@@ -1,3 +1,4 @@
+import { timeoutSignal } from "../transport.js";
 import { resolvePath, WHOLE_OUTPUT } from "./context.js";
 import { DaytonaError, DaytonaFileNotFoundError, guard } from "./errors.js";
 const PERMISSIONS = ["---", "--x", "-w-", "-wx", "r--", "r-x", "rw-", "rwx"];
@@ -5,7 +6,7 @@ function downloadRequest(timeout, signal) {
     if (!Number.isFinite(timeout) || timeout < 0)
         throw new DaytonaError("Download timeout must be a nonnegative finite number.");
     signal?.throwIfAborted();
-    const deadline = timeout > 0 ? AbortSignal.timeout(Math.ceil(timeout * 1000)) : undefined;
+    const deadline = timeout > 0 ? timeoutSignal(timeout * 1000) : undefined;
     return {
         timeoutMs: 0,
         ...(deadline || signal

package/dist/daytona/image.d.ts

@@ -6,6 +6,14 @@ export type ContextFile = {
     mode?: number;
 };
 declare const PYTHON: readonly ["3.9", "3.10", "3.11", "3.12", "3.13"];
+/** Daytona's pip options, as pip flags. */
+export type PipInstallOptions = {
+    indexUrl?: string;
+    extraIndexUrls?: string[];
+    findLinks?: string[];
+    pre?: boolean;
+    extraOptions?: string;
+};
 /** 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. */
@@ -18,14 +26,8 @@ export declare class Image {
     static debianSlim(pythonVersion?: (typeof PYTHON)[number]): Image;
     /** A local Dockerfile; files it copies come from its directory. */
     static fromDockerfile(path: string): Image;
-    pipInstall(packages: string | string[], options?: {
-        indexUrl?: string;
-        extraIndexUrls?: string[];
-        findLinks?: string[];
-        pre?: boolean;
-        extraOptions?: string;
-    }): Image;
-    pipInstallFromRequirements(requirementsTxt: string): Image;
+    pipInstall(packages: string | string[], options?: PipInstallOptions): Image;
+    pipInstallFromRequirements(requirementsTxt: string, options?: PipInstallOptions): Image;
     pipInstallFromPyproject(): Image;
     addLocalFile(localPath: string, remotePath: string): Image;
     addLocalDir(localPath: string, remotePath: string): Image;
@@ -34,7 +36,9 @@ export declare class Image {
     workdir(dirPath: string): Image;
     entrypoint(entrypointCommands: string[]): Image;
     cmd(cmd: string[]): Image;
-    dockerfileCommands(dockerfileCommands: string[]): Image;
+    dockerfileCommands(dockerfileCommands: string[], contextDir?: string, options?: {
+        strictContext?: boolean;
+    }): Image;
     /** The Dockerfile and its context files, read from the local disk. */
     build(): Promise<{
         dockerfile: string;

package/dist/daytona/image.js

@@ -1,6 +1,15 @@
 import { createHash } from "node:crypto";
-import { NotSupportedError } from "./errors.js";
+import { DaytonaInvalidArgumentError, NotSupportedError } from "./errors.js";
 const PYTHON = ["3.9", "3.10", "3.11", "3.12", "3.13"];
+function pipFlags(options) {
+    return [
+        ...(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] : []),
+    ].join(" ");
+}
 /** 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. */
@@ -37,20 +46,13 @@ export class Image {
         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());
+        this.#lines.push(`RUN python -m pip install ${list.map((one) => JSON.stringify(one)).join(" ")} ${pipFlags(options)}`.trim());
         return this;
     }
-    pipInstallFromRequirements(requirementsTxt) {
+    pipInstallFromRequirements(requirementsTxt, options = {}) {
         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}`);
+        this.#lines.push(`COPY ${remote.slice(1)} ${remote}`, `RUN python -m pip install -r ${remote} ${pipFlags(options)}`.trim());
         return this;
     }
     pipInstallFromPyproject() {
@@ -90,7 +92,11 @@ export class Image {
         this.#lines.push(`CMD ${JSON.stringify(cmd)}`);
         return this;
     }
-    dockerfileCommands(dockerfileCommands) {
+    dockerfileCommands(dockerfileCommands, contextDir, options = {}) {
+        if (options.strictContext && !contextDir)
+            throw new DaytonaInvalidArgumentError("strictContext requires contextDir so that the build context boundary is explicit");
+        if (contextDir)
+            throw new NotSupportedError("A build context directory for dockerfileCommands (contextDir)", "Add the files with addLocalDir(contextDir, remotePath) or addLocalFile, then COPY from where they land, or build from a Dockerfile with Image.fromDockerfile(path).");
         this.#lines.push(...dockerfileCommands);
         return this;
     }

package/dist/daytona/index.d.ts

@@ -4,7 +4,7 @@ export { Process, CodeRunParams, PtyHandle, type PtyConnectOptions, type PtyCrea
 export { FileSystem, type FileDownloadRequest, type FileDownloadResponse, type FileInfo, type FilePermissionsParams, type FileUpload, type Match, type ReplaceResult, type SearchFilesResponse, type UploadSource, type UploadProgress, type UploadStreamOptions, } from "./filesystem.js";
 export { Git, type GitStatus, type ListBranchResponse } from "./git.js";
 export { Accessibility, ComputerUse, Display, Keyboard, Mouse, RecordingService, Screenshot, type ComputerUseStartResponse, type ComputerUseStatusResponse, type ComputerUseStopResponse, type DisplayInfo, type ListRecordingsResponse, type Recording, type ScreenshotOptions, type ScreenshotRegion, type ScreenshotResponse, type WindowInfo, } from "./computer-use.js";
-export { Image } from "./image.js";
+export { Image, type PipInstallOptions } from "./image.js";
 export { resolvePath } from "./context.js";
 export type { DaytonaConfig, WithRuntime } from "./client.js";
 export * from "./errors.js";

package/dist/daytona/sandbox.d.ts

@@ -87,7 +87,8 @@ export declare class Sandbox {
     readonly git: Git;
     readonly codeInterpreter: CodeInterpreter;
     env: Record<string, string>;
-    readonly public: boolean;
+    /** Whether its previews are public; setPublic changes it. */
+    public: boolean;
     readonly snapshot: string | undefined;
     /** Use daytona.create or daytona.get. */
     constructor(runtime: RuntimeSandbox, client: Runtime, options: SandboxOptions);
@@ -154,8 +155,13 @@ export declare class Sandbox {
         networkAllowList?: string;
         domainAllowList?: string;
     }): Promise<void>;
+    /** Makes every port it shares public, or private with a token, and the
+     * ports getPreviewLink shares from now on. A port already shared changes
+     * at once, keeping its address, as on Daytona. Without credit, public is
+     * refused (public_preview_not_allowed) and nothing changes. */
+    setPublic(isPublic: boolean): Promise<void>;
     /** A preview address for `port`: public when the sandbox was created with
-     * `public: true`, else private with a token. */
+     * `public: true` or setPublic(true) since, else private with a token. */
     getPreviewLink(port: number): Promise<PortPreviewUrl>;
     getUserHomeDir(): Promise<string>;
     getUserRootDir(): Promise<string>;

package/dist/daytona/sandbox.js

@@ -90,6 +90,7 @@ export class Sandbox {
     git;
     codeInterpreter;
     env;
+    /** Whether its previews are public; setPublic changes it. */
     public;
     snapshot;
     #rt;
@@ -349,8 +350,21 @@ export class Sandbox {
         const runtime = await this.#live();
         await guard("sandbox", () => runtime.network.set(rules ?? { internet: true }));
     }
+    /** Makes every port it shares public, or private with a token, and the
+     * ports getPreviewLink shares from now on. A port already shared changes
+     * at once, keeping its address, as on Daytona. Without credit, public is
+     * refused (public_preview_not_allowed) and nothing changes. */
+    async setPublic(isPublic) {
+        const visibility = isPublic ? "public" : "private";
+        const runtime = await this.#live();
+        const shared = await guard("sandbox", () => runtime.previews.list());
+        for (const preview of shared)
+            if (preview.visibility !== visibility)
+                await guard("sandbox", () => runtime.previews.create(preview.port, { visibility }));
+        this.public = isPublic;
+    }
     /** A preview address for `port`: public when the sandbox was created with
-     * `public: true`, else private with a token. */
+     * `public: true` or setPublic(true) since, 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" }));
@@ -440,7 +454,7 @@ export class Sandbox {
         return refusal("Signed download URLs", "Use sandbox.fs.downloadFile(path).");
     }
     createSshAccess() {
-        return refusal("SSH access", "Use `npx withruntime sandbox ssh <id>` (also VS Code and JetBrains) or sandbox.withruntime.terminal().");
+        return refusal("SSH access", "Use `npx withruntime sandboxes ssh <id>` (also VS Code and JetBrains) or sandbox.withruntime.terminal().");
     }
     revokeSshAccess() {
         return this.createSshAccess();

package/dist/domains/index.d.ts

@@ -0,0 +1,9 @@
+/** `withruntime/domains`: Domains alone. Your own hostname for a sandbox's port, with HTTPS.
+ *
+ *   import { domains } from "withruntime/domains";
+ *   const client = domains(); // RUNTIME_API_KEY, or this machine's saved connection
+ */
+import { Runtime, type RuntimeOptions } from "../client.js";
+export type { Domain, CheckedDomain, DnsRecord } from "../products/network-products.js";
+/** `runtime.domains` of a client made with `options`. */
+export declare function domains(options?: RuntimeOptions): Runtime["domains"];

package/dist/domains/index.js

@@ -0,0 +1,10 @@
+/** `withruntime/domains`: Domains alone. Your own hostname for a sandbox's port, with HTTPS.
+ *
+ *   import { domains } from "withruntime/domains";
+ *   const client = domains(); // RUNTIME_API_KEY, or this machine's saved connection
+ */
+import { Runtime } from "../client.js";
+/** `runtime.domains` of a client made with `options`. */
+export function domains(options) {
+    return new Runtime(options).domains;
+}

package/dist/e2b/commands.d.ts

@@ -1,6 +1,6 @@
 import type { Process } from "../sandbox.js";
 import type { OutputEvent, ProcessInfo as RuntimeProcessInfo } from "../types.js";
-import type { RequestOptions } from "../transport.js";
+import { type RequestOptions } from "../transport.js";
 import type { RuntimeSandbox } from "./client.js";
 import { TimeoutError, type CommandResult } from "./errors.js";
 export type { CommandResult };