withruntime 0.10.0 → 0.11.1

package/dist/daytona/computer-use.js

@@ -0,0 +1,324 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { basename, dirname } from "node:path";
+import { RuntimeError } from "../errors.js";
+import { guard, NotSupportedError } from "./errors.js";
+const ALTERNATIVE_STREAM = "Open the live desktop from `(await sandbox.withruntime.desktop.start()).streamUrl`.";
+async function desktop(live) {
+    return (await live()).desktop;
+}
+/** `sandbox.computerUse.mouse`. */
+export class Mouse {
+    #live;
+    /** Use sandbox.computerUse.mouse. */
+    constructor(live) {
+        this.#live = live;
+    }
+    async getPosition() {
+        const { x, y } = await guard("other", async () => (await desktop(this.#live)).cursor());
+        return { x, y };
+    }
+    async move(x, y) {
+        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 }));
+        return { x, y };
+    }
+    async drag(startX, startY, endX, endY, button = "left") {
+        const which = buttonOf(button);
+        await guard("other", async () => {
+            const screen = await desktop(this.#live);
+            if (which === "left")
+                return screen.drag([startX, startY], [endX, endY]);
+            await screen.move(startX, startY);
+            await screen.mouseDown(which);
+            await screen.move(endX, endY);
+            return screen.mouseUp(which);
+        });
+        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 }));
+        return true;
+    }
+}
+/** `sandbox.computerUse.keyboard`. Key names are Daytona's (enter, esc,
+ * ctrl, cmd, pageup, f5) or xdotool's (Return, Escape, Prior). */
+export class Keyboard {
+    #live;
+    /** Use sandbox.computerUse.keyboard. */
+    constructor(live) {
+        this.#live = live;
+    }
+    /** Types `text`, `delay` milliseconds between keys. */
+    async type(text, delay) {
+        await guard("other", async () => (await desktop(this.#live)).type(text, delay === undefined ? {} : { delayMs: delay }));
+    }
+    async press(key, modifiers = []) {
+        await guard("other", async () => (await desktop(this.#live)).press([...modifiers, key].map(keyOf).join("+")));
+    }
+    /** A combination such as "ctrl+c" or "ctrl+shift+t". */
+    async hotkey(keys) {
+        await guard("other", async () => (await desktop(this.#live)).press(keys.split("+").map(keyOf).join("+")));
+    }
+}
+/** `sandbox.computerUse.screenshot`: the whole screen, PNG or JPEG. */
+export class Screenshot {
+    #live;
+    /** Use sandbox.computerUse.screenshot. */
+    constructor(live) {
+        this.#live = live;
+    }
+    takeFullScreen(showCursor = false) {
+        return this.takeCompressed({ showCursor, format: "png" });
+    }
+    takeRegion(_region, _showCursor) {
+        return Promise.reject(region());
+    }
+    async takeCompressed(options = {}) {
+        if (options.showCursor)
+            throw new NotSupportedError("Drawing the cursor into a screenshot (showCursor)", "Take it without; sandbox.computerUse.mouse.getPosition() says where the cursor is.");
+        if (options.scale !== undefined && options.scale !== 1)
+            throw new NotSupportedError("Scaling a screenshot", "Take it at full size and scale it yourself, or start the desktop smaller: sandbox.withruntime.desktop.start({ width, height }).");
+        const format = (options.format ?? "png").toLowerCase();
+        if (format !== "png" && format !== "jpeg" && format !== "jpg")
+            throw new NotSupportedError(`Screenshots as ${format}`, 'Use format "png" or "jpeg".');
+        const bytes = await guard("other", async () => (await desktop(this.#live)).screenshot(format === "png"
+            ? {}
+            : {
+                format: "jpeg",
+                ...(options.quality === undefined ? {} : { quality: options.quality }),
+            }));
+        return { screenshot: Buffer.from(bytes).toString("base64"), sizeBytes: bytes.byteLength };
+    }
+    takeCompressedRegion(_region, _options) {
+        return Promise.reject(region());
+    }
+}
+/** `sandbox.computerUse.display`. */
+export class Display {
+    #live;
+    /** Use sandbox.computerUse.display. */
+    constructor(live) {
+        this.#live = live;
+    }
+    /** The one screen, its size read from a screenshot. */
+    async getInfo() {
+        const png = await guard("other", async () => (await desktop(this.#live)).screenshot());
+        const { width, height } = pngSize(png);
+        return { displays: [{ id: 0, x: 0, y: 0, width, height, isActive: true }] };
+    }
+    async getWindows() {
+        const windows = await guard("other", async () => (await desktop(this.#live)).windows());
+        return {
+            windows: windows.map((one) => ({
+                id: Number(one.id),
+                title: one.title,
+                x: one.x,
+                y: one.y,
+                width: one.width,
+                height: one.height,
+            })),
+        };
+    }
+}
+/** `sandbox.computerUse.recording`: screen recordings to MP4. */
+export class RecordingService {
+    #live;
+    /** Use sandbox.computerUse.recording. */
+    constructor(live) {
+        this.#live = live;
+    }
+    /** Starts recording. Runtime names the file itself; `label` is not used. */
+    async start(_label) {
+        return recordingOf(await guard("other", async () => (await desktop(this.#live)).recordings.start()));
+    }
+    async stop(id) {
+        return recordingOf(await guard("other", async () => (await desktop(this.#live)).recordings.stop(id)));
+    }
+    async list() {
+        const all = await guard("other", async () => (await desktop(this.#live)).recordings.list());
+        return { recordings: all.map(recordingOf) };
+    }
+    async get(id) {
+        return recordingOf(await guard("other", async () => (await desktop(this.#live)).recordings.get(id)));
+    }
+    async delete(id) {
+        await guard("other", async () => (await desktop(this.#live)).recordings.delete(id));
+    }
+    /** Saves the MP4 to `localPath`, making its directory. */
+    async download(id, localPath) {
+        const bytes = await guard("other", async () => (await desktop(this.#live)).recordings.download(id));
+        await mkdir(dirname(localPath), { recursive: true });
+        await writeFile(localPath, bytes);
+    }
+}
+/** `sandbox.computerUse.accessibility`: Runtime's desktop has no
+ * accessibility tree; every method throws NotSupportedError. */
+export class Accessibility {
+    #refuse() {
+        return Promise.reject(new NotSupportedError("The desktop's accessibility tree", "Find things on screen with a screenshot (sandbox.computerUse.screenshot.takeFullScreen()) and act with the mouse and keyboard."));
+    }
+    getTree(_options) {
+        return this.#refuse();
+    }
+    findNodes(_options) {
+        return this.#refuse();
+    }
+    focusNode(_id) {
+        return this.#refuse();
+    }
+    invokeNode(_id, _action) {
+        return this.#refuse();
+    }
+    setNodeValue(_id, _value) {
+        return this.#refuse();
+    }
+}
+/** `sandbox.computerUse`: a Linux desktop driven like a person would. */
+export class ComputerUse {
+    mouse;
+    keyboard;
+    screenshot;
+    display;
+    recording;
+    accessibility;
+    #live;
+    /** Use sandbox.computerUse. */
+    constructor(live) {
+        this.#live = live;
+        this.mouse = new Mouse(live);
+        this.keyboard = new Keyboard(live);
+        this.screenshot = new Screenshot(live);
+        this.display = new Display(live);
+        this.recording = new RecordingService(live);
+        this.accessibility = new Accessibility();
+    }
+    /** Starts the desktop. A sandbox's first start installs it, which takes a
+     * minute or two; this waits for that. */
+    async start() {
+        await guard("other", async () => (await desktop(this.#live)).start());
+        return {
+            message: "Computer use processes started successfully",
+            status: { desktop: { running: true } },
+        };
+    }
+    async stop() {
+        await guard("other", async () => (await desktop(this.#live)).stop());
+        return {
+            message: "Computer use processes stopped successfully",
+            status: { desktop: { running: false } },
+        };
+    }
+    /** "active" while the desktop runs, else "inactive". */
+    async getStatus() {
+        try {
+            await (await desktop(this.#live)).cursor();
+            return { status: "active" };
+        }
+        catch (error) {
+            if (error instanceof RuntimeError &&
+                (error.code === "desktop_not_running" || error.code === "desktop_not_installed"))
+                return { status: "inactive" };
+            return guard("other", () => {
+                throw error;
+            });
+        }
+    }
+    getProcessStatus(_processName) {
+        return processes();
+    }
+    restartProcess(_processName) {
+        return processes();
+    }
+    getProcessLogs(_processName) {
+        return processes();
+    }
+    getProcessErrors(_processName) {
+        return processes();
+    }
+}
+function processes() {
+    return Promise.reject(new NotSupportedError("Managing the desktop's processes one by one", `Use computerUse.getStatus(), stop() and start(). ${ALTERNATIVE_STREAM}`));
+}
+function region() {
+    return new NotSupportedError("Screenshots of part of the screen", "Take the whole screen with takeFullScreen() or takeCompressed() and crop it yourself.");
+}
+function buttonOf(button) {
+    if (button === "left" || button === "middle" || button === "right")
+        return button;
+    throw new RangeError(`button is "left", "middle" or "right", not ${JSON.stringify(button)}.`);
+}
+/** Daytona's key names as xdotool's; anything else passes as given. */
+const KEYS = {
+    enter: "Return",
+    return: "Return",
+    esc: "Escape",
+    escape: "Escape",
+    backspace: "BackSpace",
+    delete: "Delete",
+    del: "Delete",
+    tab: "Tab",
+    space: "space",
+    up: "Up",
+    down: "Down",
+    left: "Left",
+    right: "Right",
+    home: "Home",
+    end: "End",
+    pageup: "Prior",
+    pagedown: "Next",
+    insert: "Insert",
+    capslock: "Caps_Lock",
+    control: "ctrl",
+    ctrl: "ctrl",
+    shift: "shift",
+    alt: "alt",
+    cmd: "super",
+    command: "super",
+    meta: "super",
+    win: "super",
+    super: "super",
+};
+function keyOf(key) {
+    const name = key.trim();
+    const lower = name.toLowerCase();
+    if (KEYS[lower])
+        return KEYS[lower];
+    if (/^f([1-9]|1[0-2])$/.test(lower))
+        return lower.toUpperCase();
+    return name;
+}
+const STATUS = {
+    starting: "recording",
+    installing: "recording",
+    recording: "recording",
+    finished: "completed",
+    failed: "failed",
+};
+function recordingOf(recording) {
+    const start = recording.startedAt ?? null;
+    return {
+        id: recording.id,
+        fileName: basename(recording.path),
+        filePath: recording.path,
+        startTime: start === null ? "" : new Date(start).toISOString(),
+        ...(start !== null && recording.seconds !== undefined && STATUS[recording.state] !== "recording"
+            ? { endTime: new Date(start + recording.seconds * 1000).toISOString() }
+            : {}),
+        status: STATUS[recording.state] ?? recording.state,
+        sizeBytes: recording.bytes,
+        ...(recording.seconds === undefined ? {} : { durationSeconds: recording.seconds }),
+    };
+}
+/** Width and height from a PNG's header. */
+function pngSize(png) {
+    const view = new DataView(png.buffer, png.byteOffset, png.byteLength);
+    if (png.byteLength < 24 || view.getUint32(12) !== 0x49484452)
+        throw new RangeError("The desktop's screenshot was not a PNG.");
+    return { width: view.getUint32(16), height: view.getUint32(20) };
+}

package/dist/daytona/context.d.ts

@@ -11,6 +11,8 @@ export interface SandboxContext {
     /** Makes /home/daytona (Daytona's home) lead to /workspace (Runtime's),
      * once, the first time something names it. */
     ensureHome(text: string | undefined): Promise<void>;
+    /** The Linux user commands run as (create's `user`), when not the owner. */
+    readonly user?: string;
 }
 /** Daytona's home, and the working directory relative paths resolve from. */
 export declare const DAYTONA_HOME = "/home/daytona";
@@ -29,3 +31,11 @@ export declare const WHOLE_OUTPUT: {
 export declare function resolvePath(path: string): string;
 /** Quotes a word for bash. */
 export declare function quote(word: string): string;
+/** A command and its environment as Runtime runs them: as given for the
+ * sandbox owner; for another user through sudo, its environment carried on
+ * the command line (sudo resets it) and umask 002, so files it makes in the
+ * shared working directory stay writable by the owner's group. */
+export declare function runAs(user: string | undefined, argv: readonly string[], env?: Record<string, string>): {
+    argv: string[];
+    env?: Record<string, string>;
+};

package/dist/daytona/context.js

@@ -24,3 +24,27 @@ export function resolvePath(path) {
 export function quote(word) {
     return `'${word.replace(/'/g, `'\\''`)}'`;
 }
+/** A command and its environment as Runtime runs them: as given for the
+ * sandbox owner; for another user through sudo, its environment carried on
+ * the command line (sudo resets it) and umask 002, so files it makes in the
+ * shared working directory stay writable by the owner's group. */
+export function runAs(user, argv, env = {}) {
+    if (!user)
+        return { argv: [...argv], ...(Object.keys(env).length ? { env } : {}) };
+    return {
+        argv: [
+            "sudo",
+            "-u",
+            user,
+            "-H",
+            "--",
+            "env",
+            ...Object.entries(env).map(([name, value]) => `${name}=${value}`),
+            "sh",
+            "-c",
+            'umask 002; exec "$@"',
+            "sh",
+            ...argv,
+        ],
+    };
+}

package/dist/daytona/daytona.d.ts

@@ -13,6 +13,8 @@ export declare const DEFAULT_RESOURCES: {
 export declare const DEFAULT_AUTO_STOP_MINUTES = 15;
 /** Daytona's label for a sandbox's code language. */
 export declare const LANGUAGE_LABEL = "code-toolbox-language";
+/** The Linux user given at create, so get() and list() run as it too. */
+export declare const USER_LABEL = "compat.daytona-user";
 export declare enum CodeLanguage {
     PYTHON = "python",
     TYPESCRIPT = "typescript",
@@ -69,10 +71,28 @@ export type ForkSandboxParams = {
     name?: string;
 };
 export interface ListSandboxesQuery {
+    /** Daytona's page size; every sandbox is still listed. */
     limit?: number;
+    sort?: "name" | "cpu" | "memoryGib" | "diskGib" | "lastActivityAt" | "createdAt";
+    order?: "asc" | "desc";
+    /** An id prefix, any case. */
+    id?: string;
+    /** A name prefix, any case. */
     name?: string;
     labels?: Record<string, string>;
     states?: SandboxState[];
+    targets?: string[];
+    minCpu?: number;
+    maxCpu?: number;
+    minMemoryGib?: number;
+    maxMemoryGib?: number;
+    minDiskGib?: number;
+    maxDiskGib?: number;
+    isRecoverable?: boolean;
+    createdAtAfter?: Date;
+    createdAtBefore?: Date;
+    lastActivityAfter?: Date;
+    lastActivityBefore?: Date;
     [other: string]: unknown;
 }
 /** A Daytona snapshot: on Runtime, an image (or a snapshot made with