@openclaw/feishu 2026.9.8 → 2026.10.1-beta.2

package/node_modules/@openclaw/fs-safe/dist/root-create-native.js

@@ -0,0 +1,350 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import fs from "node:fs";
+import { randomUUID } from "node:crypto";
+import fsAsync from "node:fs/promises";
+import path from "node:path";
+import { assertSyncDirectoryGuard } from "./directory-guard.js";
+import { nodeDirectorySearchOnlyFlags } from "./directory-mode-node.js";
+import { assertDarwinCreationAcl, assertPrivateDirectory } from "./creation-boundary.js";
+import { assertMutationNotDenied } from "./deny-mutations.js";
+import { FsSafeError } from "./errors.js";
+import { getNativeBinding } from "./native.js";
+import { captureNativeFdClose } from "./native-binding.js";
+import { openNativeRootAdmission } from "./native-parent-admission.js";
+import { capturePolicyAwareNativeParent } from "./native-policy-parent.js";
+import { isNotFoundPathError, isPathInside } from "./path.js";
+import { preparePinnedWriteMutationAdmission } from "./pinned-mutation-admission.js";
+import { resolvePathViaExistingAncestor } from "./root-path-existing.js";
+import { admitPathInsideRoot } from "./root-boundary.js";
+import { assertRootIdentityCurrentSync } from "./root-context.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
+import { getFsSafeTestHooks } from "./test-hooks.js";
+import { createSuppressedError } from "./suppressed-error.js";
+export function rootWriteQueueKey(root, relativePath) {
+    return `${root.rootReal}\0${relativePath}`;
+}
+export function buildAtomicWriteTempPath(targetPath) {
+    return path.join(path.dirname(targetPath), `.fs-safe-${randomUUID()}.tmp`);
+}
+function unavailable() {
+    throw new FsSafeError("helper-unavailable", "native confined creation is unavailable");
+}
+async function withNativeDirectory(params, operation, discard) {
+    const binding = getNativeBinding();
+    if (!binding?.openBeneath || !binding.mkdirChildBeneath || (params.private && process.platform === "win32"))
+        return unavailable();
+    const directoryTarget = params.directory === params.target;
+    const canonicalTarget = async (target) => directoryTarget
+        ? await resolvePathViaExistingAncestor(target)
+        : path.join(await resolvePathViaExistingAncestor(path.dirname(target)), path.basename(target));
+    const resolveCurrent = params.resolveCurrent;
+    params = { ...params,
+        directory: await resolvePathViaExistingAncestor(params.directory),
+        target: await canonicalTarget(params.target),
+        resolveCurrent: async () => await canonicalTarget(await resolveCurrent()),
+    };
+    if (!isPathInside(params.root.rootReal, params.directory)) {
+        throw new FsSafeError("outside-workspace", "creation parent is outside root");
+    }
+    const close = captureNativeFdClose(binding);
+    let pending;
+    try {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const admitted = await openNativeRootAdmission(binding, {
+                rootPath: params.root.rootReal, rootIdentity: params.root.rootIdentity, operation: "create", reportCloseErrors: true, searchOnly: true,
+            });
+            const rootOwner = __addDisposableResource(env_1, admitted.root, true);
+            const descriptors = [];
+            const directoryOwner = __addDisposableResource(env_1, { [Symbol.dispose]() {
+                    const errors = [];
+                    for (const fd of descriptors.reverse())
+                        try {
+                            close(fd);
+                        }
+                        catch (error) {
+                            errors.push(error);
+                        }
+                    if (errors.length)
+                        throw new AggregateError(errors, "creation directory close failed");
+                } }, false);
+            const guards = [];
+            function assertCurrent() {
+                assertRootIdentityCurrentSync(params.root);
+                for (const guard of guards)
+                    assertSyncDirectoryGuard(guard);
+            }
+            async function authorize(mutation) {
+                if (path.relative(params.target, await params.resolveCurrent()) !== "") {
+                    throw new FsSafeError("path-mismatch", "creation route changed during admission");
+                }
+                await assertMutationNotDenied(params.target, params.policy?.denyMutations);
+                await assertMutationNotDenied(mutation, params.policy?.denyMutations);
+                assertCurrent();
+            }
+            let current = rootOwner.fd;
+            let currentPath = params.root.rootReal;
+            const flags = (nodeDirectorySearchOnlyFlags()?.flags ?? fs.constants.O_RDONLY) |
+                (fs.constants.O_DIRECTORY ?? 0) | (fs.constants.O_NOFOLLOW ?? 0);
+            if (!params.private && !(directoryTarget && params.directory === params.root.rootReal)) {
+                if (!admitPathInsideRoot({ rootPath: params.root.rootReal, candidatePath: params.target, rootIdentity: params.root.rootIdentity })) {
+                    throw new FsSafeError("outside-workspace", "creation target is outside root");
+                }
+                const relativeParentPath = path.relative(params.root.rootReal, params.directory).split(path.sep).join("/");
+                const prepared = await preparePinnedWriteMutationAdmission({
+                    rootReal: params.root.rootReal, rootIdentity: params.root.rootIdentity,
+                    resolvedTargetPath: params.target, defaultRelativeParentPath: relativeParentPath,
+                    originalPath: params.originalPath, policy: params.policy ?? {},
+                    resolveCurrent: async () => ({ resolved: await params.resolveCurrent() }),
+                });
+                const parent = await capturePolicyAwareNativeParent(binding, {
+                    rootPath: params.root.rootReal, rootIdentity: params.root.rootIdentity,
+                    relativeParentPath, basename: directoryTarget ? "" : path.basename(params.target),
+                    mkdir: params.mkdir, mode: 0o600, input: { kind: "buffer", data: "" },
+                    mutationAdmission: prepared.mutationAdmission, assertBeforeMutation: params.assertBeforeMutation,
+                }, admitted, process.platform === "win32", flags, true);
+                descriptors.push(parent.fd);
+                guards.push(parent.guard);
+                assertCurrent();
+                pending = { value: await operation(binding, parent.fd, assertCurrent) };
+                return pending.value;
+            }
+            for (const segment of path.relative(currentPath, params.directory).split(path.sep).filter(Boolean)) {
+                const childPath = path.join(currentPath, segment);
+                let child;
+                let created = false;
+                try {
+                    child = binding.openBeneath(current, segment, flags).fd;
+                }
+                catch (error) {
+                    if (!params.mkdir || !isNotFoundPathError(error))
+                        throw error;
+                    await getFsSafeTestHooks()?.beforeRootFallbackMutation?.("mkdir", childPath);
+                    await authorize(childPath);
+                    if (params.private)
+                        assertDarwinCreationAcl(current, "directory");
+                    params.assertBeforeMutation?.();
+                    assertCurrent();
+                    if (binding.mkdirOpenChildBeneath) {
+                        const opened = binding.mkdirOpenChildBeneath(current, segment, params.private ? 0o700 : 0o777, flags);
+                        created = opened.created;
+                        child = opened.fd;
+                    }
+                    else {
+                        created = binding.mkdirChildBeneath(current, segment, params.private ? 0o700 : 0o777);
+                        child = binding.openBeneath(current, segment, flags).fd;
+                    }
+                }
+                descriptors.push(child);
+                const stat = inspectFileIdentitySync(() => fs.fstatSync(child, { bigint: true }));
+                if (!stat.isDirectory())
+                    throw new FsSafeError("not-file", "creation parent is not a directory");
+                guards.push({ dir: childPath, realPath: childPath, stat });
+                assertCurrent();
+                if (created && params.private)
+                    await assertPrivateDirectory(childPath);
+                current = child;
+                currentPath = childPath;
+            }
+            await authorize(params.target);
+            if (params.private) {
+                await assertPrivateDirectory(currentPath);
+                assertCurrent();
+            }
+            pending = { value: await operation(binding, current, assertCurrent) };
+            return pending.value;
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            const result_1 = __disposeResources(env_1);
+            if (result_1)
+                await result_1;
+        }
+    }
+    catch (error) {
+        if (pending && discard) {
+            try {
+                await discard(pending.value);
+            }
+            catch (cleanupError) {
+                throw createSuppressedError(cleanupError, error, "creation handoff and cleanup failed");
+            }
+        }
+        throw error;
+    }
+}
+export async function tryMkdirRootNative(params) {
+    // The protected Windows creator already verifies the admitted parent identity
+    // and uses handle-relative NtCreateFile with its protected security descriptor.
+    if (params.private && process.platform === "win32")
+        return false;
+    return await withNativeDirectory(params, async (_binding, _fd, assertCurrent) => { assertCurrent(); return true; });
+}
+export async function tryOpenCreateRootNative(params) {
+    const binding = getNativeBinding();
+    if (!binding?.removeStagedFile || !binding.openCreateBeneath)
+        return unavailable();
+    const access = (params.existingFlags & fs.constants.O_RDWR) ? 0o600 : 0o200;
+    if (typeof params.mode !== "number")
+        throw Object.assign(new TypeError("mode must be a number"), { code: "ERR_INVALID_ARG_TYPE" });
+    if (!Number.isInteger(params.mode) || params.mode < 0 || params.mode > 0xffffffff) {
+        throw Object.assign(new RangeError("mode must be an unsigned 32-bit integer"), { code: "ERR_OUT_OF_RANGE" });
+    }
+    const creationMode = () => {
+        const mask = process.umask();
+        const desired = params.mode & 0o7777 & ~mask;
+        return (desired & access) === access ? desired : undefined;
+    };
+    // A public FileHandle reopen must not require widening creation permissions.
+    if (creationMode() === undefined)
+        return unavailable();
+    return await withNativeDirectory(params, async (binding, parent, assertCurrent) => {
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            params.assertBeforeMutation?.();
+            assertCurrent();
+            const mode = creationMode();
+            if (mode === undefined)
+                throw new FsSafeError("helper-unavailable", "native creation cannot preserve the requested permissions during handoff");
+            // Native creation owns the only O_CREAT dispatch. The subsequent Node open
+            // carries neither O_CREAT nor O_TRUNC and must match this retained inode.
+            const close = captureNativeFdClose(binding);
+            const fd = binding.openCreateBeneath(parent, path.basename(params.target), params.flags, params.mode & 0o7777);
+            let rawOpen = true;
+            const closeRaw = () => { if (rawOpen) {
+                rawOpen = false;
+                close(fd);
+            } };
+            const owner = __addDisposableResource(env_2, { [Symbol.dispose]: closeRaw }, false);
+            try {
+                const identity = inspectFileIdentitySync(() => fs.fstatSync(fd, { bigint: true }));
+                if (!identity.isFile() || identity.nlink !== 1n)
+                    throw new FsSafeError("path-mismatch", "created file changed");
+                // Keep the kernel's creation-time ACL and umask decisions. chmod here
+                // could widen inherited ACL restrictions, even for ordinary mode bits.
+                if (process.platform !== "win32" && (Number(identity.mode) & access) !== access) {
+                    throw new FsSafeError("helper-unavailable", "created permissions do not permit a FileHandle handoff");
+                }
+                assertCurrent();
+                const handle = await fsAsync.open(params.target, params.existingFlags);
+                let validatedHandle = false;
+                try {
+                    inspectFileIdentitySync(() => fs.fstatSync(handle.fd, { bigint: true }), identity);
+                    validatedHandle = true;
+                    assertCurrent();
+                    // Close failures still belong to this scope, before transferring either owner.
+                    closeRaw();
+                    // Empty relative paths duplicate the admitted descriptor without reopening its name.
+                    const retainedParent = binding.openBeneath(parent, "", (nodeDirectorySearchOnlyFlags()?.flags ?? fs.constants.O_RDONLY) | (fs.constants.O_DIRECTORY ?? 0)).fd;
+                    let held = true;
+                    return { handle, async cleanupCreated() {
+                            if (!held)
+                                return;
+                            inspectFileIdentitySync(() => fs.fstatSync(handle.fd, { bigint: true }), identity);
+                            binding.removeStagedFile(retainedParent, path.basename(params.target), handle.fd);
+                        }, releaseCreationParent() {
+                            if (!held)
+                                return;
+                            held = false;
+                            close(retainedParent);
+                        } };
+                }
+                catch (error) {
+                    if (!rawOpen && validatedHandle) {
+                        try {
+                            binding.removeStagedFile(parent, path.basename(params.target), handle.fd);
+                        }
+                        catch { /* Preserve handoff failure. */ }
+                    }
+                    await handle.close();
+                    throw error;
+                }
+            }
+            catch (error) {
+                if (rawOpen)
+                    try {
+                        binding.removeStagedFile(parent, path.basename(params.target), fd);
+                    }
+                    catch { /* Preserve the admission failure. */ }
+                throw error;
+            }
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            __disposeResources(env_2);
+        }
+    }, async (created) => {
+        const env_3 = { stack: [], error: void 0, hasError: false };
+        try {
+            const handle = __addDisposableResource(env_3, created.handle, true);
+            const parent = __addDisposableResource(env_3, { [Symbol.dispose]: created.releaseCreationParent }, false);
+            await created.cleanupCreated();
+        }
+        catch (e_3) {
+            env_3.error = e_3;
+            env_3.hasError = true;
+        }
+        finally {
+            const result_2 = __disposeResources(env_3);
+            if (result_2)
+                await result_2;
+        }
+    });
+}

package/node_modules/@openclaw/fs-safe/dist/root-directory-list-types.d.ts

@@ -0,0 +1,35 @@
+import type { ExactStatIdentity } from "./stat-observation.js";
+import type { DirEntry } from "./types.js";
+/** Strings only: cached spellings never replace an observation or its identity fences. */
+export type RootDirectoryListingPaths = {
+    directory: string;
+    names: Map<string, string>;
+};
+export type RootDirectoryListing = {
+    paths: RootDirectoryListingPaths;
+    assertCurrent(): Promise<void>;
+    next(): Promise<{
+        kind: "entry";
+        entry: DirEntry;
+        identity?: ExactStatIdentity;
+    } | {
+        kind: "limit";
+        name: string;
+    } | undefined>;
+    [Symbol.asyncDispose](): Promise<void>;
+};
+export type RootDirectoryListingOptions = {
+    order: "sorted" | "filesystem";
+    signal?: AbortSignal;
+    snapshot: boolean;
+    maxNames?: number;
+    metadataBatchSize?: number;
+    /** Internal watch lane: exact identities and bounded synchronous name reads on Node. */
+    exactIdentity?: boolean;
+    /** Advisory scans may omit vanished leaves after revalidating their parent. */
+    skipVanished?: boolean;
+    previousPaths?: RootDirectoryListingPaths;
+    /** Internal owner receives cleanup failures, including acquisition rollback. */
+    onCleanupFailure?: (error: unknown) => void;
+    admitEntry(): boolean;
+};

package/node_modules/@openclaw/fs-safe/dist/root-directory-list-types.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@openclaw/fs-safe/dist/root-directory-list.d.ts

@@ -2,9 +2,10 @@ import type { BigIntStats, Stats } from "node:fs";
 import { type AsyncDirectoryGuard } from "./directory-guard.js";
 import { type RootContext } from "./root-context.js";
 import type { RootPathDirectoryObservationGuard, RootPathObservationReceipt, RootPathParentObservationReceipt } from "./root-path.js";
-import { type ExactStatIdentity } from "./stat-observation.js";
 import type { DirEntry, PathStat } from "./types.js";
+import type { RootDirectoryListing, RootDirectoryListingOptions } from "./root-directory-list-types.js";
 export declare function pathStatFromStats(stat: Stats | BigIntStats): PathStat;
+export declare function pathStatFromStats(stat: Stats | BigIntStats, name: string): DirEntry;
 export type RootDirectoryObservationGuard = AsyncDirectoryGuard<BigIntStats>;
 export declare function createRootDirectoryObservationGuard(root: RootContext, directory: string): Promise<RootDirectoryObservationGuard>;
 export declare function assertRootDirectoryObservationGuard(root: RootContext, guard: RootDirectoryObservationGuard | RootPathDirectoryObservationGuard): Promise<void>;
@@ -17,30 +18,4 @@ export declare function assertRootDirectoryObservationGuard(root: RootContext, g
 export declare function assertRootPathObservationReceiptCurrent(root: RootContext, receipt: RootPathObservationReceipt | RootPathParentObservationReceipt, finalTarget?: Stats | BigIntStats): void;
 export declare function listDirectoryPath(root: RootContext, directory: string, withFileTypes: true, receipt?: RootPathObservationReceipt): Promise<DirEntry[]>;
 export declare function listDirectoryPath(root: RootContext, directory: string, withFileTypes: boolean, receipt?: RootPathObservationReceipt): Promise<string[] | DirEntry[]>;
-export type RootDirectoryListing = {
-    assertCurrent(): Promise<void>;
-    next(): Promise<{
-        kind: "entry";
-        entry: DirEntry;
-        identity?: ExactStatIdentity;
-    } | {
-        kind: "limit";
-        name: string;
-    } | undefined>;
-    [Symbol.asyncDispose](): Promise<void>;
-};
-export type RootDirectoryListingOptions = {
-    order: "sorted" | "filesystem";
-    signal?: AbortSignal;
-    snapshot: boolean;
-    maxNames?: number;
-    metadataBatchSize?: number;
-    /** Internal exact metadata lane, supported by streaming filesystem order. */
-    exactIdentity?: boolean;
-    /** Advisory scans may omit vanished leaves after revalidating their parent. */
-    skipVanished?: boolean;
-    /** Internal owner receives cleanup failures, including acquisition rollback. */
-    onCleanupFailure?: (error: unknown) => void;
-    admitEntry(): boolean;
-};
 export declare function openRootDirectoryListing(root: RootContext, directory: string, options: RootDirectoryListingOptions, receipt?: RootPathObservationReceipt): Promise<RootDirectoryListing>;

package/node_modules/@openclaw/fs-safe/dist/root-directory-list.js

@@ -21,8 +21,8 @@ function directoryEntryName(bytes) {
     }
     return bytes.toString("utf8");
 }
-async function readDirectoryEntryName(handle) {
-    const entry = await handle.read();
+async function readDirectoryEntryName(handle, synchronous = false) {
+    const entry = synchronous ? handle.readSync() : await handle.read();
     // Bun returns the raw Buffer directly; Node returns a Dirent whose name is a Buffer.
     // Node's Dir types still declare only string names.
     return entry === null ? undefined
@@ -31,25 +31,19 @@ async function readDirectoryEntryName(handle) {
 function openDirectoryNames(directory) {
     return fs.opendir(directory, { bufferSize: 1, encoding: "buffer" });
 }
-export function pathStatFromStats(stat) {
+export function pathStatFromStats(stat, name) {
     const mtimeMs = typeof stat.mtimeMs === "bigint"
         ? "mtimeNs" in stat && typeof stat.mtimeNs === "bigint"
             ? Number(stat.mtimeNs) / 1_000_000
             : stat.mtime.getTime()
         : stat.mtimeMs;
-    return {
-        dev: Number(stat.dev),
-        gid: Number(stat.gid),
-        ino: Number(stat.ino),
-        isDirectory: stat.isDirectory(),
-        isFile: stat.isFile(),
-        isSymbolicLink: stat.isSymbolicLink(),
-        mode: Number(stat.mode),
-        mtimeMs,
-        nlink: Number(stat.nlink),
-        size: Number(stat.size),
-        uid: Number(stat.uid),
-    };
+    const dev = Number(stat.dev), gid = Number(stat.gid), ino = Number(stat.ino);
+    const isDirectory = stat.isDirectory(), isFile = stat.isFile(), isSymbolicLink = stat.isSymbolicLink();
+    const mode = Number(stat.mode), nlink = Number(stat.nlink), size = Number(stat.size), uid = Number(stat.uid);
+    // Construct named metadata directly, preserving property order without a spread copy.
+    return name === undefined
+        ? { dev, gid, ino, isDirectory, isFile, isSymbolicLink, mode, mtimeMs, nlink, size, uid }
+        : { name, dev, gid, ino, isDirectory, isFile, isSymbolicLink, mode, mtimeMs, nlink, size, uid };
 }
 export async function createRootDirectoryObservationGuard(root, directory) {
     const guard = await createAsyncDirectoryGuard(directory, { bigint: true });
@@ -220,12 +214,14 @@ async function listGuardedDirectoryPath(root, guard, withFileTypes, receipt) {
         if (beforeObservation)
             await beforeObservation(guard.realPath, withFileTypes);
         const names = (await fs.readdir(guard.realPath, { encoding: "buffer" })).map(directoryEntryName).sort();
-        entries = withFileTypes
-            ? names.map(name => ({
-                name,
-                ...pathStatFromStats(fsSync.lstatSync(path.join(guard.realPath, name))),
-            }))
-            : names;
+        if (withFileTypes) {
+            // readdir supplies literal child names beneath the already-canonical directory.
+            const prefix = guard.realPath.endsWith(path.sep) ? guard.realPath : `${guard.realPath}${path.sep}`;
+            entries = names.map(name => pathStatFromStats(fsSync.lstatSync(`${prefix}${name}`), name));
+        }
+        else {
+            entries = names;
+        }
     }
     catch (error) {
         // Preserve ordinary observation errors only while the admitted directory is
@@ -268,12 +264,14 @@ export async function openRootDirectoryListing(root, directory, options, receipt
             await assertRootDirectoryObservationGuard(root, guard);
         options.signal?.throwIfAborted();
     };
+    const paths = { directory: guard.realPath, names: new Map() };
+    const previousPaths = options.previousPaths?.directory === guard.realPath ? options.previousPaths.names : undefined;
     let handle;
     let names;
     let snapshot;
-    let index = 0;
+    let index = 0, preparedIndex = 0;
     let prepared = [];
-    let preparedIndex = 0;
+    const synchronousNames = options.exactIdentity && !process.versions.bun && !process.versions.deno;
     let pendingFailure;
     let pendingLimit;
     let preparedBatch = false;
@@ -347,7 +345,7 @@ export async function openRootDirectoryListing(root, directory, options, receipt
         preparedIndex = 0;
         while (true) {
             try {
-                const entry = { name, ...pathStatFromStats(fsSync.lstatSync(path.join(guard.realPath, name))) };
+                const entry = pathStatFromStats(fsSync.lstatSync(path.join(guard.realPath, name)), name);
                 prepared.push(entry);
                 // No later sibling can be observed before a possible recursive descent.
                 if (entry.isDirectory || entry.isSymbolicLink || prepared.length >= (options.metadataBatchSize ?? METADATA_BATCH_SIZE))
@@ -376,6 +374,7 @@ export async function openRootDirectoryListing(root, directory, options, receipt
         }
     };
     return {
+        paths,
         assertCurrent,
         async next() {
             try {
@@ -400,15 +399,19 @@ export async function openRootDirectoryListing(root, directory, options, receipt
                     return;
                 }
                 for (;;) {
+                    if (synchronousNames && index++ % METADATA_BATCH_SIZE === METADATA_BATCH_SIZE - 1)
+                        await yieldToEventLoop();
                     await assertCurrent();
-                    const name = await readDirectoryEntryName(handle);
+                    const name = await readDirectoryEntryName(handle, synchronousNames);
                     await assertCurrent();
                     if (name === undefined)
                         return;
                     if (!options.admitEntry())
                         return { kind: "limit", name };
                     // The stream's post-read fence is also the pre-stat fence in this owned operation.
-                    const pathname = path.join(guard.realPath, name);
+                    const pathname = previousPaths?.get(name) ?? path.join(guard.realPath, name);
+                    if (options.exactIdentity)
+                        paths.names.set(name, pathname);
                     let observed;
                     try {
                         observed = options.exactIdentity ? inspectStatObservationSync(bigint => bigint
@@ -421,7 +424,7 @@ export async function openRootDirectoryListing(root, directory, options, receipt
                         throw error;
                     }
                     await assertCurrent();
-                    return { kind: "entry", entry: { name, ...pathStatFromStats(observed.stat) }, identity: observed.identity };
+                    return { kind: "entry", entry: pathStatFromStats(observed.stat, name), identity: observed.identity };
                 }
             }
             catch (error) {

package/node_modules/@openclaw/fs-safe/dist/root-directory.js

@@ -5,11 +5,8 @@ import { formatErrorDetail } from "./error-detail.js";
 import { FsSafeError } from "./errors.js";
 import { assertNoNulPathInput, hasNodeErrorCode, isNodeError, isNotFoundPathError, isPathInside, isPathRelativeEscape, } from "./path.js";
 import { realpathSync } from "./realpath.js";
-import { resolvePathWithinRoot } from "./root-paths-lexical.js";
+import { invalidPath, resolvePathWithinRoot } from "./root-paths-lexical.js";
 import { assertNoWindowsPathAlias, pathForWindowsFilesystem, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
-function invalidPath(scopeLabel) {
-    return { ok: false, error: `Invalid path: must stay within ${scopeLabel}` };
-}
 export function resolveNearestExistingPath(targetPath) {
     assertNoWindowsPathAlias(targetPath);
     let current = resolvePathPreservingWindowsRoot(targetPath);

package/node_modules/@openclaw/fs-safe/dist/root-errors.js

@@ -29,7 +29,41 @@ export function hardlinkedPathNotAllowedError() {
 export function isAlreadyExistsError(error) {
     return hasNodeErrorCode(error, "EEXIST") || /File exists|EEXIST/i.test(String(error));
 }
+function descriptorExhaustion(error) {
+    const pending = [error];
+    let details;
+    let code;
+    const seen = new Set();
+    while (pending.length) {
+        const current = pending.pop();
+        if (!(current instanceof Error) || seen.has(current))
+            continue;
+        seen.add(current);
+        // Keep boundary/policy failures primary, including combined failures.
+        if (current instanceof FsSafeError && current.code !== "helper-failed" && current.code !== "not-removable")
+            return;
+        const diagnostic = current;
+        if (current instanceof FsSafeError && (!details || current.details?.cleanup))
+            details = current.details ?? details;
+        if (diagnostic.code === "EMFILE" || diagnostic.code === "ENFILE")
+            code ??= diagnostic.code;
+        if (diagnostic.name === "SuppressedError")
+            pending.push(diagnostic.suppressed, diagnostic.error);
+        if (current instanceof AggregateError)
+            pending.push(...current.errors);
+        pending.push(current.cause);
+    }
+    if (!code)
+        return;
+    const cleanup = details?.cleanup;
+    const publication = details?.publication;
+    const preserved = cleanup?.status === "preserved" && publication?.status === "indeterminate";
+    return new FsSafeError("helper-failed", `filesystem write failed: too many open files (${code})${preserved ? "; publication outcome is indeterminate; staged file preserved" : ""}`, { cause: error, details });
+}
 export function normalizePinnedWriteError(error) {
+    const exhausted = descriptorExhaustion(error);
+    if (exhausted)
+        return exhausted;
     if (error instanceof FsSafeError) {
         return error;
     }