toolcraft 0.0.749 → 0.0.751

package/node_modules/@poe-code/safe-fs/dist/python/filesystem.js

@@ -0,0 +1,243 @@
+import { parsePythonFsRequest } from "./request.js";
+import { composeAbortSignals } from "../contracts/abort.js";
+import { FsError } from "../contracts/errors.js";
+import { dirname, validatePath } from "../contracts/virtual-path.js";
+/** Async half of a worker RPC filesystem. Never run this on an Atomics.wait-blocked interpreter thread. */
+export class PythonFileSystem {
+    #fs;
+    #cwd;
+    #transfer;
+    #limit;
+    #directoryLimit;
+    #open;
+    #abort = new AbortController();
+    #scope;
+    #handles = new Map();
+    #pending = new Set();
+    #acquiring = 0;
+    #next = 1;
+    #closing;
+    constructor(fs, options) {
+        this.#fs = fs;
+        validatePath(options.cwd);
+        if (!options.cwd.startsWith("/"))
+            throw new FsError("EINVAL", { syscall: "python filesystem", path: options.cwd, message: "cwd must be absolute" });
+        this.#cwd = options.cwd;
+        this.#transfer = options.maxTransferBytes ?? Infinity;
+        this.#limit = options.maxOpenFiles ?? Infinity;
+        this.#directoryLimit = options.maxDirectoryEntries ?? Infinity;
+        for (const limit of [this.#transfer, options.maxOpenFiles, options.maxDirectoryEntries])
+            if (limit !== undefined && limit !== Infinity && (!Number.isSafeInteger(limit) || limit < 1))
+                throw new FsError("EINVAL", { syscall: "python filesystem" });
+        this.#open = options.open;
+        this.#scope = composeAbortSignals([...(options.signal === undefined ? [] : [options.signal]), this.#abort.signal]);
+    }
+    dispatch(value) {
+        if (this.#closing)
+            return Promise.reject(new FsError("EBADF"));
+        let request;
+        try {
+            request = parsePythonFsRequest(value, this.#transfer);
+            if (request.op !== "close")
+                this.#scope.signal.throwIfAborted();
+        }
+        catch (error) {
+            return Promise.reject(this.#scope.signal.aborted ? this.#scope.signal.reason : error);
+        }
+        const operation = this.#execute(request);
+        this.#pending.add(operation);
+        void operation.then(() => this.#pending.delete(operation), () => this.#pending.delete(operation));
+        return operation;
+    }
+    #path(path) {
+        validatePath(path);
+        if (path.length === 0)
+            throw new FsError("ENOENT", { syscall: "resolve", path });
+        return path.startsWith("/") ? path : `${this.#cwd === "/" ? "" : this.#cwd}/${path}`;
+    }
+    #handle(id) {
+        const handle = this.#handles.get(id);
+        if (!handle)
+            throw new FsError("EBADF");
+        return handle;
+    }
+    #size(size) {
+        if (!Number.isSafeInteger(size) || size < 0)
+            throw new FsError("EINVAL");
+        if (size > this.#transfer)
+            throw new FsError("EFBIG", { message: "Python filesystem transfer exceeds configured limit" });
+    }
+    async #execute(request) {
+        if (request.op === "close") {
+            const [id] = request.args;
+            const handle = this.#handle(id);
+            this.#handles.delete(id);
+            await handle.close({ signal: this.#scope.signal });
+            return;
+        }
+        const signal = this.#scope.signal;
+        signal.throwIfAborted();
+        const options = { signal };
+        const fs = this.#fs;
+        switch (request.op) {
+            case "open": {
+                const [path, supplied] = request.args;
+                if (this.#handles.size + this.#acquiring >= this.#limit || !Number.isSafeInteger(this.#next))
+                    throw new FsError("EMFILE", { syscall: "open" });
+                if (!this.#open && !fs.open)
+                    throw new FsError("ENOTSUP", { syscall: "open", path });
+                this.#acquiring++;
+                let handle;
+                try {
+                    // A following capability query cannot preflight exclusive final-entry acquisition.
+                    // The canonical open remains authoritative for selected-path policy and atomic refusal.
+                    const capabilities = supplied.creation !== "exclusive" && fs.capabilitiesFor ? await fs.capabilitiesFor(this.#path(path), { signal, ...(supplied.creation === "ifMissing" ? { create: true } : {}) }) : fs.capabilities;
+                    if (capabilities.readOnly === true && (supplied.access === "write" || supplied.access === "readwrite" || supplied.creation === "ifMissing" || supplied.creation === "exclusive" || supplied.truncate === true || supplied.append === true))
+                        throw new FsError("EROFS", { syscall: "open", path });
+                    if (capabilities.open === false)
+                        throw new FsError("ENOTSUP", { syscall: "open", path });
+                    signal.throwIfAborted();
+                    const open = this.#open ?? fs.open.bind(fs);
+                    handle = await open(this.#path(path), { ...supplied, signal });
+                    signal.throwIfAborted();
+                    const id = this.#next++;
+                    this.#handles.set(id, handle);
+                    return id;
+                }
+                catch (error) {
+                    if (handle)
+                        try {
+                            await handle.close();
+                        }
+                        catch { /* Preserve the acquisition failure. */ }
+                    signal.throwIfAborted();
+                    throw error;
+                }
+                finally {
+                    this.#acquiring--;
+                }
+            }
+            case "descriptorCapabilities": return { ...this.#handle(request.args[0]).capabilities };
+            case "fstat": return this.#handle(request.args[0]).stat(options);
+            case "position": {
+                const handle = this.#handle(request.args[0]);
+                if (handle.capabilities.position !== true || !handle.getPosition)
+                    throw new FsError("ENOTSUP");
+                return handle.getPosition(options);
+            }
+            case "read": {
+                const [id, length, position] = request.args;
+                this.#size(length);
+                const buffer = new Uint8Array(length);
+                const count = await this.#handle(id).read(buffer, position, options);
+                if (!Number.isSafeInteger(count) || count < 0 || count > length)
+                    throw new FsError("EIO");
+                return buffer.slice(0, count);
+            }
+            case "write": {
+                const [id, data, position] = request.args;
+                if (!(data instanceof Uint8Array))
+                    throw new FsError("EINVAL");
+                this.#size(data.byteLength);
+                // The request may outlive its transport's shared reply/request slot.
+                const owned = data.slice();
+                const count = await this.#handle(id).write(owned, position, options);
+                if (!Number.isSafeInteger(count) || count < 0 || count > owned.byteLength)
+                    throw new FsError("EIO");
+                return count;
+            }
+            case "ftruncate": return this.#handle(request.args[0]).truncate(request.args[1], options);
+            case "sync": return this.#handle(request.args[0]).sync(request.args[1], options);
+            case "stat": return fs.stat(this.#path(request.args[0]), options);
+            case "lstat": return fs.lstat(this.#path(request.args[0]), options);
+            case "realpath": return fs.realpath(this.#path(request.args[0]), options);
+            case "readdir": {
+                const path = this.#path(request.args[0]);
+                const entries = await fs.readdir(path, { ...options, ...(this.#directoryLimit === Infinity ? {} : { maxEntries: this.#directoryLimit }) });
+                signal.throwIfAborted();
+                if (entries.length > this.#directoryLimit)
+                    throw new FsError("EFBIG", { syscall: "readdir", path, message: "Python directory listing exceeds configured limit" });
+                return entries;
+            }
+            case "access": return fs.access(this.#path(request.args[0]), request.args[1], options);
+            case "mkdir": return fs.mkdir(this.#path(request.args[0]), { ...request.args[1], ...options });
+            case "rm": {
+                const path = this.#path(request.args[0]);
+                if (!fs.unlink)
+                    throw new FsError("ENOTSUP", { syscall: "unlink", path });
+                return fs.unlink(path, options);
+            }
+            case "rmdir": {
+                const path = this.#path(request.args[0]);
+                const capabilities = fs.capabilitiesFor ? await fs.capabilitiesFor(path, options) : fs.capabilities;
+                signal.throwIfAborted();
+                if (capabilities.readOnly === true)
+                    throw new FsError("EROFS", { syscall: "rmdir", path });
+                if (!fs.rmdir || capabilities.removeDirectory === false || capabilities.snapshotRmdir === true)
+                    throw new FsError("ENOTSUP", { syscall: "rmdir", path });
+                return fs.rmdir(path, options);
+            }
+            case "rmtreeSupported":
+            case "rmtree": {
+                const path = this.#path(request.args[0]);
+                const capabilities = fs.capabilitiesFor ? await fs.capabilitiesFor(path, options) : fs.capabilities;
+                signal.throwIfAborted();
+                if (request.op === "rmtreeSupported")
+                    return capabilities.readOnly === true || capabilities.atomicTreeRemoval === true && typeof fs.removeTreeConditional === "function";
+                if (capabilities.readOnly === true)
+                    throw new FsError("EROFS", { syscall: "rmtree", path });
+                if (capabilities.atomicTreeRemoval !== true || !fs.removeTreeConditional)
+                    throw new FsError("ENOTSUP", { syscall: "rmtree", path });
+                const expected = await fs.lstat(path, options);
+                signal.throwIfAborted();
+                if (expected.type !== "directory")
+                    throw new FsError("ENOTDIR", { syscall: "rmtree", path });
+                const parent = await fs.stat(dirname(path), options);
+                signal.throwIfAborted();
+                return fs.removeTreeConditional(path, { ...options, parent, expected });
+            }
+            case "rename": return fs.rename(this.#path(request.args[0]), this.#path(request.args[1]), options);
+            case "readlink":
+                if (fs.readlink)
+                    return fs.readlink(this.#path(request.args[0]), options);
+                break;
+            case "symlink":
+                if (fs.symlink)
+                    return fs.symlink(request.args[0], this.#path(request.args[1]), options);
+                break;
+            case "link":
+                if (fs.link)
+                    return fs.link(this.#path(request.args[0]), this.#path(request.args[1]), options);
+                break;
+            case "chmod":
+                if (fs.chmod)
+                    return fs.chmod(this.#path(request.args[0]), request.args[1], options);
+                break;
+            case "truncate":
+                if (fs.truncate)
+                    return fs.truncate(this.#path(request.args[0]), request.args[1], options);
+                break;
+            case "utimes":
+                if (fs.utimes)
+                    return fs.utimes(this.#path(request.args[0]), request.args[1], request.args[2], options);
+                break;
+        }
+        throw new FsError("ENOTSUP", { syscall: request.op });
+    }
+    close() {
+        if (!this.#closing) {
+            this.#closing = Promise.resolve().then(async () => {
+                await Promise.allSettled([...this.#pending]);
+                const handles = [...this.#handles.values()];
+                this.#handles.clear();
+                const results = await Promise.allSettled(handles.map(handle => handle.close({ signal: this.#scope.signal })));
+                this.#scope.dispose();
+                const failed = results.find(result => result.status === "rejected");
+                if (failed?.status === "rejected")
+                    throw failed.reason;
+            });
+            this.#abort.abort(new FsError("ECANCELED", { syscall: "python filesystem close" }));
+        }
+        return this.#closing;
+    }
+}

package/node_modules/@poe-code/safe-fs/dist/python/flags.d.ts

@@ -0,0 +1,3 @@
+import type { OpenFileOptions } from "../contracts/filesystem.js";
+/** Emscripten's pinned musl flag ABI, not the host operating system's flags. */
+export declare function translatePythonOpenFlags(flags: number, mode?: number): OpenFileOptions;

package/node_modules/@poe-code/safe-fs/dist/python/flags.js

@@ -0,0 +1,14 @@
+import { FsError } from "../contracts/errors.js";
+/** Emscripten's pinned musl flag ABI, not the host operating system's flags. */
+export function translatePythonOpenFlags(flags, mode = 0o666) {
+    if (!Number.isSafeInteger(flags) || flags < 0 || flags > 0x7fffffff || (flags & 3) === 3)
+        throw new FsError("EINVAL", { syscall: "open" });
+    const exclusive = (flags & (64 | 128)) === (64 | 128);
+    // CLOEXEC and LARGEFILE do not alter the lifetime or numeric range of a virtual descriptor.
+    const supported = 3 | 64 | 128 | 512 | 1024 | 32768 | 524288 | (exclusive ? 131072 : 0);
+    if ((flags & ~supported) !== 0)
+        throw new FsError("ENOTSUP", { syscall: "open" });
+    return { access: (flags & 3) === 0 ? "read" : (flags & 3) === 1 ? "write" : "readwrite",
+        creation: (flags & 64) !== 0 ? exclusive ? "exclusive" : "ifMissing" : "never",
+        truncate: (flags & 512) !== 0, append: (flags & 1024) !== 0, mode };
+}

package/node_modules/@poe-code/safe-fs/dist/python/index.d.ts

@@ -0,0 +1,9 @@
+export { PythonFileSystem } from "./filesystem.js";
+export type { PythonFileSystemOptions, PythonFsRequest } from "./filesystem.js";
+export { translatePythonOpenFlags } from "./flags.js";
+export { mountPythonFileSystem } from "./emscripten.js";
+export type { PythonMountOptions } from "./emscripten.js";
+export { PythonStatTranslator } from "./stat.js";
+export type { PythonWireStat } from "./stat.js";
+export { createPythonNativeSyscalls } from './native.js';
+export type { PythonNativeSyscallOptions } from './native.js';

package/node_modules/@poe-code/safe-fs/dist/python/index.js

@@ -0,0 +1,5 @@
+export { PythonFileSystem } from "./filesystem.js";
+export { translatePythonOpenFlags } from "./flags.js";
+export { mountPythonFileSystem } from "./emscripten.js";
+export { PythonStatTranslator } from "./stat.js";
+export { createPythonNativeSyscalls } from './native.js';

package/node_modules/@poe-code/safe-fs/dist/python/native.d.ts

@@ -0,0 +1,18 @@
+export interface PythonNativeSyscallOptions {
+    readonly runtime: any;
+    readonly dispatch: (request: {
+        op: string;
+        args: unknown[];
+    }) => Promise<unknown>;
+    readonly signal: AbortSignal;
+    readonly cwd: string;
+    readonly runtimeMount: string;
+    readonly maxTransferBytes: number;
+    readonly getUmask?: () => number;
+    readonly original?: (name: string, args: readonly (number | bigint)[]) => number;
+}
+export declare function createPythonNativeSyscalls(options: PythonNativeSyscallOptions): {
+    invoke(name: string, args: readonly (number | bigint)[]): Promise<number>;
+    metadata(path: string | number, follow: boolean): Promise<Record<string, any>>;
+    close(): Promise<void>;
+};