withruntime 0.10.0 → 0.11.1

package/dist/daytona/daytona.js

@@ -1,6 +1,7 @@
 import { clientFor, } from "./client.js";
 import { DaytonaError, DaytonaNotFoundError, guard, NotSupportedError } from "./errors.js";
-import { networkRules, notFound, retentionDays, Sandbox, windowSeconds, } from "./sandbox.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()`
    makes a Runtime sandbox with Daytona's defaults. */
 /** Daytona's default machine: 1 vCPU, 1 GiB memory, 3 GiB disk (checked
@@ -14,6 +15,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 +195,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
                 ? {}
@@ -203,9 +212,15 @@ export class Daytona {
                     memoryMiB: Math.round(resources.memory * 1024),
                     diskMiB: Math.round(resources.disk * 1024),
                 }),
-            timeoutSeconds: lifecycle.deadline
-                ? Math.max(60, Math.min(lifecycle.windowSeconds, Math.floor((lifecycle.deadline - Date.now()) / 1000)))
-                : lifecycle.windowSeconds,
+            // A time to live is a time limit, kept by the lease. Without one there
+            // is none: it runs while it works and autoStopInterval is its idle
+            // pause, counted by the sandbox itself, so a long command is never
+            // frozen for want of calls from this client (0300).
+            ...(lifecycle.deadline
+                ? {
+                    timeoutSeconds: Math.max(60, Math.min(lifecycle.windowSeconds, Math.floor((lifecycle.deadline - Date.now()) / 1000))),
+                }
+                : { idlePauseSeconds: idlePauseOf(lifecycle.autoStopInterval) }),
             onLeaseEnd: lifecycle.ephemeral || lifecycle.deadline ? "stop" : "pause",
             ...(params.name ? { name: params.name } : {}),
             ...(labels ? { labels } : {}),
@@ -216,6 +231,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 +250,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,26 +304,44 @@ 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,
-            lifecycle: {
-                windowSeconds: runtime.info.timeoutSeconds,
-                ephemeral: onLeaseEnd === "stop",
-                autoStopInterval: Math.round(runtime.info.timeoutSeconds / 60),
-                autoArchiveInterval: 0,
-                autoDeleteInterval: -1,
-            },
+            ...(user ? { user } : {}),
+            lifecycle: runtime.info.timeoutSeconds
+                ? {
+                    windowSeconds: runtime.info.timeoutSeconds,
+                    idleSeconds: runtime.info.timeoutSeconds,
+                    ephemeral: onLeaseEnd === "stop",
+                    autoStopInterval: Math.round(runtime.info.timeoutSeconds / 60),
+                    autoArchiveInterval: 0,
+                    autoDeleteInterval: -1,
+                }
+                : {
+                    // No time limit: its idle pause is its autoStopInterval.
+                    windowSeconds: LEASE_MAX_SECONDS,
+                    idleSeconds: Infinity,
+                    ephemeral: onLeaseEnd === "stop",
+                    autoStopInterval: Math.round((runtime.info.idlePauseSeconds ?? 0) / 60),
+                    autoArchiveInterval: 0,
+                    autoDeleteInterval: -1,
+                },
         });
     }
     /** 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 +351,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 +377,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 +435,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 +452,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 +460,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);

package/dist/daytona/index.d.ts

@@ -1,8 +1,9 @@
 export { Daytona, CodeLanguage, SnapshotService, VolumeService, DEFAULT_RESOURCES, DEFAULT_AUTO_STOP_MINUTES, lifecycleOf, type CreateSandboxBaseParams, type CreateSandboxFromImageParams, type CreateSandboxFromSnapshotParams, type CreateSnapshotParams, type ForkSandboxParams, type ListSandboxesQuery, type PaginatedSnapshots, type Resources, type Snapshot, type Volume, type VolumeMount, } from "./daytona.js";
 export { Sandbox, CodeInterpreter, networkRules, windowSeconds, type ExecutionError, type ExecutionResult, type InterpreterContext, type OutputMessage, type PortPreviewUrl, } from "./sandbox.js";
-export { Process, CodeRunParams, type Command, type ExecuteResponse, type Session, type SessionCommandLogsResponse, type SessionExecuteRequest, type SessionExecuteResponse, } from "./process.js";
+export { Process, CodeRunParams, PtyHandle, type PtyConnectOptions, type PtyCreateOptions, type PtyResult, type PtySessionInfo, type Command, type ExecuteResponse, type Session, type SessionCommandLogsResponse, type SessionExecuteRequest, type SessionExecuteResponse, } from "./process.js";
 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 { resolvePath } from "./context.js";
 export type { DaytonaConfig, WithRuntime } from "./client.js";
@@ -18,31 +19,6 @@ export declare const SandboxState: {
     readonly DESTROYED: "destroyed";
 };
 export type SandboxState = (typeof SandboxState)[keyof typeof SandboxState];
-export declare const ComputerUse: {
-    (...args: unknown[]): never;
-    new (...args: unknown[]): never;
-    readonly [key: string]: (...args: unknown[]) => never;
-};
-export declare const Mouse: {
-    (...args: unknown[]): never;
-    new (...args: unknown[]): never;
-    readonly [key: string]: (...args: unknown[]) => never;
-};
-export declare const Keyboard: {
-    (...args: unknown[]): never;
-    new (...args: unknown[]): never;
-    readonly [key: string]: (...args: unknown[]) => never;
-};
-export declare const Screenshot: {
-    (...args: unknown[]): never;
-    new (...args: unknown[]): never;
-    readonly [key: string]: (...args: unknown[]) => never;
-};
-export declare const Display: {
-    (...args: unknown[]): never;
-    new (...args: unknown[]): never;
-    readonly [key: string]: (...args: unknown[]) => never;
-};
 export declare const LspLanguageId: {
     (...args: unknown[]): never;
     new (...args: unknown[]): never;

package/dist/daytona/index.js

@@ -9,9 +9,10 @@
 import { NotSupportedError } from "./errors.js";
 export { Daytona, CodeLanguage, SnapshotService, VolumeService, DEFAULT_RESOURCES, DEFAULT_AUTO_STOP_MINUTES, lifecycleOf, } from "./daytona.js";
 export { Sandbox, CodeInterpreter, networkRules, windowSeconds, } from "./sandbox.js";
-export { Process, CodeRunParams, } from "./process.js";
+export { Process, CodeRunParams, PtyHandle, } from "./process.js";
 export { FileSystem, } from "./filesystem.js";
 export { Git } from "./git.js";
+export { Accessibility, ComputerUse, Display, Keyboard, Mouse, RecordingService, Screenshot, } from "./computer-use.js";
 export { Image } from "./image.js";
 export { resolvePath } from "./context.js";
 export * from "./errors.js";
@@ -41,10 +42,4 @@ function unsupportedExport(name, alternative) {
         },
     });
 }
-const DESKTOP = "Use Runtime's desktop: `await sandbox.withruntime.desktop.start()`.";
-export const ComputerUse = unsupportedExport("computer use", DESKTOP);
-export const Mouse = unsupportedExport("computer use (Mouse)", DESKTOP);
-export const Keyboard = unsupportedExport("computer use (Keyboard)", DESKTOP);
-export const Screenshot = unsupportedExport("computer use (Screenshot)", DESKTOP);
-export const Display = unsupportedExport("computer use (Display)", DESKTOP);
 export const LspLanguageId = unsupportedExport("language servers", "Start one in a session with process.executeSessionCommand(..., { runAsync: true }).");

package/dist/daytona/process.d.ts

@@ -1,3 +1,4 @@
+import type { Terminal } from "../sandbox.js";
 import { quote, type SandboxContext } from "./context.js";
 /** Daytona's ExecuteResponse. `result` is the command's stdout and stderr
  * together, in the order they were written. */
@@ -76,11 +77,67 @@ export declare class Process {
     deleteSession(sessionId: string): Promise<void>;
     getEntrypointSession(): Promise<never>;
     getEntrypointLogs(): Promise<never>;
-    createPty(): Promise<never>;
-    connectPty(): Promise<never>;
-    listPtySessions(): Promise<never>;
-    getPtySessionInfo(): Promise<never>;
-    killPtySession(): Promise<never>;
-    resizePtySession(): Promise<never>;
+    /** Starts an interactive shell on a terminal (a PTY) that outlives this
+     * connection: disconnect() leaves it running, connectPty(id) attaches
+     * again, killPtySession(id) ends it. On Runtime it is a process started
+     * with a terminal, found again by its id among the sandbox's processes. */
+    createPty(options: PtyCreateOptions & Partial<PtyConnectOptions>): Promise<PtyHandle>;
+    /** Attaches to a running PTY session. Output it printed before arrives
+     * first, then what it prints from now on. */
+    connectPty(sessionId: string, options?: Partial<PtyConnectOptions>): Promise<PtyHandle>;
+    listPtySessions(): Promise<PtySessionInfo[]>;
+    getPtySessionInfo(sessionId: string): Promise<PtySessionInfo>;
+    /** Ends the session's shell and everything it runs. */
+    killPtySession(sessionId: string): Promise<void>;
+    resizePtySession(sessionId: string, cols: number, rows: number): Promise<PtySessionInfo>;
+}
+/** Daytona's PtyCreateOptions. */
+export interface PtyCreateOptions {
+    id: string;
+    cwd?: string;
+    envs?: Record<string, string>;
+    cols?: number;
+    rows?: number;
+}
+/** Daytona's PtyConnectOptions. */
+export interface PtyConnectOptions {
+    onData: (data: Uint8Array) => void | Promise<void>;
+}
+/** Daytona's PtyResult. */
+export interface PtyResult {
+    exitCode?: number;
+    error?: string;
+}
+/** Daytona's PtySessionInfo. */
+export interface PtySessionInfo {
+    active: boolean;
+    cols: number;
+    createdAt: string;
+    cwd: string;
+    envs: Record<string, string>;
+    id: string;
+    lazyStart: boolean;
+    rows: number;
+}
+/** One connection to a PTY session, Daytona's PtyHandle over Runtime's
+ * terminal WebSocket. */
+export declare class PtyHandle {
+    #private;
+    readonly sessionId: string;
+    /** Use process.createPty or process.connectPty. */
+    constructor(terminal: Terminal, sessionId: string, resize: (cols: number, rows: number) => Promise<PtySessionInfo>, kill: () => Promise<void>);
+    get exitCode(): number | undefined;
+    get error(): string | undefined;
+    isConnected(): boolean;
+    /** Resolves at once: the handle is returned connected. */
+    waitForConnection(): Promise<void>;
+    sendInput(data: string | Uint8Array): Promise<void>;
+    resize(cols: number, rows: number): Promise<PtySessionInfo>;
+    /** Closes this connection; the session keeps running. */
+    disconnect(): Promise<void>;
+    /** Resolves when the session ends (or this connection closes) with its
+     * exit code, or `error` saying why there is none. */
+    wait(): Promise<PtyResult>;
+    kill(): Promise<void>;
 }
 export { quote };