withruntime 0.9.0 → 0.11.0

package/dist/credentials.js

@@ -12,6 +12,14 @@ export function connectionOrigins(env) {
         auth: apiOrigin(env.RUNTIME_AUTH_URL ?? "https://withruntime.com"),
     };
 }
+/** Browser-issued production credentials must only reach the production API.
+ * CLI and MCP share this boundary, including resumed device requests. */
+export function checkBrowserOrigins(origins) {
+    const local = (origin) => ["localhost", "127.0.0.1", "[::1]"].includes(new URL(origin).hostname);
+    if (!((origins.auth === "https://withruntime.com" && origins.api === "https://api.withruntime.com") ||
+        (local(origins.auth) && local(origins.api))))
+        throw new Error("Browser login supports Runtime's production endpoints or local test endpoints. Check RUNTIME_AUTH_URL and RUNTIME_API_URL.");
+}
 function defaultDirectory(env) {
     const root = env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
     if (!isAbsolute(root))
@@ -93,8 +101,75 @@ export function connectionStore(env, directory = defaultDirectory(env)) {
                     throw error;
             });
     }
+    const lockFile = join(directory, `${name}.lock`);
+    /** ARCHITECTURE.md section 3.9: concurrent CLI processes keep each account's
+     * connection. Serialize the entire read/modify/write, not only each rename.
+     * Never steal a lock: stale cleanup can otherwise delete a new live lock. */
+    async function updateAccounts(update) {
+        await privateDirectory(true);
+        const until = performance.now() + 10_000;
+        let handle;
+        for (;;) {
+            try {
+                handle = await open(lockFile, "wx", 0o600);
+                break;
+            }
+            catch (error) {
+                if (error.code !== "EEXIST")
+                    throw error;
+            }
+            const text = await readPrivate(lockFile, 1024, "credential update lock");
+            let pid;
+            try {
+                pid = JSON.parse(text ?? "null")?.pid;
+            }
+            catch {
+                // The holder may not have finished writing its process id yet.
+            }
+            if (typeof pid === "number" && Number.isSafeInteger(pid) && pid > 0) {
+                try {
+                    process.kill(pid, 0);
+                }
+                catch (error) {
+                    if (error.code === "ESRCH")
+                        throw new Error(`A previous Runtime credential update was interrupted. Remove ${lockFile} and retry.`);
+                }
+            }
+            if (performance.now() >= until)
+                throw new Error(`Another Runtime command is updating saved accounts. Retry when it finishes. If no command is running, remove ${lockFile} and retry.`);
+            await new Promise((resolve) => setTimeout(resolve, 25));
+        }
+        try {
+            await handle.writeFile(JSON.stringify({ pid: process.pid }));
+            return await update();
+        }
+        finally {
+            try {
+                await handle.close();
+            }
+            finally {
+                await unlink(lockFile);
+            }
+        }
+    }
     const pendingFile = join(directory, `${name}.pending.json`);
     const accountsFile = join(directory, `${name}.accounts.json`);
+    /** Active and archived connections must satisfy the same contract: switching
+     * accounts cannot publish a credential the next command refuses to read. */
+    function validConnection(value) {
+        if (value === null || typeof value !== "object")
+            return false;
+        const saved = value;
+        return (saved.version === 1 &&
+            saved.apiOrigin === origins.api &&
+            saved.authOrigin === origins.auth &&
+            typeof saved.key === "string" &&
+            /^rtcloud_[a-f0-9-]{36}_[A-Za-z0-9_-]{43}$/.test(saved.key) &&
+            typeof saved.connectionId === "string" &&
+            typeof saved.orgId === "string" &&
+            typeof saved.agentName === "string" &&
+            (saved.orgName === undefined || typeof saved.orgName === "string"));
+    }
     return {
         async read() {
             const text = await readPrivate(file, 4096, "saved connection");
@@ -107,15 +182,7 @@ export function connectionStore(env, directory = defaultDirectory(env)) {
             catch {
                 throw new Error("Runtime's saved connection is invalid. Connect again.");
             }
-            if (saved.version !== 1 ||
-                saved.apiOrigin !== origins.api ||
-                saved.authOrigin !== origins.auth ||
-                typeof saved.key !== "string" ||
-                !/^rtcloud_[a-f0-9-]{36}_[A-Za-z0-9_-]{43}$/.test(saved.key) ||
-                typeof saved.connectionId !== "string" ||
-                typeof saved.orgId !== "string" ||
-                typeof saved.agentName !== "string" ||
-                (saved.orgName !== undefined && typeof saved.orgName !== "string"))
+            if (!validConnection(saved))
                 throw new Error("Runtime's saved connection is invalid. Connect again.");
             return saved;
         },
@@ -125,12 +192,14 @@ export function connectionStore(env, directory = defaultDirectory(env)) {
         async save(connection) {
             if (connection.apiOrigin !== origins.api || connection.authOrigin !== origins.auth)
                 throw new Error("Connection origins do not match.");
-            const previous = await this.read().catch(() => null);
-            if (previous && previous.orgId !== connection.orgId) {
-                const others = (await this.others()).filter((one) => one.orgId !== previous.orgId && one.orgId !== connection.orgId);
-                await writePrivate(accountsFile, JSON.stringify([previous, ...others].slice(0, SAVED_ACCOUNTS)));
-            }
-            await writePrivate(file, JSON.stringify(connection));
+            return updateAccounts(async () => {
+                const previous = await this.read().catch(() => null);
+                if (previous && previous.orgId !== connection.orgId) {
+                    const others = (await this.others()).filter((one) => one.orgId !== previous.orgId && one.orgId !== connection.orgId);
+                    await writePrivate(accountsFile, JSON.stringify([previous, ...others].slice(0, SAVED_ACCOUNTS)));
+                }
+                await writePrivate(file, JSON.stringify(connection));
+            });
         },
         /** The other accounts this machine has connected, newest first. */
         async others() {
@@ -145,15 +214,7 @@ export function connectionStore(env, directory = defaultDirectory(env)) {
                 return [];
             try {
                 const list = JSON.parse(text);
-                return Array.isArray(list)
-                    ? list.filter((one) => one &&
-                        one.version === 1 &&
-                        one.apiOrigin === origins.api &&
-                        one.authOrigin === origins.auth &&
-                        typeof one.key === "string" &&
-                        /^rtcloud_[a-f0-9-]{36}_[A-Za-z0-9_-]{43}$/.test(one.key) &&
-                        typeof one.orgId === "string")
-                    : [];
+                return Array.isArray(list) ? list.filter(validConnection) : [];
             }
             catch {
                 return [];
@@ -162,21 +223,29 @@ export function connectionStore(env, directory = defaultDirectory(env)) {
         /** Use another saved account's connection, by account id or name. The one
          * in use moves to the saved accounts. Null when none matches. */
         async use(which) {
-            const others = await this.others();
-            const wanted = which.trim().toLowerCase();
-            const chosen = others.find((one) => one.orgId === which) ??
-                others.find((one) => one.orgName?.toLowerCase() === wanted) ??
-                null;
-            if (!chosen)
-                return null;
-            const current = await this.read().catch(() => null);
-            const rest = others.filter((one) => one.orgId !== chosen.orgId);
-            await writePrivate(accountsFile, JSON.stringify((current ? [current, ...rest] : rest).slice(0, SAVED_ACCOUNTS)));
-            await writePrivate(file, JSON.stringify(chosen));
-            return chosen;
+            return updateAccounts(async () => {
+                const others = await this.others();
+                const wanted = which.trim().toLowerCase();
+                const chosen = others.find((one) => one.orgId === which) ??
+                    others.find((one) => one.orgName?.toLowerCase() === wanted) ??
+                    null;
+                if (!chosen)
+                    return null;
+                const current = await this.read().catch(() => null);
+                const rest = others.filter((one) => one.orgId !== chosen.orgId);
+                await writePrivate(accountsFile, JSON.stringify((current ? [current, ...rest] : rest).slice(0, SAVED_ACCOUNTS)));
+                await writePrivate(file, JSON.stringify(chosen));
+                return chosen;
+            });
         },
-        async remove() {
-            await removePrivate(file);
+        /** Forget the expected credential after a remote revoke or refusal. A
+         * concurrent login may have saved another connection during that request. */
+        async remove(expectedKey) {
+            await updateAccounts(async () => {
+                if (expectedKey !== undefined && (await this.read())?.key !== expectedKey)
+                    return;
+                await removePrivate(file);
+            });
         },
         /** A browser approval that was started and not yet answered, so a command
          * that was stopped while it waited picks up the same link and code rather

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

@@ -0,0 +1,162 @@
+import type { RuntimeSandbox } from "./client.js";
+type Live = () => Promise<RuntimeSandbox>;
+export interface ScreenshotRegion {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface ScreenshotOptions {
+    showCursor?: boolean;
+    format?: string;
+    quality?: number;
+    scale?: number;
+}
+export interface Position {
+    x?: number;
+    y?: number;
+}
+export interface ScreenshotResponse {
+    cursorPosition?: Position;
+    /** The image, base64. */
+    screenshot?: string;
+    sizeBytes?: number;
+}
+export interface DisplayInfo {
+    height?: number;
+    id?: number;
+    isActive?: boolean;
+    width?: number;
+    x?: number;
+    y?: number;
+}
+export interface WindowInfo {
+    height?: number;
+    id?: number;
+    isActive?: boolean;
+    title?: string;
+    width?: number;
+    x?: number;
+    y?: number;
+}
+export interface ProcessStatus {
+    autoRestart?: boolean;
+    pid?: number;
+    priority?: number;
+    running?: boolean;
+}
+export interface ComputerUseStartResponse {
+    message?: string;
+    status?: Record<string, ProcessStatus>;
+}
+export type ComputerUseStopResponse = ComputerUseStartResponse;
+export interface ComputerUseStatusResponse {
+    status?: string;
+}
+export interface Recording {
+    durationSeconds?: number;
+    endTime?: string;
+    fileName: string;
+    filePath: string;
+    id: string;
+    sizeBytes?: number;
+    startTime: string;
+    status: string;
+}
+export interface ListRecordingsResponse {
+    recordings: Recording[];
+}
+/** `sandbox.computerUse.mouse`. */
+export declare class Mouse {
+    #private;
+    /** Use sandbox.computerUse.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>;
+}
+/** `sandbox.computerUse.keyboard`. Key names are Daytona's (enter, esc,
+ * ctrl, cmd, pageup, f5) or xdotool's (Return, Escape, Prior). */
+export declare class Keyboard {
+    #private;
+    /** Use sandbox.computerUse.keyboard. */
+    constructor(live: Live);
+    /** Types `text`, `delay` milliseconds between keys. */
+    type(text: string, delay?: number): Promise<void>;
+    press(key: string, modifiers?: string[]): Promise<void>;
+    /** A combination such as "ctrl+c" or "ctrl+shift+t". */
+    hotkey(keys: string): Promise<void>;
+}
+/** `sandbox.computerUse.screenshot`: the whole screen, PNG or JPEG. */
+export declare class Screenshot {
+    #private;
+    /** Use sandbox.computerUse.screenshot. */
+    constructor(live: Live);
+    takeFullScreen(showCursor?: boolean): Promise<ScreenshotResponse>;
+    takeRegion(_region: ScreenshotRegion, _showCursor?: boolean): Promise<ScreenshotResponse>;
+    takeCompressed(options?: ScreenshotOptions): Promise<ScreenshotResponse>;
+    takeCompressedRegion(_region: ScreenshotRegion, _options?: ScreenshotOptions): Promise<ScreenshotResponse>;
+}
+/** `sandbox.computerUse.display`. */
+export declare class Display {
+    #private;
+    /** Use sandbox.computerUse.display. */
+    constructor(live: Live);
+    /** The one screen, its size read from a screenshot. */
+    getInfo(): Promise<{
+        displays?: DisplayInfo[];
+    }>;
+    getWindows(): Promise<{
+        windows?: WindowInfo[];
+    }>;
+}
+/** `sandbox.computerUse.recording`: screen recordings to MP4. */
+export declare class RecordingService {
+    #private;
+    /** Use sandbox.computerUse.recording. */
+    constructor(live: Live);
+    /** Starts recording. Runtime names the file itself; `label` is not used. */
+    start(_label?: string): Promise<Recording>;
+    stop(id: string): Promise<Recording>;
+    list(): Promise<ListRecordingsResponse>;
+    get(id: string): Promise<Recording>;
+    delete(id: string): Promise<void>;
+    /** Saves the MP4 to `localPath`, making its directory. */
+    download(id: string, localPath: string): Promise<void>;
+}
+/** `sandbox.computerUse.accessibility`: Runtime's desktop has no
+ * accessibility tree; every method throws NotSupportedError. */
+export declare class Accessibility {
+    #private;
+    getTree(_options?: unknown): Promise<never>;
+    findNodes(_options?: unknown): Promise<never>;
+    focusNode(_id: string): Promise<never>;
+    invokeNode(_id: string, _action?: string): Promise<never>;
+    setNodeValue(_id: string, _value: string): Promise<never>;
+}
+/** `sandbox.computerUse`: a Linux desktop driven like a person would. */
+export declare class ComputerUse {
+    #private;
+    readonly mouse: Mouse;
+    readonly keyboard: Keyboard;
+    readonly screenshot: Screenshot;
+    readonly display: Display;
+    readonly recording: RecordingService;
+    readonly accessibility: Accessibility;
+    /** Use sandbox.computerUse. */
+    constructor(live: Live);
+    /** Starts the desktop. A sandbox's first start installs it, which takes a
+     * minute or two; this waits for that. */
+    start(): Promise<ComputerUseStartResponse>;
+    stop(): Promise<ComputerUseStopResponse>;
+    /** "active" while the desktop runs, else "inactive". */
+    getStatus(): Promise<ComputerUseStatusResponse>;
+    getProcessStatus(_processName: string): Promise<never>;
+    restartProcess(_processName: string): Promise<never>;
+    getProcessLogs(_processName: string): Promise<never>;
+    getProcessErrors(_processName: string): Promise<never>;
+}
+export {};

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) };
+}