@openclaw/openshell-sandbox 2026.9.4 → 2026.9.6

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, PermissionCheckOptions, 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

@@ -1,9 +1,11 @@
 import os from "node:os";
 import { getNativeBinding } from "./native.js";
-import { executePermissionCommand, formatPermissionErrorDetail, getPermissionCommandFailure, } from "./permission-exec.js";
+import { executePermissionCommand } from "./permission-exec.js";
+import { safeStat } from "./permissions.js";
 import { normalizeLowercaseStringOrEmpty } from "./string-coerce.js";
 import { resolveWindowsSystemCommand } from "./windows-command.js";
-import { inspectWindowsOwner, resolveWindowsCurrentUserSid, resolveWindowsPrincipalSids, } from "./windows-owner.js";
+import { inspectWindowsOwner } from "./windows-owner.js";
+import { hasWindowsPathAlias } from "./windows-path-alias.js";
 const INHERIT_FLAGS = new Set(["I", "OI", "CI", "IO", "NP"]);
 const WORLD_PRINCIPALS = new Set(["everyone", "users", "builtin\\users", "authenticated users", "nt authority\\authenticated users", "anonymous logon", "nt authority\\anonymous logon", "guests", "builtin\\guests", "interactive", "nt authority\\interactive", "network", "nt authority\\network", "local"]);
 const TRUSTED_BASE = new Set([
@@ -37,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,
@@ -67,38 +65,26 @@ function inspectWindowsPermissionsNative(params) {
         return undefined;
     }
 }
-export async function inspectWindowsPermissions(params) {
-    const native = inspectWindowsPermissionsNative(params);
+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(targetPath, unverified);
     if (native)
         return native;
-    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,
-    };
     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 };
     }
-    const acl = await inspectWindowsAcl(params.targetPath, {
-        env: params.opts?.env,
-        exec: params.opts?.exec,
-        currentUserSid: owner.currentUserSid,
-        principalSids: owner.principalSids,
-        principalTranslationFailed: owner.principalTranslationFailed,
-    });
+    const acl = summarizeWindowsOwnerAcl(owner);
     const ownerFields = {
         ...(owner.sid ? { ownerSid: owner.sid } : {}),
         ...(owner.trusted !== undefined ? { ownerTrusted: owner.trusted } : {}),
@@ -107,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),
@@ -132,8 +114,18 @@ export function resolveWindowsUserPrincipal(env, userInfo = defaultWindowsUserIn
     const domain = env?.USERDOMAIN?.trim();
     return domain ? `${domain}\\${username}` : username;
 }
+function buildTrustedSidPrincipals(env) {
+    const trusted = new Set();
+    const userSid = normalizeSid(env?.USERSID ?? "");
+    if (userSid && SID_RE.test(userSid) && !WORLD_SIDS.has(userSid))
+        trusted.add(userSid);
+    return trusted;
+}
 function buildTrustedPrincipals(env) {
-    const trusted = new Set(TRUSTED_BASE);
+    const trusted = new Set([
+        ...TRUSTED_BASE,
+        ...buildTrustedSidPrincipals(env),
+    ]);
     const principal = resolveWindowsUserPrincipal(env);
     if (principal) {
         trusted.add(normalize(principal));
@@ -141,9 +133,6 @@ function buildTrustedPrincipals(env) {
         if (userOnly)
             trusted.add(normalize(userOnly));
     }
-    const userSid = normalizeSid(env?.USERSID ?? "");
-    if (userSid && SID_RE.test(userSid) && !WORLD_SIDS.has(userSid))
-        trusted.add(userSid);
     return trusted;
 }
 function classifyPrincipal(principal, trustedPrincipals) {
@@ -215,7 +204,11 @@ export function parseIcaclsOutput(output, targetPath) {
     return entries;
 }
 export function summarizeWindowsAcl(entries, env) {
-    const trustedPrincipals = buildTrustedPrincipals(env);
+    // Canonical SID entries cannot match account names. Classify them directly
+    // so structured descriptor facts do not depend on a separate user lookup.
+    const trustedPrincipals = entries.every((entry) => SID_RE.test(normalize(entry.sid ?? entry.principal)))
+        ? buildTrustedSidPrincipals(env)
+        : buildTrustedPrincipals(env);
     const trusted = [];
     const untrustedWorld = [];
     const untrustedGroup = [];
@@ -230,49 +223,79 @@ export function summarizeWindowsAcl(entries, env) {
     }
     return { trusted, untrustedWorld, untrustedGroup };
 }
-export async function inspectWindowsAcl(targetPath, opts) {
-    let command = "";
-    let startedAt = performance.now();
-    const exec = async (file, args) => {
-        command = file;
-        startedAt = performance.now();
-        return await (opts?.exec ?? defaultPermissionExec)(file, args);
-    };
-    try {
-        if (opts?.principalTranslationFailed)
-            throw new Error("Windows ACL principal SID translation failed");
-        const { stdout, stderr } = await exec(resolveWindowsSystemCommand("icacls.exe", opts?.env), [targetPath]);
-        let entries = parseIcaclsOutput(`${stdout}\n${stderr}`.trim(), targetPath);
-        if (!entries.length)
-            throw new Error("Windows ACL output could not be verified");
-        const unresolvedPrincipals = entries.filter((entry) => !entry.sid).map((entry) => entry.principal);
-        const principalSids = await resolveWindowsPrincipalSids({ principals: unresolvedPrincipals, known: opts?.principalSids, env: opts?.env, exec });
-        entries = entries.map((entry) => {
-            const sid = entry.sid ?? principalSids[entry.principal.toLowerCase()];
-            if (!sid)
-                throw new Error(`Windows ACL principal SID could not be verified: ${entry.principal}`);
-            return { ...entry, sid };
-        });
-        let currentUserSid = normalizeSid(opts?.currentUserSid ?? "");
-        let effectiveEnv = currentUserSid ? { USERSID: currentUserSid } : undefined;
-        let { trusted, untrustedWorld, untrustedGroup } = summarizeWindowsAcl(entries, effectiveEnv);
-        if (!currentUserSid && untrustedGroup.some((entry) => entry.sid && !TRUSTED_SIDS.has(entry.sid))) {
-            currentUserSid = (await resolveWindowsCurrentUserSid({ exec, env: opts?.env })) ?? "";
-            if (currentUserSid) {
-                effectiveEnv = { USERSID: currentUserSid };
-                ({ trusted, untrustedWorld, untrustedGroup } = summarizeWindowsAcl(entries, effectiveEnv));
-            }
-        }
-        return { ok: true, entries, trusted, untrustedWorld, untrustedGroup };
-    }
-    catch (err) {
+const MASK_RIGHTS = [
+    [0x1000_0000, "GA"], [0x8000_0000, "GR"], [0x4000_0000, "GW"], [0x2000_0000, "GE"],
+    [0x0001_0000, "D"], [0x0002_0000, "RC"], [0x0004_0000, "WDAC"], [0x0008_0000, "WO"],
+    [0x0010_0000, "S"], [0x0001, "RD"], [0x0002, "WD"], [0x0004, "AD"],
+    [0x0008, "REA"], [0x0010, "WEA"], [0x0020, "X"], [0x0040, "DC"], [0x0080, "RA"], [0x0100, "WA"],
+];
+function summarizeWindowsOwnerAcl(owner) {
+    const error = owner.error ?? owner.aclError;
+    if (error || owner.daclPresent === undefined || !owner.aces || !owner.currentUserSid) {
         return {
             ok: false, entries: [], trusted: [], untrustedWorld: [], untrustedGroup: [],
-            error: formatPermissionErrorDetail(String(err)),
-            errorDetail: getPermissionCommandFailure(err, command, performance.now() - startedAt),
-            errorCause: err,
+            error: error ?? "Windows ACL query returned incomplete descriptor data",
+            errorDetail: owner.errorDetail, errorCause: owner.errorCause,
         };
     }
+    // A null DACL grants everyone full access; an empty DACL grants nothing.
+    const grants = owner.daclPresent ? owner.aces : [{ sid: "s-1-1-0", mask: 0x001f_01ff, deny: false, inheritOnly: false }];
+    const entries = grants.filter(ace => !ace.deny && !ace.inheritOnly).map(ace => {
+        const rights = ace.mask === 0x001f_01ff ? ["F"] : MASK_RIGHTS.filter(([mask]) => (ace.mask & mask) !== 0).map(([, name]) => name);
+        return {
+            principal: ace.sid, sid: ace.sid, rights, rawRights: "(" + rights.join(",") + ")",
+            // Retain the coarse policy's conservative treatment of read-control and
+            // mutation rights. Denies do not subtract grants or claim effective access.
+            canRead: (ace.mask & 0x9002_0089) !== 0,
+            canWrite: (ace.mask & 0x500d_0156) !== 0,
+        };
+    });
+    return { ok: true, entries, ...summarizeWindowsAcl(entries, { USERSID: owner.currentUserSid }) };
+}
+export async function inspectWindowsAcl(targetPath, opts) {
+    if (opts?.principalTranslationFailed) {
+        const error = new Error("Windows ACL principal SID translation failed");
+        return summarizeWindowsOwnerAcl({ error: String(error), errorCause: error });
+    }
+    if (hasWindowsPathAlias(targetPath, "filesystem", "win32")) {
+        const error = new Error("Path uses a Windows filesystem namespace alias");
+        return summarizeWindowsOwnerAcl({ error: String(error), errorCause: error });
+    }
+    let owner;
+    if (process.platform === "win32" && opts?.env === undefined && opts?.exec === undefined) {
+        try {
+            const native = getNativeBinding();
+            const stat = native && await safeStat(targetPath);
+            // Keep the named-query behavior for leaf links; the native reader follows them.
+            const facts = stat?.ok && !stat.isSymlink ? native?.readOwnerAndDacl(targetPath) : undefined;
+            if (facts && !facts.fallbackRequired && facts.isLocal && facts.aceListComplete && facts.unsupportedAceTypes.length === 0 &&
+                facts.aces.every(ace => ace.flags.inherited && ace.mask !== 0)) {
+                // .NET normalizes explicit ACEs, but retains nonzero inherited ACEs in
+                // their original order without merging them. Other forms keep its query.
+                // Adapt descriptor facts only: the public summary owns its SID and rights
+                // classification, which differs from the native secure-read policy.
+                owner = {
+                    daclPresent: facts.daclPresent,
+                    currentUserSid: facts.currentUserSid,
+                    aces: facts.aces.map(ace => ({
+                        sid: ace.sid,
+                        mask: ace.mask,
+                        deny: ace.aceType === "deny",
+                        inheritOnly: ace.flags.inheritOnly,
+                    })),
+                };
+            }
+        }
+        catch {
+            // Preserve this inspector's structured fallback and command diagnostics
+            // when the optional helper or native descriptor query is unavailable.
+        }
+    }
+    owner ??= await inspectWindowsOwner({ targetPath, env: opts?.env, exec: opts?.exec ?? defaultPermissionExec });
+    return summarizeWindowsOwnerAcl({
+        ...owner,
+        currentUserSid: normalizeSid(opts?.currentUserSid ?? "") || owner.currentUserSid,
+    });
 }
 export function formatWindowsAclSummary(summary) {
     if (!summary.ok)

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

@@ -1,9 +1,21 @@
-import fs from "node:fs/promises";
+import fsSync from "node:fs";
 import { formatIcaclsResetCommand, inspectWindowsPermissions, } from "./permissions-windows.js";
+import { hasWindowsPathAlias, pathForWindowsFilesystem, } from "./windows-path-alias.js";
 export { createIcaclsResetCommand, formatIcaclsResetCommand, formatWindowsAclSummary, inspectWindowsAcl, parseIcaclsOutput, resolveWindowsUserPrincipal, summarizeWindowsAcl, } from "./permissions-windows.js";
-export async function safeStat(targetPath) {
+function failedSafeStat(error) {
+    return {
+        ok: false,
+        isSymlink: false,
+        isDir: false,
+        mode: null,
+        uid: null,
+        gid: null,
+        error,
+    };
+}
+async function safeStatAdmitted(targetPath) {
     try {
-        const lst = await fs.lstat(targetPath);
+        const lst = fsSync.lstatSync(pathForWindowsFilesystem(targetPath));
         return {
             ok: true,
             isSymlink: lst.isSymbolicLink(),
@@ -14,19 +26,22 @@ export async function safeStat(targetPath) {
         };
     }
     catch (err) {
-        return {
-            ok: false,
-            isSymlink: false,
-            isDir: false,
-            mode: null,
-            uid: null,
-            gid: null,
-            error: String(err),
-        };
+        return failedSafeStat(String(err));
+    }
+}
+export async function safeStat(targetPath) {
+    if (hasWindowsPathAlias(targetPath, "filesystem")) {
+        return failedSafeStat("Path uses a Windows filesystem namespace alias");
     }
+    return await safeStatAdmitted(targetPath);
 }
 export async function inspectPathPermissions(targetPath, opts) {
-    const st = await safeStat(targetPath);
+    const admissionPlatform = process.platform === "win32"
+        ? process.platform
+        : (opts?.platform ?? process.platform);
+    const st = hasWindowsPathAlias(targetPath, "filesystem", admissionPlatform)
+        ? failedSafeStat("Path uses a Windows filesystem namespace alias")
+        : await safeStatAdmitted(targetPath);
     if (!st.ok) {
         return {
             ok: false,
@@ -46,7 +61,7 @@ export async function inspectPathPermissions(targetPath, opts) {
     let effectiveIsDir = st.isDir;
     if (st.isSymlink) {
         try {
-            const target = await fs.stat(targetPath);
+            const target = fsSync.statSync(targetPath);
             effectiveMode = typeof target.mode === "number" ? target.mode : st.mode;
             effectiveIsDir = target.isDirectory();
         }
@@ -56,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

@@ -0,0 +1,24 @@
+import { type DenyMutationPolicy } from "./deny-mutations.js";
+import { type RootBoundaryIdentity } from "./root-boundary.js";
+import type { PinnedWriteMutationAdmission } from "./pinned-write-types.js";
+import type { MutationSymlinkPolicy } from "./root-symlink-policy.js";
+export type PinnedMutationPolicySnapshot = Readonly<{
+    denyMutations?: DenyMutationPolicy;
+    mutationSymlinks?: MutationSymlinkPolicy;
+}>;
+export declare function snapshotPinnedMutationPolicy(denyMutations: DenyMutationPolicy | undefined, mutationSymlinks: MutationSymlinkPolicy | undefined): PinnedMutationPolicySnapshot | undefined;
+export declare function preparePinnedWriteMutationAdmission(params: {
+    rootReal: string;
+    rootWithSep: string;
+    rootIdentity?: RootBoundaryIdentity;
+    resolvedTargetPath: string;
+    defaultRelativeParentPath: string;
+    originalPath?: string;
+    policy: PinnedMutationPolicySnapshot | undefined;
+    resolveCurrent(): Promise<{
+        resolved: string;
+    }>;
+}): Promise<{
+    relativeParentPath: string;
+    mutationAdmission?: PinnedWriteMutationAdmission;
+}>;