@openclaw/openshell-sandbox 2026.9.5 → 2026.9.6

package/node_modules/@openclaw/fs-safe/dist/temp-workspace-child-admission.js

@@ -1,8 +1,76 @@
-import { inspectDirectoryIdentitySync } from "./directory-guard.js";
+import fsSync, {} from "node:fs";
+import { inspectDirectoryIdentitySync, observeDirectoryIdentitySync } from "./directory-guard.js";
 import { pinNodeDirectoryForMode, pinNodeDirectoryForModeSync } from "./directory-mode-node.js";
 import { FsSafeError } from "./errors.js";
-import { TEMP_WORKSPACE_NUMERIC_IDENTITY_REPLAY, } from "./temp-workspace-identity.js";
-import { assertTrustedTempWorkspaceDirectory } from "./temp-workspace-permissions.js";
+import { recordFileObservationFailure } from "./file-observation.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
+export const TEMP_WORKSPACE_NUMERIC_IDENTITY_REPLAY = process.platform === "linux" || process.platform === "darwin";
+export function projectTempWorkspaceNumericIdentity(identity) {
+    const dev = Number(identity.dev);
+    const ino = Number(identity.ino);
+    if (!Number.isSafeInteger(dev) || dev < 0 || BigInt(dev) !== identity.dev ||
+        !Number.isSafeInteger(ino) || ino < 0 || BigInt(ino) !== identity.ino) {
+        return undefined;
+    }
+    return Object.freeze({ dev, ino });
+}
+function identityMismatch() {
+    const error = new FsSafeError("path-mismatch", "file identity changed or could not be verified");
+    recordFileObservationFailure(error, "identity");
+    throw error;
+}
+function inspectNumericIdentity(current, expected) {
+    if (!Number.isSafeInteger(current.dev) || current.dev < 0 || current.dev !== expected.dev ||
+        !Number.isSafeInteger(current.ino) || current.ino < 0 || current.ino !== expected.ino) {
+        identityMismatch();
+    }
+    return current;
+}
+export function inspectTempWorkspaceDescriptorIdentitySync(fd, expected, numeric) {
+    // A malformed or mismatched numeric observation is definite and never
+    // retried. Unsafe receipts and other platforms retain exact replay.
+    if (TEMP_WORKSPACE_NUMERIC_IDENTITY_REPLAY && numeric) {
+        return inspectNumericIdentity(fsSync.fstatSync(fd), numeric);
+    }
+    return inspectFileIdentitySync(() => fsSync.fstatSync(fd, { bigint: true }), expected);
+}
+export function inspectTempWorkspaceDirectoryIdentitySync(dir, expected, numeric) {
+    if (TEMP_WORKSPACE_NUMERIC_IDENTITY_REPLAY && numeric) {
+        return inspectNumericIdentity(observeDirectoryIdentitySync(dir), numeric);
+    }
+    return inspectFileIdentitySync(() => observeDirectoryIdentitySync(dir, { bigint: true }), expected);
+}
+export function validateTempWorkspaceDirMode(mode) {
+    if (!Number.isInteger(mode) || mode < 0 || mode > 0o7777) {
+        throw new FsSafeError("insecure-permissions", "temp workspace dirMode must be permission bits");
+    }
+    if (process.platform !== "win32" && (mode & 0o022) !== 0) {
+        throw new FsSafeError("insecure-permissions", "temp workspace must not be group/world writable");
+    }
+}
+export function assertTrustedTempWorkspaceDirectory(stat, uid, child = false) {
+    if (uid === undefined)
+        return;
+    const ownedByUser = typeof stat.uid === "bigint" ? stat.uid === BigInt(uid) : stat.uid === uid;
+    const ownedByRoot = typeof stat.uid === "bigint" ? stat.uid === 0n : stat.uid === 0;
+    if (!ownedByUser && (child || !ownedByRoot)) {
+        throw new FsSafeError("not-owned", "temp workspace directory has an untrusted owner");
+    }
+    // A root/current-user-owned sticky directory protects children owned by us,
+    // including the usual shared system temp directory. Never chmod that parent.
+    const writable = typeof stat.mode === "bigint"
+        ? (stat.mode & 18n) !== 0n
+        : Number.isSafeInteger(stat.mode) && stat.mode >= 0 && (stat.mode & 0o022) !== 0;
+    const sticky = typeof stat.mode === "bigint"
+        ? (stat.mode & 512n) !== 0n
+        : Number.isSafeInteger(stat.mode) && stat.mode >= 0 && (stat.mode & 0o1000) !== 0;
+    if (typeof stat.mode !== "bigint" && (!Number.isSafeInteger(stat.mode) || stat.mode < 0)) {
+        throw new FsSafeError("insecure-permissions", "temp workspace directory permissions are invalid");
+    }
+    if (writable && (child || !sticky)) {
+        throw new FsSafeError("insecure-permissions", "temp workspace directory is group/world writable without sticky protection");
+    }
+}
 const WINDOWS = process.platform === "win32";
 export function assertTempWorkspaceChildState(stat, ownerUid) {
     const exactIdentity = typeof stat.dev === "bigint" && typeof stat.ino === "bigint" &&
@@ -74,18 +142,6 @@ export function admitTempWorkspaceChildSync(dir, expected, parent, mode) {
         owner.close();
     }
 }
-export function admitRetainedTempWorkspaceChild(retained, needsModeInitialization, parent, mode) {
-    if (!needsModeInitialization)
-        return undefined;
-    return retained.initializeMode(mode, parent.ownerUid, parent.assertCurrent);
-}
-export function admitRetainedTempWorkspaceChildSync(retained, needsModeInitialization, parent, mode) {
-    if (!needsModeInitialization) {
-        retained.discardInitialReceipt();
-        return;
-    }
-    retained.initializeModeSync(mode, parent.ownerUid, parent.assertCurrent);
-}
 export function validateAdmittedTempWorkspaceChild(current, ownerUid, mode) {
     assertTempWorkspaceChildState(current, ownerUid);
     if (!childHasRequestedMode(current, mode)) {

package/node_modules/@openclaw/fs-safe/dist/temp-workspace-descriptor.d.ts

@@ -1,18 +1,13 @@
 import fsSync from "node:fs";
 import type { FileIdentityStat } from "./file-identity.js";
 import type { TempWorkspaceRootAdmission } from "./temp-workspace-admission.js";
-import { type TempWorkspaceIdentityStat } from "./temp-workspace-identity.js";
+import { type TempWorkspaceIdentityStat } from "./temp-workspace-child-admission.js";
 type DirectoryDescriptorAccess = "read" | "search";
 export type RetainedDirectory = {
     fd: number;
     access: DirectoryDescriptorAccess;
     receipt: Readonly<{
         path: string;
-        realPath: string;
-        identity: Readonly<{
-            dev: bigint;
-            ino: bigint;
-        }>;
     }>;
 };
 export type RetainedChildDirectory = {
@@ -45,4 +40,3 @@ export declare class TempWorkspaceRetainedChild {
     close(): void;
 }
 export {};
-//# sourceMappingURL=temp-workspace-descriptor.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/temp-workspace-descriptor.js

@@ -5,8 +5,7 @@ import { assertOwnedDirectory } from "./directory-mode-owner.js";
 import { FsSafeError } from "./errors.js";
 import { assertNoWindowsPathAlias, pathForWindowsFilesystem, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
 import { inspectFileIdentitySync } from "./strict-file-identity.js";
-import { assertTempWorkspaceChildState, childHasRequestedMode, validateAdmittedTempWorkspaceChild, } from "./temp-workspace-child-admission.js";
-import { inspectTempWorkspaceDescriptorIdentitySync, inspectTempWorkspaceDirectoryIdentitySync, projectTempWorkspaceNumericIdentity, TEMP_WORKSPACE_NUMERIC_IDENTITY_REPLAY, } from "./temp-workspace-identity.js";
+import { assertTempWorkspaceChildState, childHasRequestedMode, validateAdmittedTempWorkspaceChild, inspectTempWorkspaceDescriptorIdentitySync, inspectTempWorkspaceDirectoryIdentitySync, projectTempWorkspaceNumericIdentity, TEMP_WORKSPACE_NUMERIC_IDENTITY_REPLAY, } from "./temp-workspace-child-admission.js";
 function assertRetainedChildDirectory(stat) {
     if (stat.isSymbolicLink() || !stat.isDirectory()) {
         throw new FsSafeError("not-file", "temp workspace child must be a real directory");
@@ -80,8 +79,6 @@ export function openTempWorkspaceCleanupParent(root, admission) {
             access: opened.access,
             receipt: Object.freeze({
                 path: pathname,
-                realPath: admission.realPath,
-                identity: admission.identity,
             }),
         };
     }
@@ -185,18 +182,15 @@ export class TempWorkspaceRetainedChild {
         return descriptor;
     }
     async #assertProcAuthority(fd, ownerUid) {
-        if ((await fs.statfs("/proc/self/fd", { bigint: true })).type !== 0x9fa0n) {
-            throw new FsSafeError("path-mismatch", "directory mode requires a trusted procfs fd namespace");
-        }
-        const procPath = `/proc/self/fd/${fd}`;
-        const opened = inspectFileIdentitySync(() => fsSync.fstatSync(fd, { bigint: true }), this.#identity);
-        const followed = inspectFileIdentitySync(() => fsSync.statSync(procPath, { bigint: true }), this.#identity);
-        assertOwnedDirectory(opened, followed);
-        assertTempWorkspaceChildState(opened, ownerUid);
-        assertTempWorkspaceChildState(followed, ownerUid);
+        const filesystem = await fs.statfs("/proc/self/fd", { bigint: true });
+        this.#assertProcDescriptorAuthority(fd, ownerUid, filesystem.type);
     }
     #assertProcAuthoritySync(fd, ownerUid) {
-        if (fsSync.statfsSync("/proc/self/fd", { bigint: true }).type !== 0x9fa0n) {
+        const filesystem = fsSync.statfsSync("/proc/self/fd", { bigint: true });
+        this.#assertProcDescriptorAuthority(fd, ownerUid, filesystem.type);
+    }
+    #assertProcDescriptorAuthority(fd, ownerUid, filesystemType) {
+        if (filesystemType !== 0x9fa0n) {
             throw new FsSafeError("path-mismatch", "directory mode requires a trusted procfs fd namespace");
         }
         const procPath = `/proc/self/fd/${fd}`;
@@ -309,13 +303,7 @@ export class TempWorkspaceRetainedChild {
         catch (error) {
             // The readable replacement has not been installed. Give it exactly one
             // close attempt and leave neither indeterminate descriptor owned here.
-            try {
-                fsSync.closeSync(fd);
-            }
-            catch (closeError) {
-                throw new AggregateError([error, closeError], "temp workspace child descriptor replacement close failed");
-            }
-            throw error;
+            closeAfterAdmissionFailure(fd, error, "temp workspace child descriptor replacement close failed");
         }
         this.#fd = fd;
         this.#access = "read";
@@ -334,16 +322,7 @@ export class TempWorkspaceRetainedChild {
         const fd = this.#fd;
         this.#fd = undefined;
         if (retainDescriptor && !this.canEnumerate) {
-            try {
-                fsSync.closeSync(fd);
-            }
-            catch (closeError) {
-                throw new AggregateError([
-                    new FsSafeError("helper-unavailable", "temp workspace cleanup requires a readable child descriptor"),
-                    closeError,
-                ], "temp workspace child descriptor rejection and close failed");
-            }
-            throw new FsSafeError("helper-unavailable", "temp workspace cleanup requires a readable child descriptor");
+            closeAfterAdmissionFailure(fd, new FsSafeError("helper-unavailable", "temp workspace cleanup requires a readable child descriptor"), "temp workspace child descriptor rejection and close failed");
         }
         if (!retainDescriptor) {
             fsSync.closeSync(fd);

package/node_modules/@openclaw/fs-safe/dist/temp-workspace-owner.d.ts

@@ -15,10 +15,10 @@ export declare class TempWorkspaceCleanupCapability {
     assertAncestryCurrent(): void;
     close(): void;
 }
+export declare function throwTempWorkspaceCreationFailure(error: unknown, retainedChild: TempWorkspaceRetainedChild | undefined, capability: TempWorkspaceCleanupCapability, owner?: TempWorkspaceCleanupOwner, label?: string): never;
 export declare class TempWorkspaceCleanupOwner {
     #private;
     constructor(retained: TempWorkspaceRetainedChild, capability: TempWorkspaceCleanupCapability, retainDescriptor: boolean);
     cleanup(): Promise<TempWorkspaceCleanupResult>;
     cleanupSync(): TempWorkspaceCleanupResult;
 }
-//# sourceMappingURL=temp-workspace-owner.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/temp-workspace-owner.js

@@ -58,10 +58,10 @@ export class TempWorkspaceCleanupCapability {
         try {
             parent = openTempWorkspaceCleanupParent(root, admission);
         }
-        catch {
-            if (parent)
-                fsSync.closeSync(parent.fd);
-            parent = undefined;
+        catch (error) {
+            // Failed descriptor closure must retain the original admission failure too.
+            if (error instanceof AggregateError)
+                throw error;
         }
         let available = false;
         if (childModeAllowsRemoval && parent?.access === "read" && isNativeCleanupBinding(binding)) {
@@ -158,6 +158,36 @@ export class TempWorkspaceCleanupCapability {
             fsSync.closeSync(this.parent.fd);
     }
 }
+export function throwTempWorkspaceCreationFailure(error, retainedChild, capability, owner, label = "temp workspace") {
+    try {
+        if (owner)
+            owner.cleanupSync();
+        else {
+            const closeErrors = [];
+            try {
+                retainedChild?.close();
+            }
+            catch (closeError) {
+                closeErrors.push(closeError);
+            }
+            try {
+                capability.close();
+            }
+            catch (closeError) {
+                closeErrors.push(closeError);
+            }
+            if (closeErrors.length === 1)
+                throw closeErrors[0];
+            if (closeErrors.length > 1) {
+                throw new AggregateError(closeErrors, `${label} admission descriptor close failed`);
+            }
+        }
+    }
+    catch (cleanupError) {
+        throw new AggregateError([error, cleanupError], `${label} creation and cleanup both failed`);
+    }
+    throw error;
+}
 export class TempWorkspaceCleanupOwner {
     #dir;
     #identity;
@@ -294,22 +324,19 @@ export class TempWorkspaceCleanupOwner {
                 await beforeNativeRemoval(quarantine.path);
             return this.#mapRemoval(await this.#capability.binding.removeOwnedTree(this.#capability.parent.fd, quarantine.name, this.#directory.fd));
         }
-        let removalError;
         try {
             this.#assertQuarantine(quarantine);
-            try {
-                await fs.rm(quarantine.path, { recursive: true, force: true });
-            }
-            catch (error) {
-                removalError = error;
-                throw error;
-            }
+        }
+        catch {
+            return "indeterminate";
+        }
+        // Removal failures propagate unchanged; only authority uncertainty becomes a receipt.
+        await fs.rm(quarantine.path, { recursive: true, force: true });
+        try {
             this.#capability.assertCurrent();
             return "removed";
         }
-        catch (error) {
-            if (error === removalError)
-                throw error;
+        catch {
             return "indeterminate";
         }
     }
@@ -318,22 +345,18 @@ export class TempWorkspaceCleanupOwner {
             getFsSafeTestHooks()?.beforeTempWorkspaceNativeRemovalSync?.(quarantine.path);
             return this.#mapRemoval(this.#capability.binding.removeOwnedTreeSync(this.#capability.parent.fd, quarantine.name, this.#directory.fd));
         }
-        let removalError;
         try {
             this.#assertQuarantine(quarantine);
-            try {
-                fsSync.rmSync(quarantine.path, { recursive: true, force: true });
-            }
-            catch (error) {
-                removalError = error;
-                throw error;
-            }
+        }
+        catch {
+            return "indeterminate";
+        }
+        fsSync.rmSync(quarantine.path, { recursive: true, force: true });
+        try {
             this.#capability.assertCurrent();
             return "removed";
         }
-        catch (error) {
-            if (error === removalError)
-                throw error;
+        catch {
             return "indeterminate";
         }
     }

package/node_modules/@openclaw/fs-safe/dist/temp-workspace-types.d.ts

@@ -37,4 +37,3 @@ export type TempWorkspaceSync = {
     cleanup(): TempWorkspaceCleanupResult;
     [Symbol.dispose](): void;
 };
-//# sourceMappingURL=temp-workspace-types.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/temp.d.ts

@@ -1,4 +1,3 @@
 export { tempWorkspace, type TempWorkspace, type TempWorkspaceOptions, type TempWorkspaceCleanupResult, type TempWorkspaceCleanupSafety, tempWorkspaceSync, type TempWorkspaceSync, withTempWorkspace, withTempWorkspaceSync, } from "./private-temp-workspace.js";
 export type { TempPathIdentityReceipt } from "./temp-cleanup.js";
 export { resolveSecureTempRoot, type ResolveSecureTempRootOptions, type SecureTempRootDescriptorAdapter, } from "./secure-temp-dir.js";
-//# sourceMappingURL=temp.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/test-hooks.d.ts

@@ -29,4 +29,3 @@ export type FsSafeTestHooks = {
 };
 export declare function getFsSafeTestHooks(): FsSafeTestHooks | undefined;
 export declare function __setFsSafeTestHooksForTest(hooks?: FsSafeTestHooks): void;
-//# sourceMappingURL=test-hooks.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/text-atomic.d.ts

@@ -11,4 +11,3 @@ export type WriteTextAtomicOptions = {
     durable?: boolean;
 };
 export declare function writeTextAtomic(filePath: string, content: string, options?: WriteTextAtomicOptions): Promise<void>;
-//# sourceMappingURL=text-atomic.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/text-atomic.js

@@ -1,5 +1,5 @@
 import { replaceFileAtomic } from "./replace-file.js";
-import { admitStandalonePublicationPath } from "./standalone-publication-path.js";
+import { admitStandalonePublicationPath } from "./windows-path-alias.js";
 export async function writeTextAtomic(filePath, content, options) {
     const admittedPath = admitStandalonePublicationPath(filePath);
     const payload = options?.trailingNewline && !content.endsWith("\n") ? `${content}\n` : content;

package/node_modules/@openclaw/fs-safe/dist/timing.d.ts

@@ -6,4 +6,3 @@ export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, l
     message?: string;
     createError?: () => Error;
 }): Promise<T>;
-//# sourceMappingURL=timing.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/trash.d.ts

@@ -2,4 +2,3 @@ export type MovePathToTrashOptions = {
     allowedRoots?: Iterable<string>;
 };
 export declare function movePathToTrash(targetPath: string, options?: MovePathToTrashOptions): Promise<string>;
-//# sourceMappingURL=trash.d.ts.map

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

@@ -20,4 +20,3 @@ export type BasePathOptions = {
     rootDir: string;
     relativePath: string;
 };
-//# sourceMappingURL=types.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/unicode-path.d.ts

@@ -1,3 +1,2 @@
 export declare function lowerCaseNfc(value: string): string;
 export declare function maxNormalizedUtf8Bytes(value: string, includeRaw?: boolean): number;
-//# sourceMappingURL=unicode-path.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/unicode-path.js

@@ -3,6 +3,9 @@ export function lowerCaseNfc(value) {
     return NON_ASCII.test(value) ? value.normalize("NFC").toLowerCase().normalize("NFC") : value.toLowerCase();
 }
 export function maxNormalizedUtf8Bytes(value, includeRaw = false) {
+    // ASCII has identical raw, NFC and NFD forms, with one UTF-8 byte per unit.
+    if (typeof value === "string" && !NON_ASCII.test(value))
+        return value.length;
     const nfc = value.normalize("NFC");
     const bytes = Buffer.byteLength(nfc, "utf8");
     const maximum = includeRaw && nfc !== value ? Math.max(bytes, Buffer.byteLength(value, "utf8")) : bytes;

package/node_modules/@openclaw/fs-safe/dist/walk.d.ts

@@ -16,6 +16,10 @@ export type WalkDirectoryOptions = {
     include?: (entry: WalkDirectoryEntry) => boolean;
     descend?: (entry: WalkDirectoryEntry) => boolean;
 };
+export type AsyncWalkDirectoryOptions = Omit<WalkDirectoryOptions, "include" | "descend"> & {
+    include?: (entry: WalkDirectoryEntry) => boolean | Promise<boolean>;
+    descend?: (entry: WalkDirectoryEntry) => boolean | Promise<boolean>;
+};
 export type WalkDirectoryFailure = {
     path: string;
     relativePath: string;
@@ -32,6 +36,5 @@ type WalkDirectoryResultWithFailures = WalkDirectoryResult & {
     failedDirs: WalkDirectoryFailure[];
 };
 export declare function walkDirectorySync(rootDir: string, options?: WalkDirectoryOptions): WalkDirectoryResultWithFailures;
-export declare function walkDirectory(rootDir: string, options?: WalkDirectoryOptions): Promise<WalkDirectoryResultWithFailures>;
+export declare function walkDirectory(rootDir: string, options?: AsyncWalkDirectoryOptions): Promise<WalkDirectoryResultWithFailures>;
 export {};
-//# sourceMappingURL=walk.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/walk.js

@@ -16,6 +16,10 @@ function validateWalkOptions(options) {
         throw new TypeError(`invalid walk symlink policy: ${String(options.symlinks)}`);
     }
 }
+function isObjectResult(result) {
+    return result !== null &&
+        (typeof result === "object" || typeof result === "function");
+}
 function kindForDirent(dirent) {
     if (dirent.isDirectory())
         return "directory";
@@ -85,6 +89,8 @@ export function walkDirectorySync(rootDir, options = {}) {
         let realDir;
         const operationPath = pathForWindowsFilesystem(dir);
         try {
+            if (depth > 1 && symlinks !== "follow" && fsSync.lstatSync(operationPath).isSymbolicLink())
+                return;
             realDir = realpathSync(operationPath);
         }
         catch (error) {
@@ -102,13 +108,14 @@ export function walkDirectorySync(rootDir, options = {}) {
             recordFailedDir(result, root, dir, depth, error);
             return;
         }
+        const childPrefix = dir.endsWith(path.sep) ? dir : `${dir}${path.sep}`;
         for (const dirent of entries) {
             if (shouldStop(result, options)) {
                 result.truncated = true;
                 return;
             }
             result.scannedEntryCount += 1;
-            const fullPath = path.join(dir, dirent.name);
+            const fullPath = childPrefix + dirent.name;
             const kind = resolveKind(fullPath, dirent, symlinks);
             if (!kind)
                 continue;
@@ -146,6 +153,8 @@ export async function walkDirectory(rootDir, options = {}) {
         let realDir;
         const operationPath = pathForWindowsFilesystem(dir);
         try {
+            if (depth > 1 && symlinks !== "follow" && fsSync.lstatSync(operationPath).isSymbolicLink())
+                return;
             realDir = realpathSync.native(operationPath);
         }
         catch (error) {
@@ -163,27 +172,33 @@ export async function walkDirectory(rootDir, options = {}) {
             recordFailedDir(result, root, dir, depth, error);
             return;
         }
+        const childPrefix = dir.endsWith(path.sep) ? dir : `${dir}${path.sep}`;
         for (const dirent of entries) {
             if (shouldStop(result, options)) {
                 result.truncated = true;
                 return;
             }
             result.scannedEntryCount += 1;
-            const fullPath = path.join(dir, dirent.name);
+            const fullPath = childPrefix + dirent.name;
             const kind = resolveKind(fullPath, dirent, symlinks);
             if (!kind)
                 continue;
             const relativePath = relativeDir ? `${relativeDir}${path.sep}${dirent.name}` : dirent.name;
             const entry = buildEntry({ relativePath, fullPath, dirent, depth, kind });
-            if (options.include?.(entry) ?? true) {
+            const include = options.include;
+            const included = include == null ? true : Reflect.apply(include, options, [entry]);
+            if ((isObjectResult(included) ? await included : included) ?? true) {
                 result.entries.push(entry);
             }
             if (kind === "directory" &&
-                (options.maxDepth === undefined || depth < options.maxDepth) &&
-                (options.descend?.(entry) ?? true)) {
-                await visit(fullPath, relativePath, depth + 1);
-                if (result.truncated)
-                    return;
+                (options.maxDepth === undefined || depth < options.maxDepth)) {
+                const descend = options.descend;
+                const descended = descend == null ? true : Reflect.apply(descend, options, [entry]);
+                if ((isObjectResult(descended) ? await descended : descended) ?? true) {
+                    await visit(fullPath, relativePath, depth + 1);
+                    if (result.truncated)
+                        return;
+                }
             }
         }
     }

package/node_modules/@openclaw/fs-safe/dist/windows-command.d.ts

@@ -1,2 +1 @@
 export declare function resolveWindowsSystemCommand(command: string, env?: NodeJS.ProcessEnv): string;
-//# sourceMappingURL=windows-command.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/windows-owner.d.ts

@@ -26,4 +26,3 @@ export declare function inspectWindowsOwner(params: {
     env?: NodeJS.ProcessEnv;
     exec: WindowsOwnerExec;
 }): Promise<WindowsOwnerSummary>;
-//# sourceMappingURL=windows-owner.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/windows-owner.js

@@ -1,4 +1,4 @@
-import { formatPermissionErrorDetail, getPermissionCommandFailure, } from "./permission-exec.js";
+import { formatCaughtPermissionFailure, getPermissionCommandFailure, } from "./permission-exec.js";
 import { resolveWindowsSystemCommand } from "./windows-command.js";
 import { hasWindowsPathAlias } from "./windows-path-alias.js";
 const SID_RE = /^\*?s-\d+-\d+(-\d+)+$/i;
@@ -14,6 +14,7 @@ function windowsOwnerQueryCommand(targetPath) {
     const encodedPath = Buffer.from(targetPath, "utf8").toString("base64");
     return [
         "$ErrorActionPreference='Stop'",
+        "$env:PSModulePath=[IO.Path]::Combine($PSHOME,'Modules')",
         `$p=[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${encodedPath}'))`,
         "$sections=[System.Security.AccessControl.AccessControlSections]::Access -bor [System.Security.AccessControl.AccessControlSections]::Owner",
         "$acl=if([IO.Directory]::Exists($p)){[IO.Directory]::GetAccessControl($p,$sections)}else{[IO.File]::GetAccessControl($p,$sections)}",
@@ -29,7 +30,7 @@ function windowsOwnerQueryCommand(targetPath) {
         "$raw=[System.Security.AccessControl.RawSecurityDescriptor]::new($acl.GetSecurityDescriptorBinaryForm(),0)",
         "$dacl=$raw.DiscretionaryAcl;$complete=$true",
         "$aces=@(foreach($ace in $dacl){if($ace -isnot [System.Security.AccessControl.CommonAce] -or $ace.IsCallback -or [int]$ace.AceType -notin @(0,1)){$complete=$false;continue};@{sid=$ace.SecurityIdentifier.Value;mask=([long]$ace.AccessMask -band 4294967295);deny=([int]$ace.AceType -eq 1);inheritOnly=([int]$ace.AceFlags -band 8) -ne 0}})",
-        "@{ownerSid=$ownerSid;currentUserSid=$currentSid;daclPresent=($null -ne $dacl);aces=$aces;complete=$complete;remote=$remote}|ConvertTo-Json -Depth 4 -Compress",
+        "@{ownerSid=$ownerSid;currentUserSid=$currentSid;daclPresent=($null -ne $dacl);aces=$aces;complete=$complete;remote=$remote}|Microsoft.PowerShell.Utility\\ConvertTo-Json -Depth 4 -Compress",
     ].join(";");
 }
 function parseWindowsAclFacts(parsed) {
@@ -78,7 +79,10 @@ export async function inspectWindowsOwner(params) {
         if (!ownerSid || !currentUserSid) {
             return { error: "Windows owner query returned invalid SID data" };
         }
-        const remote = parsed.remote === true;
+        const remote = parsed.remote;
+        if (typeof remote !== "boolean") {
+            return { error: "Windows owner query returned invalid locality data" };
+        }
         return {
             sid: ownerSid,
             currentUserSid,
@@ -89,7 +93,7 @@ export async function inspectWindowsOwner(params) {
     }
     catch (err) {
         return {
-            error: formatPermissionErrorDetail(String(err)),
+            error: formatCaughtPermissionFailure(err),
             errorDetail: getPermissionCommandFailure(err, command, performance.now() - startedAt),
             errorCause: err,
         };

package/node_modules/@openclaw/fs-safe/dist/windows-path-alias.d.ts

@@ -36,4 +36,4 @@ export declare function hasWindowsPathAlias(value: string, kind: WindowsPathAlia
 export declare function assertNoWindowsPathAliasForPlatform(value: string, kind: WindowsPathAliasKind, message: string, platform: NodeJS.Platform | string | undefined): void;
 export declare function assertNoWindowsPathAlias(value: string, kind?: WindowsPathAliasKind, message?: string, platform?: NodeJS.Platform | string): void;
 export declare function isWindowsPathAliasError(error: unknown): error is FsSafeError;
-//# sourceMappingURL=windows-path-alias.d.ts.map
+export declare function admitStandalonePublicationPath(value: string, message?: string): string;