@bytecodealliance/preview2-shim 0.18.1 → 0.19.0

package/dist/nodejs/filesystem.js

@@ -0,0 +1,758 @@
+import { earlyDispose, inputStreamCreate, ioCall, outputStreamCreate, registerDispose, } from "../io/worker-io.js";
+import { FILE, INPUT_STREAM_CREATE, OUTPUT_STREAM_CREATE } from "../io/calls.js";
+import { closeSync, constants, fdatasyncSync, fstatSync, fsyncSync, ftruncateSync, futimesSync, linkSync, lstatSync, lutimesSync, mkdirSync, opendirSync, openSync, readlinkSync, readSync, renameSync, rmdirSync, statSync, symlinkSync, unlinkSync, utimesSync, writeSync, } from "node:fs";
+import { platform } from "node:process";
+const symbolDispose = Symbol.dispose || Symbol.for("dispose");
+const isWindows = platform === "win32";
+const isMac = platform === "darwin";
+const nsMagnitude = 1000000000n;
+function nsToDateTime(ns) {
+    const seconds = ns / nsMagnitude;
+    const nanoseconds = Number(ns % nsMagnitude);
+    return { seconds, nanoseconds };
+}
+function lookupType(obj) {
+    if (obj.isFile()) {
+        return "regular-file";
+    }
+    else if (obj.isSocket()) {
+        return "socket";
+    }
+    else if (obj.isSymbolicLink()) {
+        return "symbolic-link";
+    }
+    else if (obj.isFIFO()) {
+        return "fifo";
+    }
+    else if (obj.isDirectory()) {
+        return "directory";
+    }
+    else if (obj.isCharacterDevice()) {
+        return "character-device";
+    }
+    else if (obj.isBlockDevice()) {
+        return "block-device";
+    }
+    return "unknown";
+}
+// Note: This should implement per-segment semantics of openAt, but we cannot
+//       currently due to the lack of support for openat() in Node.js.
+//       Tracking issue: https://github.com/libuv/libuv/issues/4167
+/**
+ * @implements {DescriptorProps}
+ */
+class Descriptor {
+    #hostPreopen;
+    #fd;
+    #finalizer;
+    #mode;
+    #fullPath;
+    _id = 0;
+    static _createPreopen(hostPreopen) {
+        const descriptor = new Descriptor();
+        descriptor.#hostPreopen = hostPreopen.endsWith("/")
+            ? hostPreopen.slice(0, -1) || "/"
+            : hostPreopen;
+        // Windows requires UNC paths at minimum
+        if (isWindows) {
+            descriptor.#hostPreopen = descriptor.#hostPreopen.replace(/\\/g, "/");
+            if (descriptor.#hostPreopen === "/") {
+                descriptor.#hostPreopen = "//";
+            }
+        }
+        return descriptor;
+    }
+    static _create(fd, mode, fullPath) {
+        const descriptor = new Descriptor();
+        descriptor.#fd = fd;
+        descriptor.#finalizer = registerDispose(descriptor, null, fd, closeSync);
+        descriptor.#mode = mode;
+        descriptor.#fullPath = fullPath;
+        return descriptor;
+    }
+    [symbolDispose]() {
+        if (this.#finalizer) {
+            earlyDispose(this.#finalizer);
+            this.#finalizer = null;
+        }
+    }
+    readViaStream(offset) {
+        if (this.#hostPreopen) {
+            throw "is-directory";
+        }
+        return inputStreamCreate(FILE, ioCall(INPUT_STREAM_CREATE | FILE, null, {
+            fd: this.#fd,
+            offset,
+        }));
+    }
+    writeViaStream(offset) {
+        if (this.#hostPreopen) {
+            throw "is-directory";
+        }
+        return outputStreamCreate(FILE, ioCall(OUTPUT_STREAM_CREATE | FILE, null, { fd: this.#fd, offset }));
+    }
+    appendViaStream() {
+        return this.writeViaStream(this.stat().size);
+    }
+    advise(_offset, _length, _advice) {
+        if (this.getType() === "directory") {
+            throw "bad-descriptor";
+        }
+    }
+    syncData() {
+        if (this.#hostPreopen) {
+            throw "invalid";
+        }
+        try {
+            fdatasyncSync(this.#fd);
+        }
+        catch (e) {
+            if (e.code === "EPERM") {
+                return;
+            }
+            throw convertFsError(e);
+        }
+    }
+    getFlags() {
+        return this.#mode;
+    }
+    getType() {
+        if (this.#hostPreopen) {
+            return "directory";
+        }
+        const stats = fstatSync(this.#fd);
+        return lookupType(stats);
+    }
+    setSize(size) {
+        if (this.#hostPreopen) {
+            throw "is-directory";
+        }
+        try {
+            ftruncateSync(this.#fd, Number(size));
+        }
+        catch (e) {
+            if (isWindows && e.code === "EPERM") {
+                throw "access";
+            }
+            throw convertFsError(e);
+        }
+    }
+    setTimes(dataAccessTimestamp, dataModificationTimestamp) {
+        if (this.#hostPreopen) {
+            throw "invalid";
+        }
+        let stats;
+        if (dataAccessTimestamp.tag === "no-change" || dataModificationTimestamp.tag === "no-change") {
+            stats = this.stat();
+        }
+        const atime = this.#getNewTimestamp(dataAccessTimestamp, dataAccessTimestamp.tag === "no-change" && stats.dataAccessTimestamp);
+        const mtime = this.#getNewTimestamp(dataModificationTimestamp, dataModificationTimestamp.tag === "no-change" && stats.dataModificationTimestamp);
+        try {
+            futimesSync(this.#fd, atime, mtime);
+        }
+        catch (e) {
+            throw convertFsError(e);
+        }
+    }
+    #getNewTimestamp(newTimestamp, maybeNow) {
+        switch (newTimestamp.tag) {
+            case "no-change":
+                return timestampToMs(maybeNow);
+            case "timestamp":
+                return timestampToMs(newTimestamp.val);
+            default:
+                return Math.floor(Date.now() / 1e3);
+        }
+    }
+    read(length, offset) {
+        if (!this.#fullPath) {
+            throw "bad-descriptor";
+        }
+        const buf = new Uint8Array(Number(length));
+        const bytesRead = readSync(this.#fd, buf, 0, Number(length), Number(offset));
+        const out = new Uint8Array(buf.buffer, 0, bytesRead);
+        return [out, bytesRead === 0];
+    }
+    write(buffer, offset) {
+        if (!this.#fullPath) {
+            throw "bad-descriptor";
+        }
+        return BigInt(writeSync(this.#fd, buffer, 0, buffer.byteLength, Number(offset)));
+    }
+    readDirectory() {
+        if (!this.#fullPath) {
+            throw "bad-descriptor";
+        }
+        try {
+            const dir = opendirSync(this.#fullPath);
+            return directoryEntryStreamCreate(dir);
+        }
+        catch (e) {
+            throw convertFsError(e);
+        }
+    }
+    sync() {
+        if (this.#hostPreopen) {
+            throw "invalid";
+        }
+        try {
+            fsyncSync(this.#fd);
+        }
+        catch (e) {
+            if (e.code === "EPERM") {
+                return;
+            }
+            throw convertFsError(e);
+        }
+    }
+    createDirectoryAt(path) {
+        const fullPath = this.#getFullPath(path, undefined);
+        try {
+            mkdirSync(fullPath);
+        }
+        catch (e) {
+            throw convertFsError(e);
+        }
+    }
+    stat() {
+        if (this.#hostPreopen) {
+            throw "invalid";
+        }
+        let stats;
+        try {
+            stats = fstatSync(this.#fd, { bigint: true });
+        }
+        catch (e) {
+            throw convertFsError(e);
+        }
+        const type = lookupType(stats);
+        return {
+            type,
+            linkCount: stats.nlink,
+            size: stats.size,
+            dataAccessTimestamp: nsToDateTime(stats.atimeNs),
+            dataModificationTimestamp: nsToDateTime(stats.mtimeNs),
+            statusChangeTimestamp: nsToDateTime(stats.ctimeNs),
+        };
+    }
+    statAt(pathFlags, path) {
+        const fullPath = this.#getFullPath(path, false);
+        let stats;
+        try {
+            stats = (pathFlags.symlinkFollow ? statSync : lstatSync)(fullPath, {
+                bigint: true,
+            });
+        }
+        catch (e) {
+            throw convertFsError(e);
+        }
+        const type = lookupType(stats);
+        return {
+            type,
+            linkCount: stats.nlink,
+            size: stats.size,
+            dataAccessTimestamp: nsToDateTime(stats.atimeNs),
+            dataModificationTimestamp: nsToDateTime(stats.mtimeNs),
+            statusChangeTimestamp: nsToDateTime(stats.ctimeNs),
+        };
+    }
+    setTimesAt(pathFlags, path, dataAccessTimestamp, dataModificationTimestamp) {
+        const fullPath = this.#getFullPath(path, false);
+        let stats;
+        if (dataAccessTimestamp.tag === "no-change" || dataModificationTimestamp.tag === "no-change") {
+            stats = this.stat();
+        }
+        const atime = this.#getNewTimestamp(dataAccessTimestamp, dataAccessTimestamp.tag === "no-change" && stats.dataAccessTimestamp);
+        const mtime = this.#getNewTimestamp(dataModificationTimestamp, dataModificationTimestamp.tag === "no-change" && stats.dataModificationTimestamp);
+        if (!pathFlags.symlinkFollow && !lutimesSync) {
+            throw new Error("Changing the timestamps of symlinks isn't supported");
+        }
+        let metadataSetFn = pathFlags.symlinkFollow ? lutimesSync : utimesSync;
+        try {
+            metadataSetFn(fullPath, atime / 1000, mtime / 1000);
+        }
+        catch (e) {
+            throw convertFsError(e);
+        }
+    }
+    linkAt(oldPathFlags, oldPath, newDescriptor, newPath) {
+        const oldFullPath = this.#getFullPath(oldPath, oldPathFlags.symlinkFollow);
+        const newFullPath = newDescriptor.#getFullPath(newPath, false);
+        // Windows doesn't automatically fail on trailing slashes
+        if (isWindows && newFullPath.endsWith("/")) {
+            throw "no-entry";
+        }
+        try {
+            linkSync(oldFullPath, newFullPath);
+        }
+        catch (e) {
+            throw convertFsError(e);
+        }
+    }
+    openAt(pathFlags, path, openFlags, descriptorFlags) {
+        if (preopenEntries.length === 0) {
+            throw "access";
+        }
+        const fullPath = this.#getFullPath(path, pathFlags.symlinkFollow);
+        let fsOpenFlags = 0x0;
+        if (openFlags.create) {
+            fsOpenFlags |= constants.O_CREAT;
+        }
+        if (openFlags.directory) {
+            fsOpenFlags |= constants.O_DIRECTORY;
+        }
+        if (openFlags.exclusive) {
+            fsOpenFlags |= constants.O_EXCL;
+        }
+        if (openFlags.truncate) {
+            fsOpenFlags |= constants.O_TRUNC;
+        }
+        if (descriptorFlags.read && descriptorFlags.write) {
+            fsOpenFlags |= constants.O_RDWR;
+        }
+        else if (descriptorFlags.write) {
+            fsOpenFlags |= constants.O_WRONLY;
+        }
+        else if (descriptorFlags.read) {
+            fsOpenFlags |= constants.O_RDONLY;
+        }
+        if (descriptorFlags.fileIntegritySync) {
+            fsOpenFlags |= constants.O_SYNC;
+        }
+        if (descriptorFlags.dataIntegritySync) {
+            fsOpenFlags |= constants.O_DSYNC;
+        }
+        if (!pathFlags.symlinkFollow) {
+            fsOpenFlags |= constants.O_NOFOLLOW;
+        }
+        if (descriptorFlags.requestedWriteSync || descriptorFlags.mutateDirectory) {
+            throw "unsupported";
+        }
+        // Currently throw to match Wasmtime
+        if (descriptorFlags.fileIntegritySync || descriptorFlags.dataIntegritySync) {
+            throw "unsupported";
+        }
+        if (isWindows) {
+            if (!pathFlags.symlinkFollow && !openFlags.create) {
+                let isSymlink = false;
+                try {
+                    isSymlink = lstatSync(fullPath).isSymbolicLink();
+                }
+                catch {
+                    //
+                }
+                if (isSymlink) {
+                    throw openFlags.directory ? "not-directory" : "loop";
+                }
+            }
+            if (pathFlags.symlinkFollow && openFlags.directory) {
+                let isFile = false;
+                try {
+                    isFile = !statSync(fullPath).isDirectory();
+                }
+                catch {
+                    //
+                }
+                if (isFile) {
+                    throw "not-directory";
+                }
+            }
+        }
+        try {
+            const fd = openSync(fullPath.endsWith("/") ? fullPath.slice(0, -1) : fullPath, fsOpenFlags);
+            const descriptor = descriptorCreate(fd, descriptorFlags, fullPath);
+            if (fullPath.endsWith("/") && descriptor.getType() !== "directory") {
+                descriptor[symbolDispose]();
+                throw "not-directory";
+            }
+            return descriptor;
+        }
+        catch (e) {
+            if (e.code === "ERR_INVALID_ARG_VALUE") {
+                throw isWindows ? "no-entry" : "invalid";
+            }
+            throw convertFsError(e);
+        }
+    }
+    readlinkAt(path) {
+        const fullPath = this.#getFullPath(path, false);
+        try {
+            return readlinkSync(fullPath);
+        }
+        catch (e) {
+            throw convertFsError(e);
+        }
+    }
+    removeDirectoryAt(path) {
+        const fullPath = this.#getFullPath(path, false);
+        try {
+            rmdirSync(fullPath);
+        }
+        catch (e) {
+            if (isWindows && e.code === "ENOENT") {
+                throw "not-directory";
+            }
+            throw convertFsError(e);
+        }
+    }
+    renameAt(oldPath, newDescriptor, newPath) {
+        const oldFullPath = this.#getFullPath(oldPath, false);
+        const newFullPath = newDescriptor.#getFullPath(newPath, false);
+        try {
+            renameSync(oldFullPath, newFullPath);
+        }
+        catch (e) {
+            if (isWindows && e.code === "EPERM") {
+                throw "access";
+            }
+            throw convertFsError(e);
+        }
+    }
+    symlinkAt(target, path) {
+        const fullPath = this.#getFullPath(path, false);
+        if (target.startsWith("/")) {
+            throw "not-permitted";
+        }
+        try {
+            symlinkSync(target, fullPath);
+        }
+        catch (e) {
+            if (fullPath.endsWith("/") && e.code === "EEXIST") {
+                let isDir = false;
+                try {
+                    isDir = statSync(fullPath).isDirectory();
+                }
+                catch {
+                    //
+                }
+                if (!isDir) {
+                    throw isWindows ? "no-entry" : "not-directory";
+                }
+            }
+            if (isWindows) {
+                if (e.code === "EPERM" || e.code === "EEXIST") {
+                    throw "no-entry";
+                }
+            }
+            throw convertFsError(e);
+        }
+    }
+    unlinkFileAt(path) {
+        const fullPath = this.#getFullPath(path, false);
+        try {
+            if (fullPath.endsWith("/")) {
+                let isDir = false;
+                try {
+                    isDir = statSync(fullPath).isDirectory();
+                }
+                catch {
+                    //
+                }
+                throw isDir
+                    ? isWindows
+                        ? "access"
+                        : isMac
+                            ? "not-permitted"
+                            : "is-directory"
+                    : "not-directory";
+            }
+            unlinkSync(fullPath);
+        }
+        catch (e) {
+            if (isWindows && e.code === "EPERM") {
+                throw "access";
+            }
+            throw convertFsError(e);
+        }
+    }
+    isSameObject(other) {
+        return other === this;
+    }
+    metadataHash() {
+        if (this.#hostPreopen) {
+            return { upper: 0n, lower: BigInt(this._id) };
+        }
+        try {
+            const stats = fstatSync(this.#fd, { bigint: true });
+            return { upper: stats.mtimeNs, lower: stats.ino };
+        }
+        catch (e) {
+            throw convertFsError(e);
+        }
+    }
+    metadataHashAt(pathFlags, path) {
+        const fullPath = this.#getFullPath(path, false);
+        try {
+            const stats = (pathFlags.symlinkFollow ? statSync : lstatSync)(fullPath, {
+                bigint: true,
+            });
+            return { upper: stats.mtimeNs, lower: stats.ino };
+        }
+        catch (e) {
+            throw convertFsError(e);
+        }
+    }
+    // TODO: support followSymlinks
+    #getFullPath(subpath, _followSymlinks) {
+        let descriptor = this;
+        if (subpath.indexOf("\\") !== -1) {
+            subpath = subpath.replace(/\\/g, "/");
+        }
+        if (subpath.indexOf("//") !== -1) {
+            subpath = subpath.replace(/\/\/+/g, "/");
+        }
+        if (subpath[0] === "/") {
+            throw "not-permitted";
+        }
+        // segment resolution
+        const segments = [];
+        let segmentIndex = -1;
+        for (let i = 0; i < subpath.length; i++) {
+            // busy reading a segment - only terminate on '/'
+            if (segmentIndex !== -1) {
+                if (subpath[i] === "/") {
+                    segments.push(subpath.slice(segmentIndex, i + 1));
+                    segmentIndex = -1;
+                }
+                continue;
+            }
+            // new segment - check if it is relative
+            else if (subpath[i] === ".") {
+                // ../ segment
+                if (subpath[i + 1] === "." && (subpath[i + 2] === "/" || i + 2 === subpath.length)) {
+                    if (segments.pop() === undefined) {
+                        throw "not-permitted";
+                    }
+                    i += 2;
+                    continue;
+                }
+                // ./ segment
+                else if (subpath[i + 1] === "/" || i + 1 === subpath.length) {
+                    i += 1;
+                    continue;
+                }
+            }
+            // it is the start of a new segment
+            while (subpath[i] === "/") {
+                i++;
+            }
+            segmentIndex = i;
+        }
+        // finish reading out the last segment
+        if (segmentIndex !== -1) {
+            segments.push(subpath.slice(segmentIndex));
+        }
+        subpath = segments.join("");
+        if (descriptor.#hostPreopen) {
+            return (descriptor.#hostPreopen +
+                (descriptor.#hostPreopen.endsWith("/") ? "" : subpath.length > 0 ? "/" : "") +
+                subpath);
+        }
+        return descriptor.#fullPath + (subpath.length > 0 ? "/" : "") + subpath;
+    }
+}
+const descriptorCreatePreopen = Descriptor._createPreopen;
+// @ts-expect-error - Deleting static method
+delete Descriptor._createPreopen;
+const descriptorCreate = Descriptor._create;
+// @ts-expect-error - Deleting static method
+delete Descriptor._create;
+class DirectoryEntryStream {
+    #dir;
+    #finalizer;
+    readDirectoryEntry() {
+        let entry;
+        try {
+            entry = this.#dir.readSync();
+        }
+        catch (e) {
+            throw convertFsError(e);
+        }
+        if (entry === null) {
+            return undefined;
+        }
+        const name = entry.name;
+        const type = lookupType(entry);
+        return { name, type };
+    }
+    static _create(dir) {
+        const dirStream = new DirectoryEntryStream();
+        dirStream.#finalizer = registerDispose(dirStream, null, 0, dir.closeSync.bind(dir));
+        dirStream.#dir = dir;
+        return dirStream;
+    }
+    [symbolDispose]() {
+        if (this.#finalizer) {
+            earlyDispose(this.#finalizer);
+            this.#finalizer = null;
+        }
+    }
+}
+const directoryEntryStreamCreate = DirectoryEntryStream._create;
+// @ts-expect-error Deleting static method
+delete DirectoryEntryStream._create;
+let preopenEntries = [];
+export const preopens = {
+    getDirectories() {
+        return preopenEntries;
+    },
+};
+_addPreopen("/", isWindows ? "//" : "/");
+export const types = {
+    Descriptor,
+    DirectoryEntryStream,
+    filesystemErrorCode(err) {
+        return convertFsError(err.payload);
+    },
+};
+/**
+ * Replace all preopens with the given set.
+ * @param {Record<string, string>} preopens - Map of virtual paths to host paths
+ */
+export function _setPreopens(preopens) {
+    preopenEntries = [];
+    for (const [virtualPath, hostPreopen] of Object.entries(preopens)) {
+        _addPreopen(virtualPath, hostPreopen);
+    }
+}
+/**
+ * Add a single preopen mapping.
+ * @param {string} virtualPath - The virtual path visible to the guest
+ * @param {string} hostPreopen - The host filesystem path
+ */
+export function _addPreopen(virtualPath, hostPreopen) {
+    const preopenEntry = [descriptorCreatePreopen(hostPreopen), virtualPath];
+    preopenEntries.push(preopenEntry);
+}
+/**
+ * Clear all preopens, giving the guest no filesystem access.
+ * Call this immediately after import to disable default full filesystem access.
+ *
+ * @example
+ * import { _clearPreopens } from '@bytecodealliance/preview2-shim/filesystem';
+ * _clearPreopens(); // Now guest has no filesystem access by default
+ */
+export function _clearPreopens() {
+    preopenEntries = [];
+}
+/**
+ * Get current preopens configuration.
+ * @returns {Array<[Descriptor, string]>} Array of [descriptor, virtualPath] pairs
+ */
+export function _getPreopens() {
+    return [...preopenEntries];
+}
+/**
+ * Create a preopen descriptor for a host path.
+ * This is used internally to create isolated preopen instances.
+ * @param  hostPreopen - The host filesystem path
+ * @returns A preopen descriptor
+ */
+export function _createPreopenDescriptor(hostPreopen) {
+    return descriptorCreatePreopen(hostPreopen);
+}
+function convertFsError(e) {
+    switch (e.code) {
+        case "EACCES":
+            return "access";
+        case "EAGAIN":
+        case "EWOULDBLOCK":
+            return "would-block";
+        case "EALREADY":
+            return "already";
+        case "EBADF":
+            return "bad-descriptor";
+        case "EBUSY":
+            return "busy";
+        case "EDEADLK":
+            return "deadlock";
+        case "EDQUOT":
+            return "quota";
+        case "EEXIST":
+            return "exist";
+        case "EFBIG":
+            return "file-too-large";
+        case "EILSEQ":
+            return "illegal-byte-sequence";
+        case "EINPROGRESS":
+            return "in-progress";
+        case "EINTR":
+            return "interrupted";
+        case "EINVAL":
+            return "invalid";
+        case "EIO":
+            return "io";
+        case "EISDIR":
+            return "is-directory";
+        case "ELOOP":
+            return "loop";
+        case "EMLINK":
+            return "too-many-links";
+        case "EMSGSIZE":
+            return "message-size";
+        case "ENAMETOOLONG":
+            return "name-too-long";
+        case "ENODEV":
+            return "no-device";
+        case "ENOENT":
+            return "no-entry";
+        case "ENOLCK":
+            return "no-lock";
+        case "ENOMEM":
+            return "insufficient-memory";
+        case "ENOSPC":
+            return "insufficient-space";
+        case "ENOTDIR":
+        case "ERR_FS_EISDIR":
+            return "not-directory";
+        case "ENOTEMPTY":
+            return "not-empty";
+        case "ENOTRECOVERABLE":
+            return "not-recoverable";
+        case "ENOTSUP":
+            return "unsupported";
+        case "ENOTTY":
+            return "no-tty";
+        // windows gives this error for badly structured `//` reads
+        // this seems like a slightly better error than unknown given
+        // that it's a common footgun
+        case -4094:
+        case "ENXIO":
+            return "no-such-device";
+        case "EOVERFLOW":
+            return "overflow";
+        case "EPERM":
+            return "not-permitted";
+        case "EPIPE":
+            return "pipe";
+        case "EROFS":
+            return "read-only";
+        case "ESPIPE":
+            return "invalid-seek";
+        case "ETXTBSY":
+            return "text-file-busy";
+        case "EXDEV":
+            return "cross-device";
+        case "UNKNOWN":
+            switch (e.errno) {
+                case -4094:
+                    return "no-such-device";
+                default:
+                    throw e;
+            }
+        default:
+            throw e;
+    }
+}
+function timestampToMs(timestamp) {
+    let secondsInMillis = timestamp.seconds * 1000n;
+    if (secondsInMillis > Number.MAX_SAFE_INTEGER) {
+        throw new Error(`cannot represent millisecond amount as Number [${{ secondsInMillis }}]`);
+    }
+    if (timestamp.nanoseconds > Number.MAX_SAFE_INTEGER) {
+        throw new Error(`cannot represent millisecond amount as Number [${{ secondsInMillis }}]`);
+    }
+    let remainderFractionalMillis = timestamp.nanoseconds / 1_000_000;
+    const res = Number(secondsInMillis) + remainderFractionalMillis;
+    return res;
+}