withruntime 0.8.3 → 0.9.0

package/dist/vercel/filesystem.d.ts

@@ -5,7 +5,10 @@ export interface FsContext {
     readonly name: string;
     files(): Promise<Files>;
     /** Runs argv without a shell; resolves with the exit code and output. */
-    run(argv: string[]): Promise<{
+    run(argv: string[], options?: {
+        stdin?: Uint8Array;
+        signal?: AbortSignal;
+    }): Promise<{
         exitCode: number | null;
         stdout: string;
         stderr: string;
@@ -28,8 +31,8 @@ export declare class Stats {
     readonly ctimeMs: number;
     readonly birthtime: Date;
     readonly birthtimeMs: number;
-    readonly uid = 0;
-    readonly gid = 0;
+    readonly uid: number;
+    readonly gid: number;
     readonly dev = 0;
     readonly ino = 0;
     readonly nlink = 1;
@@ -86,7 +89,7 @@ export declare class FileSystem {
     mkdir(path: string, options?: {
         recursive?: boolean;
         signal?: AbortSignal;
-    } | number): Promise<string | undefined>;
+    } | number): Promise<void>;
     readdir(path: string, options?: {
         signal?: AbortSignal;
         withFileTypes?: false;
@@ -95,14 +98,14 @@ export declare class FileSystem {
         signal?: AbortSignal;
         withFileTypes: true;
     }): Promise<Dirent[]>;
-    lstat(path: string, _options?: {
+    lstat(path: string, options?: {
         signal?: AbortSignal;
     }): Promise<Stats>;
     /** Follows symbolic links. */
     stat(path: string, options?: {
         signal?: AbortSignal;
     }): Promise<Stats>;
-    unlink(path: string, _options?: {
+    unlink(path: string, options?: {
         signal?: AbortSignal;
     }): Promise<void>;
     rm(path: string, options?: {
@@ -110,40 +113,40 @@ export declare class FileSystem {
         force?: boolean;
         signal?: AbortSignal;
     }): Promise<void>;
-    rmdir(path: string, _options?: {
+    rmdir(path: string, options?: {
         signal?: AbortSignal;
     }): Promise<void>;
-    rename(oldPath: string, newPath: string, _options?: {
+    rename(oldPath: string, newPath: string, options?: {
         signal?: AbortSignal;
     }): Promise<void>;
-    copyFile(src: string, dest: string, _options?: {
+    copyFile(src: string, dest: string, options?: {
         signal?: AbortSignal;
     }): Promise<void>;
-    access(path: string, _options?: {
+    access(path: string, options?: {
         signal?: AbortSignal;
     }): Promise<void>;
-    exists(path: string, _options?: {
+    exists(path: string, options?: {
         signal?: AbortSignal;
     }): Promise<boolean>;
-    chmod(path: string, mode: number | string, _options?: {
+    chmod(path: string, mode: number | string, options?: {
         signal?: AbortSignal;
     }): Promise<void>;
-    chown(path: string, uid: number, gid: number, _options?: {
+    chown(path: string, uid: number, gid: number, options?: {
         signal?: AbortSignal;
     }): Promise<void>;
-    symlink(target: string, path: string, _options?: {
+    symlink(target: string, path: string, options?: {
         signal?: AbortSignal;
     }): Promise<void>;
-    readlink(path: string, _options?: {
+    readlink(path: string, options?: {
         signal?: AbortSignal;
     }): Promise<string>;
-    realpath(path: string, _options?: {
+    realpath(path: string, options?: {
         signal?: AbortSignal;
     }): Promise<string>;
-    truncate(path: string, len?: number, _options?: {
+    truncate(path: string, len?: number, options?: {
         signal?: AbortSignal;
     }): Promise<void>;
-    mkdtemp(prefix: string, _options?: {
+    mkdtemp(prefix: string, options?: {
         signal?: AbortSignal;
     }): Promise<string>;
 }

package/dist/vercel/filesystem.js

@@ -13,8 +13,8 @@ export class Stats {
     ctimeMs;
     birthtime;
     birthtimeMs;
-    uid = 0;
-    gid = 0;
+    uid;
+    gid;
     dev = 0;
     ino = 0;
     nlink = 1;
@@ -24,6 +24,8 @@ export class Stats {
     #type;
     constructor(entry) {
         this.#type = entry.type;
+        this.uid = entry.uid ?? 0;
+        this.gid = entry.gid ?? 0;
         this.size = entry.size;
         const typeBits = entry.type === "directory" ? 0o040000 : entry.type === "symlink" ? 0o120000 : 0o100000;
         this.mode = typeBits | ((parseInt(entry.mode, 8) || 0) & 0o7777);
@@ -61,7 +63,8 @@ export class Dirent {
     #type;
     constructor(entry, parent) {
         this.name = entry.name;
-        this.parentPath = this.path = parent;
+        this.parentPath = parent;
+        this.path = entry.path;
         this.#type = entry.type;
     }
     isFile() {
@@ -111,18 +114,27 @@ export class FileSystem {
         }
     }
     /** Runs a coreutils command; a failure is a Node-style error. */
-    async #run(syscall, path, argv) {
-        const result = await this.#call(syscall, path, () => this.#ctx.run(argv));
+    async #run(syscall, path, argv, options) {
+        options?.signal?.throwIfAborted();
+        const result = await this.#call(syscall, path, () => this.#ctx.run(argv, options));
         if (result.exitCode === 0)
             return result.stdout;
         if (/No such file or directory/.test(result.stderr))
             throw fsError("ENOENT", syscall, path);
+        if (syscall === "unlink" || syscall === "rm")
+            throw fsError("EACCES", syscall, path);
+        if (syscall === "rmdir" && /not empty/i.test(result.stderr))
+            throw fsError("ENOTEMPTY", syscall, path);
+        if (syscall === "readlink")
+            throw fsError("EINVAL", syscall, path);
         if (/File exists/.test(result.stderr))
             throw fsError("EEXIST", syscall, path);
         if (/Is a directory/.test(result.stderr))
             throw fsError("EISDIR", syscall, path);
         if (/Not a directory/.test(result.stderr))
             throw fsError("ENOTDIR", syscall, path);
+        if (/Permission denied/.test(result.stderr))
+            throw fsError("EACCES", syscall, path);
         throw Object.assign(new Error(`${syscall} '${path}' failed: ${result.stderr.trim()}`), {
             code: "EIO",
             syscall,
@@ -131,6 +143,8 @@ export class FileSystem {
     }
     async readFile(path, options) {
         const target = this.#ctx.resolve(path);
+        if (options && typeof options === "object")
+            options.signal?.throwIfAborted();
         const files = await this.#ctx.files();
         const bytes = await this.#call("open", target, () => files.read(target, typeof options === "object" && options?.signal ? { signal: options.signal } : {}));
         const encoding = encodingOf(options);
@@ -139,37 +153,64 @@ export class FileSystem {
     }
     async writeFile(path, data, options) {
         const target = this.#ctx.resolve(path);
+        if (options && typeof options === "object")
+            options.signal?.throwIfAborted();
         const files = await this.#ctx.files();
-        await this.#call("open", target, () => files.write(target, bytesOf(data, encodingOf(options))));
+        await this.#call("open", target, () => files.write(target, bytesOf(data, encodingOf(options)), typeof options === "object" && options.signal ? { signal: options.signal } : {}));
     }
     async appendFile(path, data, options) {
         const target = this.#ctx.resolve(path);
+        // Never read-modify-write: another caller may be appending too. The
+        // shell opens with O_APPEND and cat streams bytes without Python. Exec
+        // stdin is limited to 1 MiB; larger input uses the chunked files API.
+        const bytes = bytesOf(data, encodingOf(options));
+        const signal = typeof options === "object" ? options.signal : undefined;
+        signal?.throwIfAborted();
+        if (bytes.byteLength <= 1_048_576) {
+            await this.#run("open", target, ["sh", "-c", 'cat >> "$1"', "runtime-append", target], {
+                stdin: bytes,
+                ...(signal ? { signal } : {}),
+            });
+            return;
+        }
+        if (options && typeof options === "object")
+            options.signal?.throwIfAborted();
         const files = await this.#ctx.files();
-        const before = await files.read(target).catch((error) => {
-            if (missing(error))
-                return new Uint8Array();
-            throw translate(error, this.#ctx.name);
-        });
-        await this.#call("open", target, () => files.write(target, Buffer.concat([before, bytesOf(data, encodingOf(options))])));
+        const staging = `/workspace/.runtime/append/${crypto.randomUUID()}`;
+        try {
+            await this.#call("open", target, () => files.write(staging, bytes, { mode: 0o600, ...(signal ? { signal } : {}) }));
+            await this.#run("open", target, ["sh", "-c", 'cat "$1" >> "$2"', "runtime-append", staging, target], signal ? { signal } : undefined);
+        }
+        finally {
+            // A cleanup failure must not invite retrying a successful append.
+            await files.remove(staging).catch(() => undefined);
+        }
     }
     async mkdir(path, options) {
         const target = this.#ctx.resolve(path);
         const recursive = typeof options === "object" && options.recursive === true;
-        await this.#run("mkdir", target, recursive ? ["mkdir", "-p", target] : ["mkdir", target]);
-        return recursive ? target : undefined;
+        await this.#run("mkdir", target, recursive ? ["mkdir", "-p", "--", target] : ["mkdir", "--", target], typeof options === "object" ? options : {});
     }
     async readdir(path, options = {}) {
         const target = this.#ctx.resolve(path);
+        if (options && typeof options === "object")
+            options.signal?.throwIfAborted();
         const files = await this.#ctx.files();
-        const entries = await this.#call("scandir", target, () => files.list(target, { depth: 1, hidden: true }));
+        const entries = await this.#call("scandir", target, () => files.list(target, {
+            depth: 1,
+            hidden: options.withFileTypes === true,
+            ...(options.signal ? { signal: options.signal } : {}),
+        }));
         return options.withFileTypes
             ? entries.map((entry) => new Dirent(entry, target))
-            : entries.map((entry) => entry.name);
+            : entries.filter((entry) => !entry.name.startsWith(".")).map((entry) => entry.name);
     }
-    async lstat(path, _options = {}) {
+    async lstat(path, options = {}) {
         const target = this.#ctx.resolve(path);
+        if (options && typeof options === "object")
+            options.signal?.throwIfAborted();
         const files = await this.#ctx.files();
-        const found = await this.#call("lstat", target, () => files.stat(target));
+        const found = await this.#call("lstat", target, () => files.stat(target, options));
         if (!found.exists)
             throw fsError("ENOENT", "lstat", target);
         return new Stats(found);
@@ -180,69 +221,75 @@ export class FileSystem {
         const first = await this.lstat(target, options);
         if (!first.isSymbolicLink())
             return first;
-        return this.lstat(await this.realpath(target), options);
+        return this.lstat(await this.realpath(target, options), options);
     }
-    async unlink(path, _options = {}) {
+    async unlink(path, options = {}) {
         const target = this.#ctx.resolve(path);
-        await this.#run("unlink", target, ["rm", "--", target]);
+        await this.#run("unlink", target, ["rm", "--", target], options);
     }
     async rm(path, options = {}) {
         const target = this.#ctx.resolve(path);
         const flags = `${options.recursive ? "r" : ""}${options.force ? "f" : ""}`;
-        await this.#run("rm", target, flags ? ["rm", `-${flags}`, "--", target] : ["rm", "--", target]);
+        await this.#run("rm", target, flags ? ["rm", `-${flags}`, "--", target] : ["rm", "--", target], options);
     }
-    async rmdir(path, _options = {}) {
+    async rmdir(path, options = {}) {
         const target = this.#ctx.resolve(path);
-        await this.#run("rmdir", target, ["rmdir", "--", target]);
+        await this.#run("rmdir", target, ["rmdir", "--", target], options);
     }
-    async rename(oldPath, newPath, _options = {}) {
+    async rename(oldPath, newPath, options = {}) {
         const from = this.#ctx.resolve(oldPath);
         const to = this.#ctx.resolve(newPath);
+        if (options && typeof options === "object")
+            options.signal?.throwIfAborted();
         const files = await this.#ctx.files();
-        await this.#call("rename", from, () => files.rename(from, to, { overwrite: true }));
+        await this.#call("rename", from, () => files.rename(from, to, { overwrite: true, ...options }));
     }
-    async copyFile(src, dest, _options = {}) {
+    async copyFile(src, dest, options = {}) {
         const from = this.#ctx.resolve(src);
         const to = this.#ctx.resolve(dest);
-        await this.#run("copyfile", from, ["cp", "--", from, to]);
+        await this.#run("copyfile", from, ["cp", "--", from, to], options);
     }
-    async access(path, _options = {}) {
+    async access(path, options = {}) {
         const target = this.#ctx.resolve(path);
-        if (!(await this.exists(target)))
+        if (!(await this.exists(target, options)))
             throw fsError("ENOENT", "access", target);
     }
-    async exists(path, _options = {}) {
+    async exists(path, options = {}) {
         const target = this.#ctx.resolve(path);
-        const files = await this.#ctx.files();
-        return this.#call("access", target, () => files.exists(target));
-    }
-    async chmod(path, mode, _options = {}) {
+        if (options && typeof options === "object")
+            options.signal?.throwIfAborted();
+        // The native stat is lstat: a dangling link exists there. Vercel's public
+        // exists/access follow the target, matching test -e in its published SDK.
+        const result = await this.#call("access", target, () => this.#ctx.run(["test", "-e", target], options));
+        return result.exitCode === 0;
+    }
+    async chmod(path, mode, options = {}) {
         const target = this.#ctx.resolve(path);
         const octal = typeof mode === "number" ? mode.toString(8) : mode;
-        await this.#run("chmod", target, ["chmod", octal, "--", target]);
+        await this.#run("chmod", target, ["chmod", octal, "--", target], options);
     }
-    async chown(path, uid, gid, _options = {}) {
+    async chown(path, uid, gid, options = {}) {
         const target = this.#ctx.resolve(path);
-        await this.#run("chown", target, ["sudo", "chown", `${uid}:${gid}`, "--", target]);
+        await this.#run("chown", target, ["sudo", "chown", `${uid}:${gid}`, "--", target], options);
     }
-    async symlink(target, path, _options = {}) {
+    async symlink(target, path, options = {}) {
         const link = this.#ctx.resolve(path);
-        await this.#run("symlink", link, ["ln", "-s", "--", target, link]);
+        await this.#run("symlink", link, ["ln", "-s", "--", target, link], options);
     }
-    async readlink(path, _options = {}) {
+    async readlink(path, options = {}) {
         const target = this.#ctx.resolve(path);
-        return (await this.#run("readlink", target, ["readlink", "--", target])).replace(/\n$/, "");
+        return (await this.#run("readlink", target, ["readlink", "--", target], options)).replace(/\n$/, "");
     }
-    async realpath(path, _options = {}) {
+    async realpath(path, options = {}) {
         const target = this.#ctx.resolve(path);
-        return (await this.#run("realpath", target, ["realpath", "-e", "--", target])).replace(/\n$/, "");
+        return (await this.#run("realpath", target, ["realpath", "-e", "--", target], options)).replace(/\n$/, "");
     }
-    async truncate(path, len = 0, _options = {}) {
+    async truncate(path, len = 0, options = {}) {
         const target = this.#ctx.resolve(path);
-        await this.#run("open", target, ["truncate", "-s", String(len), "--", target]);
+        await this.#run("open", target, ["truncate", "-s", String(len), "--", target], options);
     }
-    async mkdtemp(prefix, _options = {}) {
+    async mkdtemp(prefix, options = {}) {
         const base = this.#ctx.resolve(prefix);
-        return (await this.#run("mkdtemp", base, ["mktemp", "-d", `${base}XXXXXX`])).replace(/\n$/, "");
+        return (await this.#run("mkdtemp", base, ["mktemp", "-d", `${base}XXXXXX`], options)).replace(/\n$/, "");
     }
 }

package/dist/vercel/sandbox.js

@@ -111,15 +111,15 @@ function statusOf(state) {
 /** Runtime's `/workspace` stands for Vercel's `/vercel/sandbox`: relative
  * paths resolve against it, and paths under /vercel/sandbox are rewritten. */
 export function toRuntimePath(path, cwd) {
-    const base = cwd === undefined ? HOME : toVercelPath(cwd);
-    const absolute = path.startsWith("/") ? path : `${base}/${path.replace(/^\.\/?/, "")}`;
+    const base = cwd === undefined ? HOME : toVercelPath(cwd).replace(/\/+$/, "");
+    const absolute = path.startsWith("/") ? path : `${base}/${path.replace(/^(?:\.(?:\/+|$))+/, "")}`;
     const normal = absolute.replace(/\/+$/, "") || "/";
     if (normal === HOME || normal.startsWith(`${HOME}/`))
         return RUNTIME_HOME + normal.slice(HOME.length);
     return normal;
 }
 function toVercelPath(path) {
-    return path.startsWith("/") ? path : `${HOME}/${path.replace(/^\.\/?/, "")}`;
+    return path.startsWith("/") ? path : `${HOME}/${path.replace(/^(?:\.(?:\/+|$))+/, "")}`;
 }
 /** A sandbox with Vercel's methods. `sandbox.withruntime` is the Runtime
  * sandbox underneath, for anything Vercel has no name for. */
@@ -143,9 +143,9 @@ export class Sandbox {
         this.fs = new FileSystem({
             name: this.name,
             files: async () => (await this.#live()).files,
-            run: async (argv) => {
+            run: async (argv, options) => {
                 const live = await this.#live();
-                return live.exec(argv);
+                return live.exec(argv, options);
             },
             resolve: (path, cwd) => toRuntimePath(path, cwd),
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "withruntime",
-  "version": "0.8.3",
+  "version": "0.9.0",
   "license": "Apache-2.0",
   "mcpName": "com.withruntime/runtime",
   "type": "module",
@@ -59,6 +59,41 @@
       "types": "./dist/ai-harness/index.d.ts",
       "import": "./dist/ai-harness/index.js",
       "default": "./dist/ai-harness/index.js"
+    },
+    "./runloop": {
+      "types": "./dist/runloop/index.d.ts",
+      "import": "./dist/runloop/index.js",
+      "default": "./dist/runloop/index.js"
+    },
+    "./codesandbox": {
+      "types": "./dist/codesandbox/index.d.ts",
+      "import": "./dist/codesandbox/index.js",
+      "default": "./dist/codesandbox/index.js"
+    },
+    "./sprites": {
+      "types": "./dist/sprites/index.d.ts",
+      "import": "./dist/sprites/index.js",
+      "default": "./dist/sprites/index.js"
+    },
+    "./freestyle": {
+      "types": "./dist/freestyle/index.d.ts",
+      "import": "./dist/freestyle/index.js",
+      "default": "./dist/freestyle/index.js"
+    },
+    "./modal": {
+      "types": "./dist/modal/index.d.ts",
+      "import": "./dist/modal/index.js",
+      "default": "./dist/modal/index.js"
+    },
+    "./cloudflare": {
+      "workerd": {
+        "types": "./dist/cloudflare/worker.d.ts",
+        "import": "./dist/cloudflare/worker.js",
+        "default": "./dist/cloudflare/worker.js"
+      },
+      "types": "./dist/cloudflare/index.d.ts",
+      "import": "./dist/cloudflare/index.js",
+      "default": "./dist/cloudflare/index.js"
     }
   },
   "bin": {
@@ -72,7 +107,9 @@
     "DAYTONA.md",
     "VERCEL.md",
     "BLAXEL.md",
-    "LICENSE"
+    "LICENSE",
+    "COMPATIBILITY.md",
+    "compatibility-lock.json"
   ],
   "engines": {
     "node": ">=22.12"
@@ -86,12 +123,17 @@
     "test:java": "bun ../../sdks/java/scripts/check.ts",
     "test:ruby": "bun ../../sdks/ruby/scripts/check.ts",
     "test:python": "bun scripts/test-python.ts",
-    "test:go": "bun scripts/test-go.ts"
+    "test:go": "bun scripts/test-go.ts",
+    "compat:upstream": "bun scripts/check-upstream.ts",
+    "test:compat": "bun test tests/e2b tests/daytona tests/vercel tests/blaxel tests/compat tests/drop-in-isolation.test.ts tests/drop-in-paths.test.ts tests/process-input.test.ts tests/watch-reentrant.test.ts tests/upstream-check.test.ts tests/process-output.test.ts tests/prepare-compatibility.test.ts",
+    "compat:prepare": "bun scripts/prepare-compatibility.ts",
+    "compat:oracle": "bun oracle/check.mjs"
   },
   "devDependencies": {
     "@ai-sdk/harness": "1.0.124",
     "@anthropic-ai/claude-agent-sdk": "0.3.277",
     "@anthropic-ai/sdk": "0.128.0",
+    "@cloudflare/workers-types": "5.20260929.1",
     "@google/genai": "2.24.0",
     "@mastra/core": "1.71.0",
     "@mistralai/mistralai": "2.7.0",