@zenfs/core 0.17.1 → 0.18.0

package/dist/emulation/promises.js

@@ -46,16 +46,17 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 /* eslint-disable @typescript-eslint/no-redundant-type-constituents */
 import { Buffer } from 'buffer';
 import { Errno, ErrnoError } from '../error.js';
-import { isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../file.js';
+import { flagToMode, isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../file.js';
 import '../polyfills.js';
 import { BigIntStats } from '../stats.js';
 import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
-import { _statfs, cred, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
+import { _statfs, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
+import { credentials } from '../credentials.js';
 import { ReadStream, WriteStream } from './streams.js';
-import { FSWatcher } from './watchers.js';
+import { FSWatcher, emitChange } from './watchers.js';
 export * as constants from './constants.js';
 export class FileHandle {
     constructor(fdOrFile) {
@@ -66,19 +67,21 @@ export class FileHandle {
     /**
      * Asynchronous fchown(2) - Change ownership of a file.
      */
-    chown(uid, gid) {
-        return this.file.chown(uid, gid);
+    async chown(uid, gid) {
+        await this.file.chown(uid, gid);
+        emitChange('change', this.file.path);
     }
     /**
      * Asynchronous fchmod(2) - Change permissions of a file.
      * @param mode A file mode. If a string is passed, it is parsed as an octal integer.
      */
-    chmod(mode) {
+    async chmod(mode) {
         const numMode = normalizeMode(mode, -1);
         if (numMode < 0) {
             throw new ErrnoError(Errno.EINVAL, 'Invalid mode.');
         }
-        return this.file.chmod(numMode);
+        await this.file.chmod(numMode);
+        emitChange('change', this.file.path);
     }
     /**
      * Asynchronous fdatasync(2) - synchronize a file's in-core state with storage device.
@@ -96,20 +99,22 @@ export class FileHandle {
      * Asynchronous ftruncate(2) - Truncate a file to a specified length.
      * @param len If not specified, defaults to `0`.
      */
-    truncate(len) {
+    async truncate(len) {
         len || (len = 0);
         if (len < 0) {
             throw new ErrnoError(Errno.EINVAL);
         }
-        return this.file.truncate(len);
+        await this.file.truncate(len);
+        emitChange('change', this.file.path);
     }
     /**
      * Asynchronously change file timestamps of the file.
      * @param atime The last access time. If a string is provided, it will be coerced to number.
      * @param mtime The last modified time. If a string is provided, it will be coerced to number.
      */
-    utimes(atime, mtime) {
-        return this.file.utimes(normalizeTime(atime), normalizeTime(mtime));
+    async utimes(atime, mtime) {
+        await this.file.utimes(normalizeTime(atime), normalizeTime(mtime));
+        emitChange('change', this.file.path);
     }
     /**
      * Asynchronously append data to a file, creating the file if it does not exist. The underlying file will _not_ be closed automatically.
@@ -132,6 +137,7 @@ export class FileHandle {
         }
         const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
         await this.file.write(encodedData, 0, encodedData.length);
+        emitChange('change', this.file.path);
     }
     /**
      * Asynchronously reads data from the file.
@@ -207,6 +213,9 @@ export class FileHandle {
     }
     async stat(opts) {
         const stats = await this.file.stat();
+        if (!stats.hasAccess(constants.R_OK, credentials)) {
+            throw ErrnoError.With('EACCES', this.file.path, 'stat');
+        }
         return opts?.bigint ? new BigIntStats(stats) : stats;
     }
     async write(data, posOrOff, lenOrEnc, position) {
@@ -228,6 +237,7 @@ export class FileHandle {
         }
         position ?? (position = this.file.position);
         const bytesWritten = await this.file.write(buffer, offset, length, position);
+        emitChange('change', this.file.path);
         return { buffer, bytesWritten };
     }
     /**
@@ -252,6 +262,7 @@ export class FileHandle {
         }
         const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
         await this.file.write(encodedData, 0, encodedData.length, 0);
+        emitChange('change', this.file.path);
     }
     /**
      * Asynchronous close(2) - close a `FileHandle`.
@@ -346,13 +357,18 @@ export async function rename(oldPath, newPath) {
     newPath = normalizePath(newPath);
     const src = resolveMount(oldPath);
     const dst = resolveMount(newPath);
+    if (!(await stat(dirname(oldPath))).hasAccess(constants.W_OK, credentials)) {
+        throw ErrnoError.With('EACCES', oldPath, 'rename');
+    }
     try {
         if (src.mountPoint == dst.mountPoint) {
-            await src.fs.rename(src.path, dst.path, cred);
+            await src.fs.rename(src.path, dst.path);
+            emitChange('rename', oldPath.toString());
             return;
         }
         await writeFile(newPath, await readFile(oldPath));
         await unlink(oldPath);
+        emitChange('rename', oldPath.toString());
     }
     catch (e) {
         throw fixError(e, { [src.path]: oldPath, [dst.path]: newPath });
@@ -366,7 +382,7 @@ rename;
 export async function exists(path) {
     try {
         const { fs, path: resolved } = resolveMount(await realpath(path));
-        return await fs.exists(resolved, cred);
+        return await fs.exists(resolved);
     }
     catch (e) {
         if (e instanceof ErrnoError && e.code == 'ENOENT') {
@@ -379,7 +395,10 @@ export async function stat(path, options) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount((await exists(path)) ? await realpath(path) : path);
     try {
-        const stats = await fs.stat(resolved, cred);
+        const stats = await fs.stat(resolved);
+        if (!stats.hasAccess(constants.R_OK, credentials)) {
+            throw ErrnoError.With('EACCES', path, 'stat');
+        }
         return options?.bigint ? new BigIntStats(stats) : stats;
     }
     catch (e) {
@@ -391,7 +410,7 @@ export async function lstat(path, options) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path);
     try {
-        const stats = await fs.stat(resolved, cred);
+        const stats = await fs.stat(resolved);
         return options?.bigint ? new BigIntStats(stats) : stats;
     }
     catch (e) {
@@ -430,7 +449,11 @@ export async function unlink(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path);
     try {
-        await fs.unlink(resolved, cred);
+        if (!(await fs.stat(resolved)).hasAccess(constants.W_OK, credentials)) {
+            throw ErrnoError.With('EACCES', resolved, 'unlink');
+        }
+        await fs.unlink(resolved);
+        emitChange('rename', path.toString());
     }
     catch (e) {
         throw fixError(e, { [resolved]: path });
@@ -446,33 +469,39 @@ async function _open(path, _flag, _mode = 0o644, resolveSymlinks) {
     const mode = normalizeMode(_mode, 0o644), flag = parseFlag(_flag);
     path = resolveSymlinks && (await exists(path)) ? await realpath(path) : path;
     const { fs, path: resolved } = resolveMount(path);
-    if (!(await fs.exists(resolved, cred))) {
+    const stats = await fs.stat(resolved).catch(() => null);
+    if (!stats) {
         if ((!isWriteable(flag) && !isAppendable(flag)) || flag == 'r+') {
             throw ErrnoError.With('ENOENT', path, '_open');
         }
         // Create the file
-        const parentStats = await fs.stat(dirname(resolved), cred);
-        if (parentStats && !parentStats.isDirectory()) {
+        const parentStats = await fs.stat(dirname(resolved));
+        if (!parentStats.hasAccess(constants.W_OK, credentials)) {
+            throw ErrnoError.With('EACCES', dirname(path), '_open');
+        }
+        if (!parentStats.isDirectory()) {
             throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
         }
-        return new FileHandle(await fs.createFile(resolved, flag, mode, cred));
+        return new FileHandle(await fs.createFile(resolved, flag, mode));
+    }
+    if (!stats.hasAccess(flagToMode(flag), credentials)) {
+        throw ErrnoError.With('EACCES', path, '_open');
     }
     if (isExclusive(flag)) {
         throw ErrnoError.With('EEXIST', path, '_open');
     }
-    if (!isTruncating(flag)) {
-        return new FileHandle(await fs.openFile(resolved, flag, cred));
-    }
+    const handle = new FileHandle(await fs.openFile(resolved, flag));
     /*
         In a previous implementation, we deleted the file and
         re-created it. However, this created a race condition if another
         asynchronous request was trying to read the file, as the file
         would not exist for a small period of time.
     */
-    const file = await fs.openFile(resolved, flag, cred);
-    await file.truncate(0);
-    await file.sync();
-    return new FileHandle(file);
+    if (isTruncating(flag)) {
+        await handle.truncate(0);
+        await handle.sync();
+    }
+    return handle;
 }
 /**
  * Asynchronous file open.
@@ -581,7 +610,11 @@ export async function rmdir(path) {
     path = (await exists(path)) ? await realpath(path) : path;
     const { fs, path: resolved } = resolveMount(path);
     try {
-        await fs.rmdir(resolved, cred);
+        if (!(await fs.stat(resolved)).hasAccess(constants.W_OK, credentials)) {
+            throw ErrnoError.With('EACCES', resolved, 'rmdir');
+        }
+        await fs.rmdir(resolved);
+        emitChange('rename', path.toString());
     }
     catch (e) {
         throw fixError(e, { [resolved]: path });
@@ -597,15 +630,24 @@ export async function mkdir(path, options) {
     const errorPaths = { [resolved]: path };
     try {
         if (!options?.recursive) {
-            await fs.mkdir(resolved, mode, cred);
+            if (!(await fs.stat(dirname(resolved))).hasAccess(constants.W_OK, credentials)) {
+                throw ErrnoError.With('EACCES', dirname(resolved), 'mkdir');
+            }
+            await fs.mkdir(resolved, mode);
+            emitChange('rename', path.toString());
+            return;
         }
         const dirs = [];
-        for (let dir = resolved, origDir = path; !(await fs.exists(dir, cred)); dir = dirname(dir), origDir = dirname(origDir)) {
+        for (let dir = resolved, origDir = path; !(await fs.exists(dir)); dir = dirname(dir), origDir = dirname(origDir)) {
             dirs.unshift(dir);
             errorPaths[dir] = origDir;
         }
         for (const dir of dirs) {
-            await fs.mkdir(dir, mode, cred);
+            if (!(await fs.stat(dirname(dir))).hasAccess(constants.W_OK, credentials)) {
+                throw ErrnoError.With('EACCES', dirname(dir), 'mkdir');
+            }
+            await fs.mkdir(dir, mode);
+            emitChange('rename', dir);
         }
         return dirs[0];
     }
@@ -616,11 +658,14 @@ export async function mkdir(path, options) {
 mkdir;
 export async function readdir(path, options) {
     path = normalizePath(path);
+    if (!(await stat(path)).hasAccess(constants.R_OK, credentials)) {
+        throw ErrnoError.With('EACCES', path, 'readdir');
+    }
     path = (await exists(path)) ? await realpath(path) : path;
     const { fs, path: resolved } = resolveMount(path);
     let entries;
     try {
-        entries = await fs.readdir(resolved, cred);
+        entries = await fs.readdir(resolved);
     }
     catch (e) {
         throw fixError(e, { [resolved]: path });
@@ -645,18 +690,31 @@ readdir;
 // SYMLINK METHODS
 /**
  * `link`.
- * @param existing
- * @param newpath
+ * @param targetPath
+ * @param linkPath
  */
-export async function link(existing, newpath) {
-    existing = normalizePath(existing);
-    newpath = normalizePath(newpath);
-    const { fs, path: resolved } = resolveMount(newpath);
+export async function link(targetPath, linkPath) {
+    targetPath = normalizePath(targetPath);
+    if (!(await stat(dirname(targetPath))).hasAccess(constants.R_OK, credentials)) {
+        throw ErrnoError.With('EACCES', dirname(targetPath), 'link');
+    }
+    linkPath = normalizePath(linkPath);
+    if (!(await stat(dirname(linkPath))).hasAccess(constants.W_OK, credentials)) {
+        throw ErrnoError.With('EACCES', dirname(linkPath), 'link');
+    }
+    const { fs, path } = resolveMount(targetPath);
+    const link = resolveMount(linkPath);
+    if (fs != link.fs) {
+        throw ErrnoError.With('EXDEV', linkPath, 'link');
+    }
     try {
-        return await fs.link(existing, newpath, cred);
+        if (!(await fs.stat(path)).hasAccess(constants.W_OK, credentials)) {
+            throw ErrnoError.With('EACCES', path, 'link');
+        }
+        return await fs.link(path, link.path);
     }
     catch (e) {
-        throw fixError(e, { [resolved]: newpath });
+        throw fixError(e, { [link.path]: linkPath, [path]: targetPath });
     }
 }
 link;
@@ -840,7 +898,7 @@ export async function realpath(path, options) {
     const lpath = join(dir == '/' ? '/' : await realpath(dir), base);
     const { fs, path: resolvedPath, mountPoint } = resolveMount(lpath);
     try {
-        const stats = await fs.stat(resolvedPath, cred);
+        const stats = await fs.stat(resolvedPath);
         if (!stats.isSymbolicLink()) {
             return lpath;
         }
@@ -854,7 +912,7 @@ realpath;
 export function watch(filename, options = {}) {
     return {
         [Symbol.asyncIterator]() {
-            const watcher = new FSWatcher(typeof options != 'string' ? options : { encoding: options });
+            const watcher = new FSWatcher(filename.toString(), typeof options != 'string' ? options : { encoding: options });
             function withDone(done) {
                 return function () {
                     const event = Promise.withResolvers();
@@ -880,7 +938,7 @@ watch;
  */
 export async function access(path, mode = constants.F_OK) {
     const stats = await stat(path);
-    if (!stats.hasAccess(mode, cred)) {
+    if (!stats.hasAccess(mode, credentials)) {
         throw new ErrnoError(Errno.EACCES);
     }
 }
@@ -936,6 +994,7 @@ export async function copyFile(src, dest, mode) {
         throw new ErrnoError(Errno.EEXIST, 'Destination file already exists.', dest, 'copyFile');
     }
     await writeFile(dest, await readFile(src));
+    emitChange('rename', dest.toString());
 }
 copyFile;
 /**
@@ -947,9 +1006,7 @@ copyFile;
  */
 export async function opendir(path, options) {
     path = normalizePath(path);
-    const dir = new Dir(path);
-    await dir._loadEntries();
-    return dir;
+    return new Dir(path);
 }
 opendir;
 /**

package/dist/emulation/shared.d.ts

@@ -1,11 +1,8 @@
 /// <reference types="node" resolution-mode="require"/>
 import type { BigIntStatsFs, StatsFs } from 'node:fs';
-import type { Cred } from '../cred.js';
 import type { File } from '../file.js';
 import type { FileSystem } from '../filesystem.js';
 import { type AbsolutePath } from './path.js';
-export declare let cred: Cred;
-export declare function setCred(val: Cred): void;
 export declare const fdMap: Map<number, File>;
 export declare function file2fd(file: File): number;
 export declare function fd2file(fd: number): File;

package/dist/emulation/shared.js

@@ -1,15 +1,9 @@
 // Utilities and shared data
 import { InMemory } from '../backends/memory.js';
-import { rootCred } from '../cred.js';
 import { Errno, ErrnoError } from '../error.js';
 import { size_max } from '../inode.js';
 import { normalizePath } from '../utils.js';
 import { resolve } from './path.js';
-// credentials
-export let cred = rootCred;
-export function setCred(val) {
-    cred = val;
-}
 // descriptors
 export const fdMap = new Map();
 let nextFd = 100;

package/dist/emulation/sync.d.ts

@@ -197,7 +197,6 @@ export declare function rmdirSync(path: fs.PathLike): void;
  * Synchronous `mkdir`.
  * @param path
  * @param mode defaults to o777
- * @todo Implement recursion
  */
 export declare function mkdirSync(path: fs.PathLike, options: fs.MakeDirectoryOptions & {
     recursive: true;
@@ -230,10 +229,10 @@ export declare function readdirSync(path: fs.PathLike, options?: (fs.ObjectEncod
 }) | BufferEncoding | null): string[] | Buffer[];
 /**
  * Synchronous `link`.
- * @param existing
- * @param newpath
+ * @param targetPath
+ * @param linkPath
  */
-export declare function linkSync(existing: fs.PathLike, newpath: fs.PathLike): void;
+export declare function linkSync(targetPath: fs.PathLike, linkPath: fs.PathLike): void;
 /**
  * Synchronous `symlink`.
  * @param target target path