@zenfs/core 2.7.5 → 2.7.7

package/dist/internal/inode.d.ts

@@ -1,3 +1,4 @@
+import { type ExceptionExtra } from 'kerium';
 import { BufferView } from 'utilium/buffer';
 import { Stats } from '../node/stats.js';
 import { type V_Context } from './contexts.js';
@@ -32,61 +33,39 @@ export interface InodeFields {
     data?: number;
     flags?: number;
     version?: number;
+    /** Extended attributes */
+    attributes?: Attributes;
 }
-/**
- * @category Internals
- * @internal
- */
-export interface InodeLike<T extends number | bigint = number> extends InodeFields {
-    /**
-     * Size of the item in bytes.
-     * For directories/symlinks, this is normally the size of the struct that represents the item.
-     */
+export interface StatsLike<T extends number | bigint = number | bigint> {
+    /** Size of the item in bytes. For directories/symlinks, this may be the size of the struct that represents the item. */
     size: T;
-    /**
-     * Unix-style file mode (e.g. 0o644) that includes the item type
-     */
+    /** Unix-style file mode (e.g. 0o644) that includes the item type */
     mode: T;
-    /**
-     * Time of last access, since epoch
-     */
+    /** Time of last access, since epoch */
     atimeMs: T;
-    /**
-     * Time of last modification, since epoch
-     */
+    /** Time of last modification, since epoch */
     mtimeMs: T;
-    /**
-     * Time of last time file status was changed, since epoch
-     */
+    /** Time of last time file status was changed, since epoch */
     ctimeMs: T;
-    /**
-     * Time of file creation, since epoch
-     */
+    /** Time of file creation, since epoch */
     birthtimeMs: T;
-    /**
-     * The id of the user that owns the file
-     */
+    /** The id of the user that owns the file */
     uid: T;
-    /**
-     * The id of the group that owns the file
-     */
+    /** The id of the group that owns the file */
     gid: T;
-    /**
-     * Inode number
-     */
+    /** Inode number */
     ino: T;
-    /**
-     * Number of hard links
-     */
+    /** Number of hard links */
     nlink: T;
-    /**
-     * Device ID for special files
-     */
+    /** Device ID for special files */
     rdev: T;
-    /**
-     * Extended attributes
-     */
-    attributes?: Attributes;
+}
+/**
+ * @category Internals
+ * @internal
+ * @todo [breaking] switch fully to using bigints
+ */
+export interface InodeLike<T extends number | bigint = number> extends InodeFields, StatsLike<T> {
 }
 /**
  * @internal @hidden
@@ -256,10 +235,34 @@ export declare function isFIFO(metadata: {
  * @internal
  */
 export declare function hasAccess($: V_Context, inode: Pick<InodeLike, 'mode' | 'uid' | 'gid'>, access: number): boolean;
+/**
+ * Throws if a given user may not search the directory `dir`
+ * @internal
+ */
+export declare function assertSearchable($: V_Context, dir: Pick<InodeLike, 'mode' | 'uid' | 'gid'>, extra?: ExceptionExtra): void;
+/**
+ * Throws if a given user may not remove `entry` from the directory `parent`
+ * @internal
+ */
+export declare function assertRemovable($: V_Context, parent: Pick<InodeLike, 'mode' | 'uid' | 'gid'>, entry: Pick<InodeLike, 'uid'>, extra?: ExceptionExtra): void;
+/**
+ * Throws if a given user is neither root nor the owner of `inode`
+ * @internal
+ */
+export declare function assertOwner($: V_Context, inode: Pick<InodeLike, 'uid'>, extra?: ExceptionExtra): void;
+/**
+ * Throws if a given user may not change the owner of `inode` to `uid` and `gid`, where `-1` leaves an ID unchanged
+ * @internal
+ */
+export declare function assertCanChown($: V_Context, inode: Pick<InodeLike, 'uid' | 'gid'>, uid: number, gid: number, extra?: ExceptionExtra): void;
 /**
  * @hidden @internal
  *
  * @todo https://github.com/nodejs/node/pull/58836 support -1 for `*chown`
  */
 export declare function _chown(stats: Partial<InodeLike>, uid: number, gid: number): boolean;
+/**
+ * @hidden @internal
+ */
+export declare function _chmod($: V_Context, inode: Pick<InodeLike, 'mode' | 'gid'>, mode: number): void;
 export {};

package/dist/internal/inode.js

@@ -33,7 +33,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     return useValue ? value : void 0;
 };
 // SPDX-License-Identifier: LGPL-3.0-or-later
-import { withErrno } from 'kerium';
+import { UV, withErrno } from 'kerium';
 import { crit, warn } from 'kerium/log';
 import { sizeof } from 'memium';
 import { $from, field, struct, types as t } from 'memium/decorators';
@@ -41,6 +41,7 @@ import { decodeUTF8, encodeUTF8, pick } from 'utilium';
 import { BufferView } from 'utilium/buffer';
 import * as c from '../constants.js';
 import { Stats } from '../node/stats.js';
+import { checkAccess } from '../vfs/config.js';
 import { contextOf } from './contexts.js';
 /**
  * Root inode
@@ -654,10 +655,10 @@ export function hasAccess($, inode, access) {
     const { credentials } = contextOf($);
     if (isSymbolicLink(inode))
         return true;
-    if (credentials.euid === 0 || credentials.egid === 0)
+    if (credentials.euid === 0)
         return !(access & c.X_OK) || isDirectory(inode) || !!(inode.mode & (c.S_IXUSR | c.S_IXGRP | c.S_IXOTH));
     let perm = 0;
-    if (credentials.uid === inode.uid) {
+    if (credentials.euid === inode.uid) {
         if (inode.mode & c.S_IRUSR)
             perm |= c.R_OK;
         if (inode.mode & c.S_IWUSR)
@@ -665,7 +666,7 @@ export function hasAccess($, inode, access) {
         if (inode.mode & c.S_IXUSR)
             perm |= c.X_OK;
     }
-    if (credentials.gid === inode.gid || credentials.groups.includes(Number(inode.gid))) {
+    else if (credentials.egid === inode.gid || credentials.groups.includes(Number(inode.gid))) {
         if (inode.mode & c.S_IRGRP)
             perm |= c.R_OK;
         if (inode.mode & c.S_IWGRP)
@@ -673,14 +674,64 @@ export function hasAccess($, inode, access) {
         if (inode.mode & c.S_IXGRP)
             perm |= c.X_OK;
     }
-    if (inode.mode & c.S_IROTH)
-        perm |= c.R_OK;
-    if (inode.mode & c.S_IWOTH)
-        perm |= c.W_OK;
-    if (inode.mode & c.S_IXOTH)
-        perm |= c.X_OK;
+    else {
+        if (inode.mode & c.S_IROTH)
+            perm |= c.R_OK;
+        if (inode.mode & c.S_IWOTH)
+            perm |= c.W_OK;
+        if (inode.mode & c.S_IXOTH)
+            perm |= c.X_OK;
+    }
     return (perm & access) === access;
 }
+/**
+ * Throws if a given user may not search the directory `dir`
+ * @internal
+ */
+export function assertSearchable($, dir, extra) {
+    if (checkAccess && !hasAccess($, dir, c.X_OK))
+        throw UV('EACCES', extra);
+}
+/**
+ * Throws if a given user may not remove `entry` from the directory `parent`
+ * @internal
+ */
+export function assertRemovable($, parent, entry, extra) {
+    if (!checkAccess)
+        return;
+    if (!hasAccess($, parent, c.W_OK | c.X_OK))
+        throw UV('EACCES', extra);
+    const { euid } = contextOf($).credentials;
+    if (parent.mode & c.S_ISVTX && euid !== 0 && euid !== entry.uid && euid !== parent.uid)
+        throw UV('EPERM', extra);
+}
+/**
+ * Throws if a given user is neither root nor the owner of `inode`
+ * @internal
+ */
+export function assertOwner($, inode, extra) {
+    if (!checkAccess)
+        return;
+    const { euid } = contextOf($).credentials;
+    if (euid !== 0 && euid !== inode.uid)
+        throw UV('EPERM', extra);
+}
+/**
+ * Throws if a given user may not change the owner of `inode` to `uid` and `gid`, where `-1` leaves an ID unchanged
+ * @internal
+ */
+export function assertCanChown($, inode, uid, gid, extra) {
+    if (!checkAccess)
+        return;
+    const { euid, egid, groups } = contextOf($).credentials;
+    if (euid === 0)
+        return;
+    const isOwner = euid === inode.uid;
+    if (uid !== -1 && !(isOwner && uid === inode.uid))
+        throw UV('EPERM', extra);
+    if (gid !== -1 && !(isOwner && (gid === inode.gid || gid === egid || groups.includes(gid))))
+        throw UV('EPERM', extra);
+}
 /**
  * @hidden @internal
  *
@@ -696,5 +747,19 @@ export function _chown(stats, uid, gid) {
         stats.gid = gid;
     else
         valid = false;
+    if (stats.mode !== undefined && !isDirectory({ mode: stats.mode })) {
+        stats.mode &= ~c.S_ISUID;
+        if (stats.mode & c.S_IXGRP)
+            stats.mode &= ~c.S_ISGID;
+    }
     return valid;
 }
+/**
+ * @hidden @internal
+ */
+export function _chmod($, inode, mode) {
+    const { euid, egid, groups } = contextOf($).credentials;
+    if (checkAccess && euid !== 0 && egid !== inode.gid && !groups.includes(inode.gid))
+        mode &= ~c.S_ISGID;
+    inode.mode = (inode.mode & (mode > c.S_IFMT ? ~c.S_IFMT : c.S_IFMT)) | mode;
+}

package/dist/internal/rpc.d.ts

@@ -100,15 +100,24 @@ export interface Message {
     method: Method;
     stack: string;
 }
-export interface Request<TMethod extends Method = Method> extends Message {
+export interface RequestInit<TMethod extends Method = Method> {
     method: TMethod;
     args: Parameters<Methods[TMethod]>;
 }
-export interface Response<TMethod extends Method = Method> extends Message {
-    error?: WithOptional<ExceptionJSON, 'code' | 'errno'>;
-    method: TMethod;
-    value: ReturnType<Methods[TMethod]>;
-}
+export type Request<TMethod extends Method = Method> = {
+    [K in Method]: Message & RequestInit<K>;
+}[TMethod];
+export type Response<TMethod extends Method = Method> = {
+    [K in Method]: Message & {
+        error?: WithOptional<ExceptionJSON, 'code' | 'errno'>;
+        method: K;
+        /**
+         * This is undefined if an error occurs, and we check it at runtime.
+         * We don't do the type stuff because Typescript gets confused
+         */
+        value: ReturnType<Methods[K]>;
+    };
+}[TMethod];
 /**
  * Encode a RPC message as a string using JSON.
  * This is only done when structured cloning is not available.
@@ -130,7 +139,7 @@ export interface Executor extends PromiseWithResolvers<any> {
     fs: PortFS;
     timeout: ReturnType<typeof setTimeout>;
 }
-export declare function request<const TRequest extends Request, TValue>(request: Omit<TRequest, 'id' | 'stack' | '_zenfs'>, { port, timeout: ms, fs }: Partial<Options> & {
+export declare function request<const Init extends RequestInit, TValue>(request: Init, { port, timeout: ms, fs }: Partial<Options> & {
     fs: PortFS;
 }): Promise<TValue>;
 export declare function handleResponse<const TMethod extends Method>(response: Response<TMethod>): void;

package/dist/internal/rpc.js

@@ -160,11 +160,6 @@ export function request(request, { port, timeout: ms = 1000, fs }) {
     port.send({ ...request, _zenfs: true, id, stack });
     return promise;
 }
-// Why Typescript, WHY does the type need to be asserted even when the method is explicitly checked?
-function __requestMethod(req) { }
-function __responseMethod(res, ...t) {
-    return t.includes(res.method);
-}
 export function handleResponse(response) {
     if (!isMessage(response))
         return;
@@ -182,7 +177,7 @@ export function handleResponse(response) {
         return;
     }
     disposeExecutors(response.id);
-    resolve(__responseMethod(response, 'stat', 'createFile', 'mkdir') ? new Inode(response.value) : response.value);
+    resolve(['stat', 'createFile', 'mkdir'].includes(response.method) ? new Inode(response.value) : response.value);
     return;
 }
 export function attach(port, handler) {
@@ -214,11 +209,9 @@ export async function handleRequest(port, fs, request) {
     if (!isMessage(request))
         return;
     let value, error;
-    const transferList = [];
     try {
         switch (request.method) {
             case 'read': {
-                __requestMethod(request);
                 const [path, buffer, start, end] = request.args;
                 await fs.read(path, buffer, start, end);
                 value = buffer;
@@ -227,7 +220,6 @@ export async function handleRequest(port, fs, request) {
             case 'stat':
             case 'createFile':
             case 'mkdir': {
-                __requestMethod(request);
                 // @ts-expect-error 2556
                 const md = await fs[request.method](...request.args);
                 const inode = md instanceof Inode ? md : new Inode(md);
@@ -235,7 +227,6 @@ export async function handleRequest(port, fs, request) {
                 break;
             }
             case 'touch': {
-                __requestMethod(request);
                 const [path, metadata] = request.args;
                 await fs.touch(path, new Inode(metadata));
                 value = undefined;
@@ -249,5 +240,5 @@ export async function handleRequest(port, fs, request) {
     catch (e) {
         error = e instanceof Exception ? e.toJSON() : pick(e, 'message', 'stack');
     }
-    port.send({ _zenfs: true, ...pick(request, 'id', 'method', 'stack'), error, value }, transferList);
+    port.send({ _zenfs: true, ...pick(request, 'id', 'method', 'stack'), error, value });
 }

package/dist/mixins/async.js

@@ -57,6 +57,12 @@ import { StoreFS } from '../backends/store/fs.js';
 import { isDirectory } from '../internal/inode.js';
 import { join } from '../path.js';
 import { _asyncFSKeys } from './shared.js';
+/**
+ * Whether the stack of `error` has a patched method or `key`'s sync method below the innermost patched method.
+ */
+function isInLoop(key, error = new Error()) {
+    return new RegExp(`__patched__[^]*(__patched__|\\b${key}Sync\\b)`).test(error.stack ?? '');
+}
 /**
  * Async() implements synchronous methods on an asynchronous file system
  *
@@ -82,6 +88,8 @@ export function Async(FS) {
             return this.sync();
         }
         _promise = Promise.resolve();
+        /** The async methods before patching, which do not update the sync cache */
+        _unpatched = {};
         _async(thunk) {
             this._promise = this._promise.finally(() => thunk());
         }
@@ -132,7 +140,7 @@ export function Async(FS) {
         renameSync(oldPath, newPath) {
             this.checkSync();
             this._sync.renameSync(oldPath, newPath);
-            this._async(() => this.rename(oldPath, newPath));
+            this._async(() => this._unpatched.rename(oldPath, newPath));
         }
         statSync(path) {
             this.checkSync();
@@ -141,28 +149,28 @@ export function Async(FS) {
         touchSync(path, metadata) {
             this.checkSync();
             this._sync.touchSync(path, metadata);
-            this._async(() => this.touch(path, metadata));
+            this._async(() => this._unpatched.touch(path, metadata));
         }
         createFileSync(path, options) {
             this.checkSync();
             const result = this._sync.createFileSync(path, options);
-            this._async(() => this.createFile(path, options));
+            this._async(() => this._unpatched.createFile(path, options));
             return result;
         }
         unlinkSync(path) {
             this.checkSync();
             this._sync.unlinkSync(path);
-            this._async(() => this.unlink(path));
+            this._async(() => this._unpatched.unlink(path));
         }
         rmdirSync(path) {
             this.checkSync();
             this._sync.rmdirSync(path);
-            this._async(() => this.rmdir(path));
+            this._async(() => this._unpatched.rmdir(path));
         }
         mkdirSync(path, options) {
             this.checkSync();
             const result = this._sync.mkdirSync(path, options);
-            this._async(() => this.mkdir(path, options));
+            this._async(() => this._unpatched.mkdir(path, options));
             return result;
         }
         readdirSync(path) {
@@ -172,7 +180,7 @@ export function Async(FS) {
         linkSync(srcpath, dstpath) {
             this.checkSync();
             this._sync.linkSync(srcpath, dstpath);
-            this._async(() => this.link(srcpath, dstpath));
+            this._async(() => this._unpatched.link(srcpath, dstpath));
         }
         async sync() {
             if (!this.attributes.has('no_async_preload') && this._sync)
@@ -194,7 +202,7 @@ export function Async(FS) {
         writeSync(path, buffer, offset) {
             this.checkSync();
             this._sync.writeSync(path, buffer, offset);
-            this._async(() => this.write(path, buffer, offset));
+            this._async(() => this._unpatched.write(path, buffer, offset));
         }
         ioctlSync(context, command, ...args) {
             this.checkSync();
@@ -261,22 +269,9 @@ export function Async(FS) {
             for (const key of toPatch) {
                 // TS does not narrow the union based on the key
                 const originalMethod = this[key].bind(this);
-                function isInLoop(depth, error) {
-                    if (!error) {
-                        error = new Error();
-                        Error.captureStackTrace(error, isInLoop);
-                    }
-                    if (!error.stack)
-                        return false;
-                    const stack = error.stack.split('\n').slice(depth).join('\n');
-                    // From the async queue
-                    return (stack.includes(`at <computed> [as ${key}]`)
-                        || stack.includes(`at async <computed> [as ${key}]`)
-                        || stack.includes(`${key}Sync `));
-                }
-                this[key] = async (...args) => {
+                const fn = async function __patched__(...args) {
                     const result = await originalMethod(...args);
-                    if (isInLoop(2))
+                    if (isInLoop(key))
                         return result;
                     if (!this._isInitialized) {
                         this._skippedCacheUpdates++;
@@ -287,13 +282,16 @@ export function Async(FS) {
                         this._sync?.[`${key}Sync`]?.(...args);
                     }
                     catch (e) {
-                        if (isInLoop(3, e))
+                        if (isInLoop(key, e))
                             return result;
                         e.message += ' (Out of sync!)';
                         throw err(e);
                     }
                     return result;
                 };
+                Object.defineProperty(fn, 'name', { get: () => key });
+                this._unpatched[key] = originalMethod;
+                this[key] = fn;
             }
             debug(`Async: patched ${toPatch.length} methods`);
         }

package/dist/mixins/mutexed.d.ts

@@ -1,28 +1,17 @@
+import { RwLockable } from 'kerium/locks';
 import type { UUID } from 'node:crypto';
 import type { Concrete } from 'utilium';
 import type { CreationOptions, FileSystem, StreamOptions, UsageInfo } from '../internal/filesystem.js';
 import type { InodeLike } from '../internal/inode.js';
 import type { IoctlContext } from '../internal/ioctl.js';
 import '../polyfills.js';
-/**
- * @category Internals
- * @internal
- */
-export declare class MutexLock {
-    protected readonly previous?: MutexLock | undefined;
-    protected current: PromiseWithResolvers<void>;
-    protected _isLocked: boolean;
-    get isLocked(): boolean;
-    constructor(previous?: MutexLock | undefined);
-    done(): Promise<void>;
-    unlock(): void;
-    [Symbol.dispose](): void;
-}
 /**
  * @hidden
  * @category Internals
+ * @deprecated This is no longer needed and will be removed
+ * @todo [breaking] Remove
  */
-export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
+export declare class _MutexedFS<T extends FileSystem> extends RwLockable implements FileSystem {
     /**
      * @internal
      */
@@ -38,31 +27,6 @@ export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
     ready(): Promise<void>;
     readySync(): void;
     usage(): UsageInfo;
-    /**
-     * The current locks
-     */
-    private currentLock?;
-    /**
-     * Adds a lock for a path
-     */
-    protected addLock(): MutexLock;
-    /**
-     * Locks `path` asynchronously.
-     * If the path is currently locked, waits for it to be unlocked.
-     * @internal
-     */
-    lock(timeout?: number): Promise<MutexLock>;
-    /**
-     * Locks `path` asynchronously.
-     * If the path is currently locked, an error will be thrown
-     * @internal
-     */
-    lockSync(): MutexLock;
-    /**
-     * Whether `path` is locked
-     * @internal
-     */
-    get isLocked(): boolean;
     rename(oldPath: string, newPath: string): Promise<void>;
     renameSync(oldPath: string, newPath: string): void;
     stat(path: string): Promise<InodeLike>;
@@ -110,9 +74,10 @@ export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
  * Instead of extending `FileSystem`,
  * `MutexedFS` implements it in order to make sure all of the methods are passed through
  *
- * @todo Change `using _` to `using void` pending https://github.com/tc39/proposal-discard-binding
  * @category Internals
  * @internal
+ * @deprecated This is no longer needed and will be removed
+ * @todo [breaking] Remove
  */
 export declare function Mutexed<const T extends Concrete<typeof FileSystem>>(FS: T): typeof _MutexedFS<InstanceType<T>> & {
     new (...args: ConstructorParameters<T>): _MutexedFS<InstanceType<T>>;