withruntime 0.10.0 → 0.11.0

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

package/dist/daytona/daytona.js

@@ -1,6 +1,6 @@
 import { clientFor, } from "./client.js";
 import { DaytonaError, DaytonaNotFoundError, guard, NotSupportedError } from "./errors.js";
-import { networkRules, notFound, retentionDays, Sandbox, windowSeconds, } from "./sandbox.js";
+import { idleSeconds, networkRules, notFound, retentionDays, Sandbox, windowSeconds, } from "./sandbox.js";
 /* Daytona's client over Runtime's. `new Daytona()` then `daytona.create()`
    makes a Runtime sandbox with Daytona's defaults. */
 /** Daytona's default machine: 1 vCPU, 1 GiB memory, 3 GiB disk (checked
@@ -14,6 +14,10 @@ const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const STOCK_SNAPSHOT = /^daytona(io)?[-/:]|^daytona$/;
 /** Daytona's label for a sandbox's code language. */
 export const LANGUAGE_LABEL = "code-toolbox-language";
+/** The Linux user given at create, so get() and list() run as it too. */
+export const USER_LABEL = "compat.daytona-user";
+/** The sandbox owner's names: Daytona's and Runtime's. */
+const OWNER = new Set(["daytona", "runtime"]);
 export var CodeLanguage;
 (function (CodeLanguage) {
     CodeLanguage["PYTHON"] = "python";
@@ -190,11 +194,15 @@ export class Daytona {
         const network = networkRules(params);
         // Daytona keeps the language in this label, so a sandbox found later with
         // get() or list() runs codeRun in the language it was made for.
-        const labels = params.language && params.language !== "python"
-            ? { ...params.labels, [LANGUAGE_LABEL]: params.language }
-            : params.labels && Object.keys(params.labels).length
-                ? params.labels
-                : undefined;
+        const user = params.user !== undefined && !OWNER.has(params.user) ? params.user : undefined;
+        const tagged = {
+            ...params.labels,
+            ...(params.language && params.language !== "python"
+                ? { [LANGUAGE_LABEL]: params.language }
+                : {}),
+            ...(user ? { [USER_LABEL]: user } : {}),
+        };
+        const labels = Object.keys(tagged).length ? tagged : undefined;
         const input = {
             ...(source.snapshot
                 ? {}
@@ -216,6 +224,8 @@ export class Daytona {
             ...params.withruntime?.create,
         };
         const runtime = await guard("sandbox", () => client.sandboxes.create(input));
+        if (user)
+            await asUser(runtime, user);
         if (lifecycle.autoDeleteInterval > 0)
             await guard("sandbox", () => runtime.setRetention(retentionDays(lifecycle.autoDeleteInterval))).catch(async (error) => {
                 await runtime.stop({ wait: false }).catch(() => undefined);
@@ -233,6 +243,7 @@ export class Daytona {
             public: params.public ?? false,
             lifecycle,
             ...("snapshot" in params && params.snapshot ? { snapshot: params.snapshot } : {}),
+            ...(user ? { user } : {}),
         });
     }
     async #source(client, params, onLogs) {
@@ -286,12 +297,15 @@ export class Daytona {
     }
     #adopt(runtime) {
         const onLeaseEnd = runtime.info.onLeaseEnd;
+        const user = runtime.info.labels[USER_LABEL];
         return new Sandbox(runtime, this.#client, {
             env: {},
             language: runtime.info.labels[LANGUAGE_LABEL] ?? "python",
             public: false,
+            ...(user ? { user } : {}),
             lifecycle: {
                 windowSeconds: runtime.info.timeoutSeconds,
+                idleSeconds: runtime.info.timeoutSeconds,
                 ephemeral: onLeaseEnd === "stop",
                 autoStopInterval: Math.round(runtime.info.timeoutSeconds / 60),
                 autoArchiveInterval: 0,
@@ -302,10 +316,15 @@ export class Daytona {
     /** Live and stopped (paused) sandboxes, oldest first. Await it for the old
      * paginated shape, `{ items, total, page, totalPages }`. */
     list(query = {}) {
-        const known = new Set(["limit", "name", "labels", "states"]);
-        const other = Object.keys(query).find((key) => query[key] !== undefined && !known.has(key));
+        const other = Object.keys(query).find((key) => query[key] !== undefined && !LISTED.has(key));
         if (other)
-            throw new NotSupportedError(`Listing sandboxes by ${other}`, "Filter by name, labels or states, and sort or narrow the result yourself.");
+            throw new NotSupportedError(`Listing sandboxes by ${other}`, other === "isPublic"
+                ? "Runtime previews are public or private per port: filter by a label you set at create."
+                : "Filter by a label you set at create, or narrow the result yourself.");
+        if (query.sort !== undefined && !SORTS[query.sort])
+            throw new RangeError(`sort is one of ${Object.keys(SORTS).join(", ")}.`);
+        if (query.order !== undefined && query.order !== "asc" && query.order !== "desc")
+            throw new RangeError('order is "asc" or "desc".');
         const states = query.states?.flatMap((state) => state === "started"
             ? ["running"]
             : state === "starting"
@@ -315,15 +334,24 @@ export class Daytona {
                     : state === "stopped" || state === "paused"
                         ? ["paused"]
                         : []);
-        const client = this.#client;
-        const adopt = (runtime) => this.#adopt(runtime);
         const filter = {
             ...(query.labels ? { labels: query.labels } : {}),
-            ...(query.name ? { name: query.name } : {}),
             ...(states ? { state: states } : {}),
             ...(query.limit ? { limit: Math.min(query.limit, 100) } : {}),
         };
+        const here = Object.keys(query).some((key) => query[key] !== undefined && !["limit", "labels", "states"].includes(key));
+        const client = this.#client;
+        const adopt = (runtime) => this.#adopt(runtime);
+        const everything = async () => {
+            const page = await guard("other", () => client.sandboxes.list(filter));
+            return arrange(await page.toArray(10_000), query);
+        };
         async function* iterate() {
+            if (here) {
+                for (const runtime of await everything())
+                    yield adopt(runtime);
+                return;
+            }
             const page = await guard("other", () => client.sandboxes.list(filter));
             for await (const runtime of page)
                 yield adopt(runtime);
@@ -332,8 +360,7 @@ export class Daytona {
         return Object.assign(iterator, {
             then(onFulfilled, onRejected) {
                 const all = (async () => {
-                    const page = await guard("other", () => client.sandboxes.list(filter));
-                    const items = (await page.toArray(10_000)).map(adopt);
+                    const items = (await everything()).map(adopt);
                     return { items, total: items.length, page: 1, totalPages: 1 };
                 })();
                 return all.then(onFulfilled, onRejected);
@@ -391,8 +418,8 @@ function refuseCreate(params) {
     for (const [field, feature, alternative] of refusals)
         if (params[field] !== undefined)
             throw new NotSupportedError(feature, alternative);
-    if (params.user !== undefined && params.user !== "daytona")
-        throw new NotSupportedError(`Running as the user "${params.user}"`, 'Commands run as the sandbox owner with passwordless sudo: prefix a command with "sudo" to run it as root.');
+    if (params.user !== undefined && !/^[a-z_][a-z0-9_-]{0,31}$/.test(params.user))
+        throw new DaytonaError(`Invalid user name ${JSON.stringify(params.user)}.`, 400);
     if (params.language !== undefined &&
         !["python", "javascript", "typescript"].includes(params.language))
         throw new NotSupportedError(`The language ${params.language}`, "Use python, javascript or typescript; run anything else with process.executeCommand.");
@@ -408,6 +435,7 @@ export function lifecycleOf(params) {
     const autoDelete = params.ephemeral ? 0 : (params.autoDeleteInterval ?? -1);
     return {
         windowSeconds: windowSeconds(autoStop),
+        idleSeconds: idleSeconds(autoStop),
         ...(params.ttlMinutes ? { deadline: Date.now() + params.ttlMinutes * 60_000 } : {}),
         ephemeral: autoDelete === 0,
         autoStopInterval: autoStop,
@@ -415,6 +443,85 @@ export function lifecycleOf(params) {
         autoDeleteInterval: autoDelete,
     };
 }
+/** What list() takes; isPublic, snapshots and autoDestroyAt are refused. */
+const LISTED = new Set([
+    "limit",
+    "sort",
+    "order",
+    "id",
+    "name",
+    "labels",
+    "states",
+    "targets",
+    "minCpu",
+    "maxCpu",
+    "minMemoryGib",
+    "maxMemoryGib",
+    "minDiskGib",
+    "maxDiskGib",
+    "isRecoverable",
+    "createdAtAfter",
+    "createdAtBefore",
+    "lastActivityAfter",
+    "lastActivityBefore",
+]);
+const lastActivity = (one) => Date.parse(one.info.lastActiveAt ?? one.info.readyAt ?? one.info.createdAt);
+const SORTS = {
+    name: (one) => one.info.name ?? one.id,
+    cpu: (one) => one.info.vcpu,
+    memoryGib: (one) => one.info.memoryMiB / 1024,
+    diskGib: (one) => one.info.diskMiB / 1024,
+    lastActivityAt: lastActivity,
+    createdAt: (one) => Date.parse(one.info.createdAt),
+};
+/** Daytona's list filters and sorting, applied here: Runtime filters by
+ * labels and state only. Sorted descending unless `order` says, as Daytona
+ * does; unsorted lists keep Runtime's order, oldest first. */
+function arrange(all, query) {
+    const within = (value, min, max) => (min === undefined || value >= min) && (max === undefined || value <= max);
+    const time = (date) => (date === undefined ? undefined : date.getTime());
+    const kept = all.filter((one) => (query.id === undefined || one.id.toLowerCase().startsWith(query.id.toLowerCase())) &&
+        (query.name === undefined ||
+            (one.info.name ?? one.id).toLowerCase().startsWith(query.name.toLowerCase())) &&
+        (query.targets === undefined || query.targets.includes("us")) &&
+        (query.isRecoverable === undefined || query.isRecoverable === false) &&
+        within(one.info.vcpu, query.minCpu, query.maxCpu) &&
+        within(one.info.memoryMiB / 1024, query.minMemoryGib, query.maxMemoryGib) &&
+        within(one.info.diskMiB / 1024, query.minDiskGib, query.maxDiskGib) &&
+        within(Date.parse(one.info.createdAt), time(query.createdAtAfter), time(query.createdAtBefore)) &&
+        within(lastActivity(one), time(query.lastActivityAfter), time(query.lastActivityBefore)));
+    const key = query.sort === undefined ? undefined : SORTS[query.sort];
+    if (!key)
+        return query.order === "desc" ? kept.reverse() : kept;
+    const sign = query.order === "asc" ? 1 : -1;
+    return kept.sort((a, b) => {
+        const x = key(a);
+        const y = key(b);
+        return sign * (typeof x === "string" ? x.localeCompare(y) : x - y);
+    });
+}
+/** Readies a new sandbox to run as `user`: the user must be in the image, as
+ * on Daytona. It joins the owner's group, and the working directory takes
+ * that group for what is made in it, so both may change each other's files.
+ * A user the image lacks ends the sandbox and says how to add it. */
+async function asUser(runtime, user) {
+    const ready = await guard("sandbox", () => runtime.exec([
+        "sh",
+        "-c",
+        'id -u "$1" >/dev/null 2>&1 || exit 3; [ "$1" = root ] || { sudo usermod -aG runtime "$1" && sudo chmod 2775 /workspace; }',
+        "sh",
+        user,
+    ])).catch(async (error) => {
+        await runtime.stop({ wait: false }).catch(() => undefined);
+        throw error;
+    });
+    if (ready.exitCode === 0)
+        return;
+    await runtime.stop({ wait: false }).catch(() => undefined);
+    throw new DaytonaError(ready.exitCode === 3
+        ? `The user "${user}" does not exist in this sandbox's image. Add it to the image (RUN useradd -m ${user}), or leave user out to run as the sandbox owner, who has passwordless sudo.`
+        : `The sandbox could not be readied for the user "${user}": ${ready.stderr.trim() || `exit ${ready.exitCode}`}`, 400);
+}
 /** The sandbox with this Runtime id, or the newest live one with this name. */
 async function find(client, idOrName) {
     if (UUID.test(idOrName))

package/dist/daytona/filesystem.js

@@ -81,6 +81,13 @@ export class FileSystem {
     async createFolder(path, mode) {
         const target = await this.#path(path);
         await this.#run(["mkdir", "-p", "-m", mode, "--", target]);
+        await this.#own(target);
+    }
+    /** Gives what this client wrote to create's `user`, so its commands may
+     * change it; the owner's files stay the owner's. */
+    async #own(target) {
+        if (this.#ctx.user)
+            await this.#run(["sudo", "chown", this.#ctx.user, "--", target]);
     }
     async deleteFile(path, recursive = false) {
         const target = await this.#path(path);
@@ -261,6 +268,7 @@ export class FileSystem {
                     ...request,
                     ...(onProgress ? { onProgress } : {}),
                 }));
+            await this.#own(target);
         }
         finally {
             request.signal?.removeEventListener("abort", stopInput);