@openclaw/openshell-sandbox 2026.9.5 → 2026.9.6

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

@@ -19,15 +19,23 @@ function resolutionError(code, absolutePath) {
         code, syscall: "resolvePathPrefix", path: absolutePath,
     });
 }
+// Leave ample room for ordinary shallow paths to retain the legacy small-array
+// path. At 32 components, repeated front removal can reindex at most 496 array
+// positions per constructed queue; longer queues use a forward cursor instead.
+const SHIFT_QUEUE_COMPONENT_LIMIT = 32;
 export function resolvePathPrefixSync(input) {
     assertNoNulPathInput(input);
     const absolutePath = absolutePathWithRawSegments(input);
     let resolved = rawRoot(absolutePath);
-    const remaining = absolutePath.slice(resolved.length).split(path.sep);
+    let remaining = absolutePath.slice(resolved.length).split(path.sep);
+    let shiftQueue = remaining.length <= SHIFT_QUEUE_COMPONENT_LIMIT;
+    let nextSegment = 0;
+    let remainingCount = remaining.length;
     const visitedStates = new Set();
     let symlinkHops = 0;
-    while (remaining.length > 0) {
-        const segment = remaining.shift();
+    while (remainingCount > 0) {
+        const segment = shiftQueue ? remaining.shift() : remaining[nextSegment++];
+        remainingCount--;
         if (segment === "")
             continue;
         if (segment === "." || segment === "..") {
@@ -51,32 +59,46 @@ export function resolvePathPrefixSync(input) {
             return {
                 absolutePath,
                 existingPath: realpathSync.native(pathForWindowsFilesystem(resolved)),
-                unresolvedSegments: [segment, ...remaining],
+                unresolvedSegments: shiftQueue ? [segment, ...remaining] : remaining.slice(nextSegment - 1),
             };
         }
         if (!stat.isSymbolicLink()) {
-            if (!stat.isDirectory() && remaining.length > 0)
+            if (!stat.isDirectory() && remainingCount > 0)
                 throw resolutionError("ENOTDIR", absolutePath);
             resolved = candidate;
             continue;
         }
-        const state = JSON.stringify([String(stat.dev), String(stat.ino), candidate, remaining]);
+        const pendingSuffix = shiftQueue ? remaining : remaining.slice(nextSegment);
+        const state = JSON.stringify([String(stat.dev), String(stat.ino), candidate, pendingSuffix]);
         if (symlinkHops >= 64 || visitedStates.has(state))
             throw resolutionError("ELOOP", absolutePath);
         visitedStates.add(state);
         symlinkHops++;
         const target = fs.readlinkSync(candidate);
         const rawTarget = path.sep === "\\" ? target.replaceAll("/", "\\") : target;
+        let targetSegments;
         if (path.isAbsolute(rawTarget)) {
             const targetRoot = rawRoot(rawTarget);
             // A rooted Windows link target uses the link's drive/share, not cwd's.
             resolved = path.sep === "\\" && targetRoot === "\\" ? rawRoot(resolved) : targetRoot;
-            remaining.unshift(...rawTarget.slice(targetRoot.length).split(path.sep));
+            targetSegments = rawTarget.slice(targetRoot.length).split(path.sep);
         }
         else {
             // A target's parent traversal applies after resolving its preceding links.
-            remaining.unshift(...rawTarget.split(path.sep));
+            targetSegments = rawTarget.split(path.sep);
         }
+        const expandedCount = targetSegments.length + pendingSuffix.length;
+        if (expandedCount <= SHIFT_QUEUE_COMPONENT_LIMIT) {
+            // The spread is bounded by the same fixed limit as subsequent shifts.
+            remaining = pendingSuffix;
+            remaining.unshift(...targetSegments);
+        }
+        else {
+            remaining = targetSegments.concat(pendingSuffix);
+        }
+        remainingCount = remaining.length;
+        shiftQueue = remainingCount <= SHIFT_QUEUE_COMPONENT_LIMIT;
+        nextSegment = 0;
     }
     return { absolutePath, existingPath: realpathSync.native(pathForWindowsFilesystem(resolved)), unresolvedSegments: [] };
 }

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

@@ -11,4 +11,3 @@ export declare function resolvePathWithinNormalizedRoot(params: ResolvePathWithi
     ok: false;
     error: string;
 };
-//# sourceMappingURL=path-scope-lexical.d.ts.map

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

@@ -4,4 +4,3 @@ export type PathSegmentRoute = Readonly<{
 }>;
 export declare function createPathSegmentRoute(segments: readonly string[]): PathSegmentRoute;
 export declare function joinPathSegmentRoute(base: string, route: PathSegmentRoute, offset: number, tail?: string): string;
-//# sourceMappingURL=path-segment-route.d.ts.map

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

@@ -2,9 +2,10 @@ export type ProbePathSuffixAliasesOptions = {
     directory: string;
     left: string;
     right: string;
+    /** Maximum relative component count; defaults to 32. */
+    maxDepth?: number;
     /** Synchronous caller policy for differing NFC pairs not equivalent under ASCII case folding. */
     shouldProbeCaseVariants?: (leftNfc: string, rightNfc: string) => boolean;
 };
 /** Observe bounded missing suffix aliases; the caller owns caching and ambiguity policy. */
 export declare function probePathSuffixAliasesSync(options: ProbePathSuffixAliasesOptions): boolean | undefined;
-//# sourceMappingURL=path-suffix-aliases.d.ts.map

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

@@ -15,6 +15,7 @@ const MAX_SUFFIX_DEPTH = 32;
 const MAX_MKDIR_ATTEMPTS = 128;
 const MAX_CREATED_DIRECTORIES = 64;
 const MAX_FORWARD_OBSERVATIONS = 4_096;
+const MAX_SCALED_FORWARD_OBSERVATIONS = 32_768;
 const PROBE_NAME_LENGTH = 6;
 const PROBE_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
 const PROBE_FIRST_ALPHABET = "bdefghijkmoqrstuvwxyz";
@@ -25,7 +26,7 @@ function assertMutationPath(value) {
     if (value.length > MAX_PATH_LENGTH)
         unavailable();
 }
-function suffixSegments(value) {
+function suffixSegments(value, maxDepth) {
     if (typeof value !== "string")
         throw new TypeError("suffix must be a string");
     if (value.length > MAX_SUFFIX_LENGTH)
@@ -35,8 +36,8 @@ function suffixSegments(value) {
     }
     const windows = process.platform === "win32";
     const segments = (windows ? value.replaceAll("/", "\\") : value).split(path.sep);
-    if (segments.length > MAX_SUFFIX_DEPTH)
-        throw new RangeError("suffix exceeds 32 components");
+    if (segments.length > maxDepth)
+        throw new RangeError(`suffix exceeds ${maxDepth} components`);
     if (segments.some(segment => !segment || segment === "." || segment === ".." ||
         (windows && (segment.includes(":") || /^[ .]+$/u.test(segment) ||
             isWindowsReservedDeviceName(segment))))) {
@@ -96,14 +97,8 @@ function createPrivateProbeName(nameLength) {
     return name;
 }
 function* asciiCaseProbePairs(nameLength, forbidden) {
-    let count = 0;
-    for (let attempt = 0; attempt < 96 && count < 24; attempt++) {
-        const first = createPrivateProbeName(nameLength);
-        const second = `${first[0].toUpperCase()}${first.slice(1)}`;
-        if (!forbidden(first) && !forbidden(second)) {
-            count++;
-            yield [first, second];
-        }
+    for (const first of privateProbeNames(nameLength, forbidden)) {
+        yield [first, `${first[0].toUpperCase()}${first.slice(1)}`];
     }
 }
 function* privateProbeNames(nameLength, forbidden) {
@@ -128,8 +123,16 @@ class ProbeDirectories {
     observations = 0;
     mkdirAttempts = 0;
     creations = 0;
-    constructor(requestedDirectory) {
+    maxObservations;
+    maxMkdirAttempts;
+    maxCreations;
+    constructor(requestedDirectory, depth) {
         this.requestedDirectory = requestedDirectory;
+        // The suffix-length limit bounds actual depth, so these products remain safe integers.
+        const scale = Math.max(1, depth / MAX_SUFFIX_DEPTH);
+        this.maxObservations = Math.min(MAX_SCALED_FORWARD_OBSERVATIONS, MAX_FORWARD_OBSERVATIONS * scale * scale);
+        this.maxMkdirAttempts = MAX_MKDIR_ATTEMPTS * scale;
+        this.maxCreations = MAX_CREATED_DIRECTORIES * scale;
         this.observe(1);
         const canonical = realpathSync.native(pathForWindowsFilesystem(requestedDirectory));
         assertMutationPath(canonical);
@@ -138,7 +141,7 @@ class ProbeDirectories {
         this.assert(this.root);
     }
     reserveObservations(units) {
-        if (this.observations + units > MAX_FORWARD_OBSERVATIONS)
+        if (units > this.maxObservations - this.observations)
             unavailable();
     }
     observe(units, cleanup = false) {
@@ -159,7 +162,7 @@ class ProbeDirectories {
         }
     }
     create(parent, name) {
-        if (this.mkdirAttempts >= MAX_MKDIR_ATTEMPTS || this.creations >= MAX_CREATED_DIRECTORIES)
+        if (this.mkdirAttempts >= this.maxMkdirAttempts || this.creations >= this.maxCreations)
             unavailable();
         const probePath = path.join(parent.path, name);
         assertMutationPath(probePath);
@@ -337,11 +340,16 @@ export function probePathSuffixAliasesSync(options) {
     const directory = resolvePathPreservingWindowsRoot(requestedDirectory);
     if (directory.length > MAX_PATH_LENGTH)
         throw new RangeError("resolved directory exceeds 32768 code units");
+    const requestedMaxDepth = options.maxDepth;
+    const maxDepth = requestedMaxDepth === undefined ? MAX_SUFFIX_DEPTH : requestedMaxDepth;
+    if (!Number.isSafeInteger(maxDepth) || maxDepth < 0) {
+        throw new RangeError("maxDepth must be a non-negative safe integer");
+    }
     const leftInput = options.left;
     const rightInput = options.right;
     const predicate = options.shouldProbeCaseVariants;
-    const left = suffixSegments(leftInput);
-    const right = suffixSegments(rightInput);
+    const left = suffixSegments(leftInput, maxDepth);
+    const right = suffixSegments(rightInput, maxDepth);
     if (left.length !== right.length)
         throw new TypeError("suffixes must have the same component count");
     if (predicate !== undefined && typeof predicate !== "function") {
@@ -370,7 +378,7 @@ export function probePathSuffixAliasesSync(options) {
     let observed;
     let cleaned = true;
     try {
-        observed = observeSuffixes(() => owner ??= new ProbeDirectories(directory), left, right, shouldProbe);
+        observed = observeSuffixes(() => owner ??= new ProbeDirectories(directory, left.length), left, right, shouldProbe);
         owner?.assert(owner.root);
     }
     catch {

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

@@ -18,4 +18,3 @@ export declare function isPathInsideWithRealpath(basePath: string, candidatePath
 export declare function safeStatSync(targetPath: string): fs.Stats | null;
 export declare function splitSafeRelativePath(relativePath: string): string[];
 export declare function resolveSafeRelativePath(rootDir: string, relativePath: string): string;
-//# sourceMappingURL=path.d.ts.map

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

@@ -160,7 +160,8 @@ export function splitSafeRelativePath(relativePath) {
 export function resolveSafeRelativePath(rootDir, relativePath) {
     assertNoWindowsPathAlias(rootDir, "filesystem", "root dir uses a Windows filesystem namespace alias");
     const root = resolvePathPreservingWindowsRoot(rootDir);
-    const target = resolvePathFromBasePreservingWindowsRoot(root, ...splitSafeRelativePath(relativePath));
+    splitSafeRelativePath(relativePath);
+    const target = resolvePathFromBasePreservingWindowsRoot(root, relativePath);
     if (!isPathInside(root, target)) {
         throw new FsSafeError("outside-workspace", "relative path escapes root");
     }

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

@@ -8,6 +8,8 @@ export type PermissionCommandFailure = {
     stderr: string;
 };
 export declare function formatPermissionErrorDetail(value: string): string;
+/** Formats only caught permission-query failures without invoking user code. */
+export declare function formatCaughtPermissionFailure(error: unknown): string;
 export declare class PermissionCommandError extends Error implements PermissionCommandFailure {
     readonly command: string;
     readonly durationMs: number;
@@ -22,4 +24,3 @@ export declare function executePermissionCommand(command: string, args: string[]
     stdout: string;
     stderr: string;
 }>;
-//# sourceMappingURL=permission-exec.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/permission-exec.js

@@ -1,6 +1,6 @@
 import { execFile } from "node:child_process";
 import path from "node:path";
-import { promisify } from "node:util";
+import { promisify, types as utilTypes } from "node:util";
 import { formatErrorDetail } from "./error-detail.js";
 const execFileAsync = promisify(execFile);
 export const DEFAULT_PERMISSION_EXEC_TIMEOUT_MS = 30_000;
@@ -8,15 +8,121 @@ export function formatPermissionErrorDetail(value) {
     const formatted = formatErrorDetail(value);
     return formatted.length > 400 ? `${formatted.slice(0, 399)}…` : formatted;
 }
+const MAX_CAUGHT_FAILURE_PROTOTYPES = 4;
+const primitiveString = String;
+const isUint8Array = utilTypes.isUint8Array;
+const Uint8ArrayIntrinsic = Uint8Array;
+const typedArrayPrototype = Object.getPrototypeOf(Uint8ArrayIntrinsic.prototype);
+const typedArrayBufferGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, "buffer").get;
+const typedArrayByteOffsetGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteOffset").get;
+const typedArrayByteLengthGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteLength").get;
+const typedArraySet = Object.getOwnPropertyDescriptor(typedArrayPrototype, "set").value;
+const textDecoderDecode = TextDecoder.prototype.decode;
+const stderrDecoder = new TextDecoder("utf-8", {
+    fatal: false,
+    ignoreBOM: true,
+});
+const MAX_STDERR_BYTES = 1600;
+function isInspectableCaughtObject(value) {
+    if ((typeof value !== "object" || value === null) && typeof value !== "function") {
+        return false;
+    }
+    try {
+        return !utilTypes.isProxy(value);
+    }
+    catch {
+        return false;
+    }
+}
+function dataProperty(value, name) {
+    let current = value;
+    for (let depth = 0; current !== null && depth < MAX_CAUGHT_FAILURE_PROTOTYPES; depth += 1) {
+        if (!isInspectableCaughtObject(current))
+            return undefined;
+        let descriptor;
+        try {
+            descriptor = Object.getOwnPropertyDescriptor(current, name);
+        }
+        catch {
+            return undefined;
+        }
+        if (descriptor) {
+            return Object.hasOwn(descriptor, "value") ? descriptor : undefined;
+        }
+        try {
+            current = Object.getPrototypeOf(current);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return undefined;
+}
+function caughtPrimitiveDisplay(value) {
+    if (value !== null && (typeof value === "object" || typeof value === "function"))
+        return undefined;
+    return primitiveString(value);
+}
+/** Formats only caught permission-query failures without invoking user code. */
+export function formatCaughtPermissionFailure(error) {
+    const primitive = caughtPrimitiveDisplay(error);
+    if (primitive !== undefined)
+        return formatBoundedCaughtDetail(primitive);
+    if (!isInspectableCaughtObject(error)) {
+        return "Uninspectable proxy failure";
+    }
+    const message = dataProperty(error, "message");
+    const name = dataProperty(error, "name");
+    const rawMessage = typeof message?.value === "string"
+        ? message.value : "";
+    const rawName = typeof name?.value === "string"
+        ? name.value : "";
+    const messageText = rawMessage.slice(0, 400);
+    const nameText = rawName.slice(0, 400);
+    const display = messageText
+        ? (nameText ? `${nameText}: ${messageText}` : messageText)
+        : nameText || (typeof error === "function" ? "Unknown function failure" : "Unknown object failure");
+    return formatBoundedCaughtDetail(display, rawMessage.length > messageText.length || rawName.length > nameText.length);
+}
+function formatBoundedCaughtDetail(value, alreadyTruncated = false) {
+    const inputWasTruncated = alreadyTruncated || value.length > 400;
+    const formatted = formatPermissionErrorDetail(value.slice(0, 400));
+    if (!inputWasTruncated || formatted.endsWith("…"))
+        return formatted;
+    return `${formatted.slice(0, 399)}…`;
+}
+function safeStderr(value) {
+    if (typeof value === "string")
+        return formatBoundedCaughtDetail(value);
+    try {
+        if (!isUint8Array(value))
+            return "";
+        const backing = Reflect.apply(typedArrayBufferGetter, value, []);
+        const byteOffset = Reflect.apply(typedArrayByteOffsetGetter, value, []);
+        const byteLength = Reflect.apply(typedArrayByteLengthGetter, value, []);
+        const copiedByteLength = byteLength < MAX_STDERR_BYTES
+            ? byteLength : MAX_STDERR_BYTES;
+        const source = new Uint8ArrayIntrinsic(backing, byteOffset, copiedByteLength);
+        const copy = new Uint8ArrayIntrinsic(copiedByteLength);
+        Reflect.apply(typedArraySet, copy, [source, 0]);
+        const decoded = Reflect.apply(textDecoderDecode, stderrDecoder, [copy]);
+        return formatBoundedCaughtDetail(decoded, byteLength > copiedByteLength);
+    }
+    catch {
+        return "";
+    }
+}
 function commandFailureFields(error) {
-    const fields = error && typeof error === "object" ? error : {};
+    const killed = dataProperty(error, "killed");
+    const code = dataProperty(error, "code");
+    const signal = dataProperty(error, "signal");
+    const stderr = dataProperty(error, "stderr");
     return {
-        timedOut: "killed" in fields && fields.killed === true &&
-            "signal" in fields && fields.signal === "SIGKILL",
-        exitCode: "code" in fields && typeof fields.code === "number" ? fields.code : null,
-        signal: "signal" in fields && typeof fields.signal === "string" ? fields.signal : null,
-        stderr: formatPermissionErrorDetail("stderr" in fields && (typeof fields.stderr === "string" || Buffer.isBuffer(fields.stderr))
-            ? fields.stderr.toString() : ""),
+        found: !!(killed || code || signal || stderr),
+        timedOut: killed?.value === true && signal?.value === "SIGKILL",
+        exitCode: typeof code?.value === "number" ? code.value : null,
+        signal: typeof signal?.value === "string" ? signal.value : null,
+        stderr: stderr ? safeStderr(stderr.value) : "",
     };
 }
 export class PermissionCommandError extends Error {
@@ -41,21 +147,38 @@ export class PermissionCommandError extends Error {
     }
 }
 export function getPermissionCommandFailure(error, command, durationMs) {
-    if (error instanceof PermissionCommandError) {
-        return {
-            command: error.command,
-            durationMs: error.durationMs,
-            timedOut: error.timedOut,
-            exitCode: error.exitCode,
-            signal: error.signal,
-            stderr: error.stderr,
-        };
+    if (isInspectableCaughtObject(error) && utilTypes.isNativeError(error)) {
+        const name = dataProperty(error, "name");
+        if (name?.value === "PermissionCommandError") {
+            const wrappedCommand = dataProperty(error, "command");
+            const wrappedDuration = dataProperty(error, "durationMs");
+            const wrappedTimedOut = dataProperty(error, "timedOut");
+            const wrappedExitCode = dataProperty(error, "exitCode");
+            const wrappedSignal = dataProperty(error, "signal");
+            const wrappedStderr = dataProperty(error, "stderr");
+            if (typeof wrappedCommand?.value === "string" &&
+                typeof wrappedDuration?.value === "number" &&
+                Number.isSafeInteger(wrappedDuration.value) && wrappedDuration.value >= 0 &&
+                typeof wrappedTimedOut?.value === "boolean" &&
+                wrappedExitCode && (wrappedExitCode.value === null || typeof wrappedExitCode.value === "number") &&
+                wrappedSignal && (wrappedSignal.value === null || typeof wrappedSignal.value === "string") &&
+                wrappedStderr) {
+                return {
+                    command: wrappedCommand.value,
+                    durationMs: wrappedDuration.value,
+                    timedOut: wrappedTimedOut.value,
+                    exitCode: wrappedExitCode.value,
+                    signal: wrappedSignal.value,
+                    stderr: safeStderr(wrappedStderr.value),
+                };
+            }
+        }
     }
-    if (!error || typeof error !== "object" ||
-        !("code" in error || "signal" in error || "killed" in error || "stderr" in error)) {
+    const fields = commandFailureFields(error);
+    if (!fields.found)
         return undefined;
-    }
-    return { command, durationMs: Math.round(durationMs), ...commandFailureFields(error) };
+    const { found: _found, ...detail } = fields;
+    return { command, durationMs: Math.round(durationMs), ...detail };
 }
 export async function executePermissionCommand(command, args, timeoutMs = DEFAULT_PERMISSION_EXEC_TIMEOUT_MS) {
     const startedAt = performance.now();

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

@@ -1,4 +1,3 @@
 export { formatOctal, formatPermissionDetail, formatPermissionRemediation, inspectPathPermissions, isGroupReadable, isGroupWritable, isWorldReadable, isWorldWritable, modeBits, safeStat, type PermissionCheck, type PermissionCheckOptions, type PermissionCommandFailure, type SafeStatResult, } from "./permissions.js";
 export { createPrivateDirectory, type CreatePrivateDirectoryOptions, } from "./private-directory.js";
 export { readOwnerAndDacl, type OwnerAndDaclResult, type WindowsAccessControlEntry, type WindowsAceFlags, } from "./owner-dacl.js";
-//# sourceMappingURL=permissions-public.d.ts.map

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

@@ -1,5 +1,5 @@
 import { type PermissionCommandFailure } from "./permission-exec.js";
-import { type PermissionCheck, type PermissionCheckOptions, type SafeStatResult } from "./permissions.js";
+import { type PermissionCheck, type PermissionCheckOptions } from "./permissions.js";
 export type PermissionExec = (command: string, args: string[]) => Promise<{
     stdout: string;
     stderr: string;
@@ -31,14 +31,7 @@ export type IcaclsResetCommandOptions = {
     env?: NodeJS.ProcessEnv;
     userInfo?: WindowsUserInfoProvider;
 };
-export declare function inspectWindowsPermissions(params: {
-    targetPath: string;
-    stat: SafeStatResult;
-    effectiveIsDir: boolean;
-    effectiveMode: number | null;
-    bits: number | null;
-    opts?: PermissionCheckOptions;
-}): Promise<PermissionCheck>;
+export declare function inspectWindowsPermissions(targetPath: string, unverified: Readonly<PermissionCheck>, opts?: PermissionCheckOptions): Promise<PermissionCheck>;
 export declare function resolveWindowsUserPrincipal(env?: NodeJS.ProcessEnv, userInfo?: WindowsUserInfoProvider): string | null;
 export declare function parseIcaclsOutput(output: string, targetPath: string): WindowsAclEntry[];
 export declare function summarizeWindowsAcl(entries: WindowsAclEntry[], env?: NodeJS.ProcessEnv): Pick<WindowsAclSummary, "trusted" | "untrustedWorld" | "untrustedGroup">;
@@ -56,4 +49,3 @@ export declare function createIcaclsResetCommand(targetPath: string, opts: Icacl
     args: string[];
     display: string;
 } | null;
-//# sourceMappingURL=permissions-windows.d.ts.map

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

@@ -39,20 +39,16 @@ const TRUSTED_BASE_ASCII = new Set([...TRUSTED_BASE].map(stripDiacritics));
 const normalize = (value) => normalizeLowercaseStringOrEmpty(value);
 const defaultWindowsUserInfo = () => os.userInfo();
 const defaultPermissionExec = executePermissionCommand;
-function inspectWindowsPermissionsNative(params) {
+function inspectWindowsPermissionsNative(targetPath, unverified) {
     const native = getNativeBinding();
     if (!native)
         return undefined;
     try {
-        const facts = native.readOwnerAndDacl(params.targetPath);
+        const facts = native.readOwnerAndDacl(targetPath);
         if (facts.fallbackRequired)
             return undefined;
         return {
-            ok: true,
-            isSymlink: params.stat.isSymlink,
-            isDir: params.effectiveIsDir,
-            mode: params.effectiveMode,
-            bits: params.bits,
+            ...unverified,
             source: "windows-acl",
             worldWritable: facts.worldWritable,
             groupWritable: facts.groupWritable,
@@ -69,34 +65,22 @@ function inspectWindowsPermissionsNative(params) {
         return undefined;
     }
 }
-export async function inspectWindowsPermissions(params) {
-    const unverified = {
-        ok: true,
-        isSymlink: params.stat.isSymlink,
-        isDir: params.effectiveIsDir,
-        mode: params.effectiveMode,
-        bits: params.bits,
-        source: "unknown",
-        worldWritable: false,
-        groupWritable: false,
-        worldReadable: false,
-        groupReadable: false,
-    };
-    if (hasWindowsPathAlias(params.targetPath, "filesystem", "win32")) {
+export async function inspectWindowsPermissions(targetPath, unverified, opts) {
+    if (hasWindowsPathAlias(targetPath, "filesystem", "win32")) {
         return {
             ...unverified,
             error: "Path uses a Windows filesystem namespace alias",
         };
     }
-    const native = inspectWindowsPermissionsNative(params);
+    const native = inspectWindowsPermissionsNative(targetPath, unverified);
     if (native)
         return native;
     const owner = await inspectWindowsOwner({
-        targetPath: params.targetPath,
-        env: params.opts?.env,
-        exec: params.opts?.exec ?? defaultPermissionExec,
+        targetPath,
+        env: opts?.env,
+        exec: opts?.exec ?? defaultPermissionExec,
     });
-    if (owner.error) {
+    if (owner.error !== undefined) {
         const error = `Windows owner inspection failed: ${owner.error}`;
         return { ...unverified, ownerError: owner.error, error, errorDetail: owner.errorDetail, errorCause: owner.errorCause };
     }
@@ -109,11 +93,7 @@ export async function inspectWindowsPermissions(params) {
     if (!acl.ok)
         return { ...unverified, ...ownerFields, error: acl.error, errorDetail: acl.errorDetail, errorCause: acl.errorCause };
     return {
-        ok: true,
-        isSymlink: params.stat.isSymlink,
-        isDir: params.effectiveIsDir,
-        mode: params.effectiveMode,
-        bits: params.bits,
+        ...unverified,
         source: "windows-acl",
         worldWritable: acl.untrustedWorld.some((entry) => entry.canWrite),
         groupWritable: acl.untrustedGroup.some((entry) => entry.canWrite),

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

@@ -57,4 +57,3 @@ export declare function isGroupWritable(bits: number | null): boolean;
 export declare function isWorldReadable(bits: number | null): boolean;
 export declare function isGroupReadable(bits: number | null): boolean;
 export declare function formatPosixMode(mode: number): string;
-//# sourceMappingURL=permissions.d.ts.map

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

@@ -39,23 +39,9 @@ export async function inspectPathPermissions(targetPath, opts) {
     const admissionPlatform = process.platform === "win32"
         ? process.platform
         : (opts?.platform ?? process.platform);
-    if (hasWindowsPathAlias(targetPath, "filesystem", admissionPlatform)) {
-        const st = failedSafeStat("Path uses a Windows filesystem namespace alias");
-        return {
-            ok: false,
-            isSymlink: false,
-            isDir: false,
-            mode: null,
-            bits: null,
-            source: "unknown",
-            worldWritable: false,
-            groupWritable: false,
-            worldReadable: false,
-            groupReadable: false,
-            error: st.error,
-        };
-    }
-    const st = await safeStatAdmitted(targetPath);
+    const st = hasWindowsPathAlias(targetPath, "filesystem", admissionPlatform)
+        ? failedSafeStat("Path uses a Windows filesystem namespace alias")
+        : await safeStatAdmitted(targetPath);
     if (!st.ok) {
         return {
             ok: false,
@@ -85,28 +71,20 @@ export async function inspectPathPermissions(targetPath, opts) {
     }
     const bits = modeBits(effectiveMode);
     const platform = opts?.platform ?? process.platform;
-    if (platform === "win32") {
-        return await inspectWindowsPermissions({
-            targetPath,
-            stat: st,
-            effectiveIsDir,
-            effectiveMode,
-            bits,
-            opts,
-        });
-    }
-    return {
+    const windows = platform === "win32";
+    const permissions = {
         ok: true,
         isSymlink: st.isSymlink,
         isDir: effectiveIsDir,
         mode: effectiveMode,
         bits,
-        source: "posix",
-        worldWritable: isWorldWritable(bits),
-        groupWritable: isGroupWritable(bits),
-        worldReadable: isWorldReadable(bits),
-        groupReadable: isGroupReadable(bits),
+        source: windows ? "unknown" : "posix",
+        worldWritable: !windows && isWorldWritable(bits),
+        groupWritable: !windows && isGroupWritable(bits),
+        worldReadable: !windows && isWorldReadable(bits),
+        groupReadable: !windows && isGroupReadable(bits),
     };
+    return windows ? await inspectWindowsPermissions(targetPath, permissions, opts) : permissions;
 }
 export function formatPermissionDetail(targetPath, perms) {
     if (perms.source === "windows-acl") {

package/node_modules/@openclaw/fs-safe/dist/pinned-mutation-admission.d.ts

@@ -1,6 +1,6 @@
 import { type DenyMutationPolicy } from "./deny-mutations.js";
 import { type RootBoundaryIdentity } from "./root-boundary.js";
-import type { PinnedWriteMutationAdmission } from "./pinned-write.js";
+import type { PinnedWriteMutationAdmission } from "./pinned-write-types.js";
 import type { MutationSymlinkPolicy } from "./root-symlink-policy.js";
 export type PinnedMutationPolicySnapshot = Readonly<{
     denyMutations?: DenyMutationPolicy;
@@ -22,4 +22,3 @@ export declare function preparePinnedWriteMutationAdmission(params: {
     relativeParentPath: string;
     mutationAdmission?: PinnedWriteMutationAdmission;
 }>;
-//# sourceMappingURL=pinned-mutation-admission.d.ts.map