@openclaw/openshell-sandbox 2026.9.2 → 2026.9.3

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

@@ -0,0 +1,59 @@
+import { type PermissionCommandFailure } from "./permission-exec.js";
+import type { PermissionCheck, PermissionCheckOptions, SafeStatResult } from "./permissions.js";
+export type PermissionExec = (command: string, args: string[]) => Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+export type WindowsAclEntry = {
+    principal: string;
+    /** Canonical principal SID when resolved from Windows. */
+    sid?: string;
+    rights: string[];
+    rawRights: string;
+    canRead: boolean;
+    canWrite: boolean;
+};
+export type WindowsAclSummary = {
+    ok: boolean;
+    entries: WindowsAclEntry[];
+    untrustedWorld: WindowsAclEntry[];
+    untrustedGroup: WindowsAclEntry[];
+    trusted: WindowsAclEntry[];
+    error?: string;
+    errorDetail?: PermissionCommandFailure;
+    errorCause?: unknown;
+};
+export type WindowsUserInfoProvider = () => {
+    username?: string | null;
+};
+export type IcaclsResetCommandOptions = {
+    isDir: boolean;
+    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 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">;
+export declare function inspectWindowsAcl(targetPath: string, opts?: {
+    env?: NodeJS.ProcessEnv;
+    exec?: PermissionExec;
+    currentUserSid?: string;
+    principalSids?: Record<string, string>;
+    principalTranslationFailed?: boolean;
+}): Promise<WindowsAclSummary>;
+export declare function formatWindowsAclSummary(summary: WindowsAclSummary): string;
+export declare function formatIcaclsResetCommand(targetPath: string, opts: IcaclsResetCommandOptions): string;
+export declare function createIcaclsResetCommand(targetPath: string, opts: IcaclsResetCommandOptions): {
+    command: string;
+    args: string[];
+    display: string;
+} | null;
+//# sourceMappingURL=permissions-windows.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"permissions-windows.d.ts","sourceRoot":"","sources":["../src/permissions-windows.ts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,wBAAwB,EAC9B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,eAAe,EAAE,sBAAsB,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAShG,MAAM,MAAM,cAAc,GAAG,CAC3B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,KACX,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAEjD,MAAM,MAAM,eAAe,GAAG;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,0DAA0D;IAC1D,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,cAAc,EAAE,eAAe,EAAE,CAAC;IAClC,cAAc,EAAE,eAAe,EAAE,CAAC;IAClC,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,wBAAwB,CAAC;IACvC,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,MAAM;IAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC;AAEzE,MAAM,MAAM,yBAAyB,GAAG;IACtC,KAAK,EAAE,OAAO,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,QAAQ,CAAC,EAAE,uBAAuB,CAAC;CACpC,CAAC;AAyEF,wBAAsB,yBAAyB,CAAC,MAAM,EAAE;IACtD,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,cAAc,CAAC;IACrB,cAAc,EAAE,OAAO,CAAC;IACxB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,IAAI,CAAC,EAAE,sBAAsB,CAAC;CAC/B,GAAG,OAAO,CAAC,eAAe,CAAC,CAmD3B;AAOD,wBAAgB,2BAA2B,CACzC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,EACvB,QAAQ,GAAE,uBAAgD,GACzD,MAAM,GAAG,IAAI,CAKf;AAyDD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,eAAe,EAAE,CAgBvF;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,GAAG,IAAI,CAAC,iBAAiB,EAAE,SAAS,GAAG,gBAAgB,GAAG,gBAAgB,CAAC,CAYjK;AAED,wBAAsB,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IAAC,IAAI,CAAC,EAAE,cAAc,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,0BAA0B,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAuCxP;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,iBAAiB,GAAG,MAAM,CAI1E;AAED,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,yBAAyB,GAAG,MAAM,CAKpG;AAED,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,yBAAyB,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAMzJ"}

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

@@ -0,0 +1,296 @@
+import os from "node:os";
+import { getNativeBinding } from "./native.js";
+import { executePermissionCommand, formatPermissionErrorDetail, getPermissionCommandFailure, } from "./permission-exec.js";
+import { normalizeLowercaseStringOrEmpty } from "./string-coerce.js";
+import { resolveWindowsSystemCommand } from "./windows-command.js";
+import { inspectWindowsOwner, resolveWindowsCurrentUserSid, resolveWindowsPrincipalSids, } from "./windows-owner.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([
+    "nt authority\\system",
+    "system",
+    "builtin\\administrators",
+    "creator owner",
+    "autorite nt\\système",
+    "nt-autorität\\system",
+    "autoridad nt\\system",
+    "autoridade nt\\system",
+]);
+const WORLD_SUFFIXES = ["\\users", "\\authenticated users"];
+const SID_RE = /^\*?s-\d+-\d+(-\d+)+$/i;
+const TRUSTED_SIDS = new Set([
+    "s-1-5-18",
+    "s-1-5-32-544",
+    "s-1-5-80-956008885-3418522649-1831038044-1853292631-2271478464",
+]);
+const WORLD_SIDS = new Set(["s-1-1-0", "s-1-5-11", "s-1-5-32-545", "s-1-5-7", "s-1-5-32-546", "s-1-5-4", "s-1-2-0", "s-1-5-2"]);
+const STATUS_PREFIXES = [
+    "successfully processed",
+    "processed",
+    "failed processing",
+    "no mapping between account names",
+];
+function stripDiacritics(value) {
+    return value.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+}
+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) {
+    const native = getNativeBinding();
+    if (!native)
+        return undefined;
+    try {
+        const facts = native.readOwnerAndDacl(params.targetPath);
+        if (facts.fallbackRequired)
+            return undefined;
+        return {
+            ok: true,
+            isSymlink: params.stat.isSymlink,
+            isDir: params.effectiveIsDir,
+            mode: params.effectiveMode,
+            bits: params.bits,
+            source: "windows-acl",
+            worldWritable: facts.worldWritable,
+            groupWritable: facts.groupWritable,
+            worldReadable: facts.worldReadable,
+            groupReadable: facts.groupReadable,
+            ownerSid: facts.ownerSid,
+            ownerTrusted: facts.ownerClass !== "foreign",
+            aclSummary: `native owner=${facts.ownerClass} world=` +
+                `${facts.worldReadable ? "r" : "-"}${facts.worldWritable ? "w" : "-"} ` +
+                `group=${facts.groupReadable ? "r" : "-"}${facts.groupWritable ? "w" : "-"}`,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function inspectWindowsPermissions(params) {
+    const native = inspectWindowsPermissionsNative(params);
+    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,
+    });
+    if (owner.error) {
+        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 ownerFields = {
+        ...(owner.sid ? { ownerSid: owner.sid } : {}),
+        ...(owner.trusted !== undefined ? { ownerTrusted: owner.trusted } : {}),
+        ...(owner.error ? { ownerError: owner.error } : {}),
+    };
+    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,
+        source: "windows-acl",
+        worldWritable: acl.untrustedWorld.some((entry) => entry.canWrite),
+        groupWritable: acl.untrustedGroup.some((entry) => entry.canWrite),
+        worldReadable: acl.untrustedWorld.some((entry) => entry.canRead),
+        groupReadable: acl.untrustedGroup.some((entry) => entry.canRead),
+        ...ownerFields,
+        aclSummary: formatWindowsAclSummary(acl),
+    };
+}
+function normalizeSid(value) {
+    const normalized = normalize(value);
+    return normalized.startsWith("*") ? normalized.slice(1) : normalized;
+}
+export function resolveWindowsUserPrincipal(env, userInfo = defaultWindowsUserInfo) {
+    const username = env?.USERNAME?.trim() || userInfo().username?.trim();
+    if (!username)
+        return null;
+    const domain = env?.USERDOMAIN?.trim();
+    return domain ? `${domain}\\${username}` : username;
+}
+function buildTrustedPrincipals(env) {
+    const trusted = new Set(TRUSTED_BASE);
+    const principal = resolveWindowsUserPrincipal(env);
+    if (principal) {
+        trusted.add(normalize(principal));
+        const userOnly = principal.split("\\").at(-1);
+        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) {
+    const normalized = normalize(principal);
+    if (SID_RE.test(normalized)) {
+        const sid = normalizeSid(normalized);
+        if (WORLD_SIDS.has(sid))
+            return "world";
+        if (TRUSTED_SIDS.has(sid) || trustedPrincipals.has(sid))
+            return "trusted";
+        return "group";
+    }
+    if (trustedPrincipals.has(normalized) || TRUSTED_BASE.has(normalized))
+        return "trusted";
+    if (WORLD_PRINCIPALS.has(normalized) || WORLD_SUFFIXES.some((suffix) => normalized.endsWith(suffix)))
+        return "world";
+    const stripped = stripDiacritics(normalized);
+    return stripped !== normalized && TRUSTED_BASE_ASCII.has(stripped) ? "trusted" : "group";
+}
+function rightsFromTokens(tokens) {
+    const upper = tokens.join("").toUpperCase();
+    return {
+        canWrite: upper.includes("F") || upper.includes("M") || upper.includes("W") || upper.includes("D"),
+        canRead: upper.includes("F") || upper.includes("M") || upper.includes("R"),
+    };
+}
+function stripTargetPrefix(params) {
+    if (params.lowerLine.startsWith(params.lowerTarget))
+        return params.trimmedLine.slice(params.normalizedTarget.length).trim();
+    if (params.lowerLine.startsWith(params.quotedLower))
+        return params.trimmedLine.slice(params.quotedTarget.length).trim();
+    return params.trimmedLine;
+}
+function parseAceEntry(entry) {
+    if (!entry.includes("("))
+        return null;
+    const idx = entry.indexOf(":");
+    if (idx === -1)
+        return null;
+    const principal = entry.slice(0, idx).trim();
+    const rawRights = entry.slice(idx + 1).trim();
+    const tokens = rawRights.match(/\(([^)]+)\)/g)?.map((token) => token.slice(1, -1).trim()).filter(Boolean) ?? [];
+    if (tokens.some((token) => token.toUpperCase() === "DENY"))
+        return null;
+    const rights = tokens.filter((token) => !INHERIT_FLAGS.has(token.toUpperCase()));
+    if (rights.length === 0)
+        return null;
+    const normalizedPrincipal = normalizeSid(principal);
+    return { principal, ...(SID_RE.test(normalizedPrincipal) ? { sid: normalizedPrincipal } : {}), rights, rawRights, ...rightsFromTokens(rights) };
+}
+export function parseIcaclsOutput(output, targetPath) {
+    const entries = [];
+    const normalizedTarget = targetPath.trim();
+    const lowerTarget = normalizedTarget.toLowerCase();
+    const quotedTarget = `"${normalizedTarget}"`;
+    const quotedLower = quotedTarget.toLowerCase();
+    for (const rawLine of output.split(/\r?\n/)) {
+        const line = rawLine.trimEnd();
+        if (!line.trim())
+            continue;
+        const trimmed = line.trim();
+        const lowerLine = trimmed.toLowerCase();
+        if (STATUS_PREFIXES.some((prefix) => lowerLine.startsWith(prefix)))
+            continue;
+        const parsed = parseAceEntry(stripTargetPrefix({ trimmedLine: trimmed, lowerLine, normalizedTarget, lowerTarget, quotedTarget, quotedLower }));
+        if (parsed)
+            entries.push(parsed);
+    }
+    return entries;
+}
+export function summarizeWindowsAcl(entries, env) {
+    const trustedPrincipals = buildTrustedPrincipals(env);
+    const trusted = [];
+    const untrustedWorld = [];
+    const untrustedGroup = [];
+    for (const entry of entries) {
+        const classification = classifyPrincipal(entry.sid ?? entry.principal, trustedPrincipals);
+        if (classification === "trusted")
+            trusted.push(entry);
+        else if (classification === "world")
+            untrustedWorld.push(entry);
+        else
+            untrustedGroup.push(entry);
+    }
+    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) {
+        return {
+            ok: false, entries: [], trusted: [], untrustedWorld: [], untrustedGroup: [],
+            error: formatPermissionErrorDetail(String(err)),
+            errorDetail: getPermissionCommandFailure(err, command, performance.now() - startedAt),
+            errorCause: err,
+        };
+    }
+}
+export function formatWindowsAclSummary(summary) {
+    if (!summary.ok)
+        return "unknown";
+    const untrusted = [...summary.untrustedWorld, ...summary.untrustedGroup];
+    return untrusted.length === 0 ? "trusted-only" : untrusted.map((entry) => `${entry.principal}:${entry.rawRights}`).join(", ");
+}
+export function formatIcaclsResetCommand(targetPath, opts) {
+    const command = resolveWindowsSystemCommand("icacls.exe", opts.env);
+    const user = resolveWindowsUserPrincipal(opts.env, opts.userInfo) ?? "%USERNAME%";
+    const grant = opts.isDir ? "(OI)(CI)F" : "F";
+    return [command, `"${targetPath}"`, "/inheritance:r", "/grant:r", `"${user}:${grant}"`, "/grant:r", `"*S-1-5-18:${grant}"`].join(" ");
+}
+export function createIcaclsResetCommand(targetPath, opts) {
+    const user = resolveWindowsUserPrincipal(opts.env, opts.userInfo);
+    if (!user)
+        return null;
+    const grant = opts.isDir ? "(OI)(CI)F" : "F";
+    const args = [targetPath, "/inheritance:r", "/grant:r", `${user}:${grant}`, "/grant:r", `*S-1-5-18:${grant}`];
+    return { command: resolveWindowsSystemCommand("icacls.exe", opts.env), args, display: formatIcaclsResetCommand(targetPath, opts) };
+}

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

@@ -0,0 +1,60 @@
+import type { PermissionCommandFailure } from "./permission-exec.js";
+import { type PermissionExec } from "./permissions-windows.js";
+export type { PermissionCommandFailure } from "./permission-exec.js";
+export { createIcaclsResetCommand, formatIcaclsResetCommand, formatWindowsAclSummary, inspectWindowsAcl, parseIcaclsOutput, resolveWindowsUserPrincipal, summarizeWindowsAcl, } from "./permissions-windows.js";
+export type { IcaclsResetCommandOptions, PermissionExec, WindowsAclEntry, WindowsAclSummary, WindowsUserInfoProvider, } from "./permissions-windows.js";
+export type PermissionCheck = {
+    ok: boolean;
+    isSymlink: boolean;
+    isDir: boolean;
+    mode: number | null;
+    bits: number | null;
+    source: "posix" | "windows-acl" | "unknown";
+    worldWritable: boolean;
+    groupWritable: boolean;
+    worldReadable: boolean;
+    groupReadable: boolean;
+    /** Canonical Windows owner SID when the owner query succeeds. */
+    ownerSid?: string;
+    /** Whether the Windows owner is the current user, LocalSystem, or Administrators. */
+    ownerTrusted?: boolean;
+    /** Owner-query failure detail when Windows ownership could not be verified. */
+    ownerError?: string;
+    aclSummary?: string;
+    error?: string;
+    errorDetail?: PermissionCommandFailure;
+    /** Original inspection failure, retained separately from serializable diagnostics. */
+    errorCause?: unknown;
+};
+export type PermissionCheckOptions = {
+    platform?: NodeJS.Platform;
+    env?: NodeJS.ProcessEnv;
+    exec?: PermissionExec;
+};
+export type SafeStatResult = {
+    ok: boolean;
+    isSymlink: boolean;
+    isDir: boolean;
+    mode: number | null;
+    uid: number | null;
+    gid: number | null;
+    error?: string;
+};
+export declare function safeStat(targetPath: string): Promise<SafeStatResult>;
+export declare function inspectPathPermissions(targetPath: string, opts?: PermissionCheckOptions): Promise<PermissionCheck>;
+export declare function formatPermissionDetail(targetPath: string, perms: PermissionCheck): string;
+export declare function formatPermissionRemediation(params: {
+    targetPath: string;
+    perms: PermissionCheck;
+    isDir: boolean;
+    posixMode: number;
+    env?: NodeJS.ProcessEnv;
+}): string;
+export declare function modeBits(mode: number | null): number | null;
+export declare function formatOctal(bits: number | null): string;
+export declare function isWorldWritable(bits: number | null): boolean;
+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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.d.ts","sourceRoot":"","sources":["../src/permissions.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,125 @@
+import fs from "node:fs/promises";
+import { formatIcaclsResetCommand, inspectWindowsPermissions, } from "./permissions-windows.js";
+export { createIcaclsResetCommand, formatIcaclsResetCommand, formatWindowsAclSummary, inspectWindowsAcl, parseIcaclsOutput, resolveWindowsUserPrincipal, summarizeWindowsAcl, } from "./permissions-windows.js";
+export async function safeStat(targetPath) {
+    try {
+        const lst = await fs.lstat(targetPath);
+        return {
+            ok: true,
+            isSymlink: lst.isSymbolicLink(),
+            isDir: lst.isDirectory(),
+            mode: typeof lst.mode === "number" ? lst.mode : null,
+            uid: typeof lst.uid === "number" ? lst.uid : null,
+            gid: typeof lst.gid === "number" ? lst.gid : null,
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            isSymlink: false,
+            isDir: false,
+            mode: null,
+            uid: null,
+            gid: null,
+            error: String(err),
+        };
+    }
+}
+export async function inspectPathPermissions(targetPath, opts) {
+    const st = await safeStat(targetPath);
+    if (!st.ok) {
+        return {
+            ok: false,
+            isSymlink: false,
+            isDir: false,
+            mode: null,
+            bits: null,
+            source: "unknown",
+            worldWritable: false,
+            groupWritable: false,
+            worldReadable: false,
+            groupReadable: false,
+            error: st.error,
+        };
+    }
+    let effectiveMode = st.mode;
+    let effectiveIsDir = st.isDir;
+    if (st.isSymlink) {
+        try {
+            const target = await fs.stat(targetPath);
+            effectiveMode = typeof target.mode === "number" ? target.mode : st.mode;
+            effectiveIsDir = target.isDirectory();
+        }
+        catch {
+            // Keep lstat metadata when the symlink target cannot be inspected.
+        }
+    }
+    const bits = modeBits(effectiveMode);
+    const platform = opts?.platform ?? process.platform;
+    if (platform === "win32") {
+        return await inspectWindowsPermissions({
+            targetPath,
+            stat: st,
+            effectiveIsDir,
+            effectiveMode,
+            bits,
+            opts,
+        });
+    }
+    return {
+        ok: true,
+        isSymlink: st.isSymlink,
+        isDir: effectiveIsDir,
+        mode: effectiveMode,
+        bits,
+        source: "posix",
+        worldWritable: isWorldWritable(bits),
+        groupWritable: isGroupWritable(bits),
+        worldReadable: isWorldReadable(bits),
+        groupReadable: isGroupReadable(bits),
+    };
+}
+export function formatPermissionDetail(targetPath, perms) {
+    if (perms.source === "windows-acl") {
+        return `${targetPath} acl=${perms.aclSummary ?? "unknown"}`;
+    }
+    return `${targetPath} mode=${formatOctal(perms.bits)}`;
+}
+export function formatPermissionRemediation(params) {
+    if (params.perms.source === "windows-acl") {
+        return formatIcaclsResetCommand(params.targetPath, {
+            isDir: params.isDir,
+            env: params.env,
+        });
+    }
+    const optionSeparator = params.targetPath.startsWith("-") ? "-- " : "";
+    return (`chmod ${params.posixMode.toString(8).padStart(3, "0")} ${optionSeparator}` +
+        formatPosixShellArgument(params.targetPath));
+}
+function formatPosixShellArgument(value) {
+    if (value && /^[A-Za-z0-9_@%+=:,./-]+$/.test(value)) {
+        return value;
+    }
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+export function modeBits(mode) {
+    return mode == null ? null : mode & 0o777;
+}
+export function formatOctal(bits) {
+    return bits == null ? "unknown" : bits.toString(8).padStart(3, "0");
+}
+export function isWorldWritable(bits) {
+    return bits != null && (bits & 0o002) !== 0;
+}
+export function isGroupWritable(bits) {
+    return bits != null && (bits & 0o020) !== 0;
+}
+export function isWorldReadable(bits) {
+    return bits != null && (bits & 0o004) !== 0;
+}
+export function isGroupReadable(bits) {
+    return bits != null && (bits & 0o040) !== 0;
+}
+export function formatPosixMode(mode) {
+    return (mode & 0o777).toString(8).padStart(3, "0");
+}

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

@@ -0,0 +1,24 @@
+import fs from "node:fs";
+export type PinnedOpenSyncFailureReason = "path" | "validation" | "io";
+export type PinnedOpenSyncResult = {
+    ok: true;
+    path: string;
+    fd: number;
+    stat: fs.Stats;
+} | {
+    ok: false;
+    reason: PinnedOpenSyncFailureReason;
+    error?: unknown;
+};
+export type PinnedOpenSyncAllowedType = "file" | "directory";
+export type PinnedOpenSyncFs = Pick<typeof fs, "constants" | "lstatSync" | "realpathSync" | "openSync" | "fstatSync" | "closeSync">;
+export declare function openPinnedFileSync(params: {
+    filePath: string;
+    resolvedPath?: string;
+    rejectPathSymlink?: boolean;
+    rejectHardlinks?: boolean;
+    maxBytes?: number;
+    allowedType?: PinnedOpenSyncAllowedType;
+    ioFs?: PinnedOpenSyncFs;
+}): PinnedOpenSyncResult;
+//# sourceMappingURL=pinned-open.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/pinned-open.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pinned-open.d.ts","sourceRoot":"","sources":["../src/pinned-open.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,SAAS,CAAC;AAMzB,MAAM,MAAM,2BAA2B,GAAG,MAAM,GAAG,YAAY,GAAG,IAAI,CAAC;AAEvE,MAAM,MAAM,oBAAoB,GAC5B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAA;CAAE,GACtD;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,2BAA2B,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAExE,MAAM,MAAM,yBAAyB,GAAG,MAAM,GAAG,WAAW,CAAC;AAE7D,MAAM,MAAM,gBAAgB,GAAG,IAAI,CACjC,OAAO,EAAE,EACT,WAAW,GAAG,WAAW,GAAG,cAAc,GAAG,UAAU,GAAG,WAAW,GAAG,WAAW,CACpF,CAAC;AAQF,wBAAgB,kBAAkB,CAAC,MAAM,EAAE;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,yBAAyB,CAAC;IACxC,IAAI,CAAC,EAAE,gBAAgB,CAAC;CACzB,GAAG,oBAAoB,CAoDvB"}

package/node_modules/@openclaw/fs-safe/dist/pinned-open.js

@@ -0,0 +1,74 @@
+import fs from "node:fs";
+import { isUnsafeDeviceReadPath } from "./device-path.js";
+import { FsSafeError } from "./errors.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
+import { resolveReadOpenFlags } from "./read-open-flags.js";
+function isExpectedPathError(error) {
+    const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
+    return code === "ENOENT" || code === "ENOTDIR" || code === "ELOOP";
+}
+export function openPinnedFileSync(params) {
+    const ioFs = params.ioFs ?? fs;
+    const allowedType = params.allowedType ?? "file";
+    const openReadFlags = resolveReadOpenFlags({ constants: ioFs.constants });
+    let fd = null;
+    try {
+        if (isUnsafeDeviceReadPath(params.filePath)) {
+            return { ok: false, reason: "validation" };
+        }
+        if (params.rejectPathSymlink) {
+            const candidateStat = ioFs.lstatSync(params.filePath);
+            if (candidateStat.isSymbolicLink()) {
+                return { ok: false, reason: "validation" };
+            }
+        }
+        const realPath = params.resolvedPath ?? ioFs.realpathSync(params.filePath);
+        if (isUnsafeDeviceReadPath(realPath)) {
+            return { ok: false, reason: "validation" };
+        }
+        const preOpenStat = inspectFileIdentitySync(() => {
+            const stat = ioFs.lstatSync(realPath, { bigint: true });
+            assertAllowedStat(stat, allowedType, params);
+            return stat;
+        });
+        fd = ioFs.openSync(realPath, openReadFlags);
+        const openedStat = ioFs.fstatSync(fd);
+        const identity = inspectFileIdentitySync(() => {
+            const stat = ioFs.fstatSync(fd, { bigint: true });
+            assertAllowedStat(stat, allowedType, params);
+            return stat;
+        }, preOpenStat);
+        inspectFileIdentitySync(() => {
+            const stat = ioFs.lstatSync(realPath, { bigint: true });
+            assertAllowedStat(stat, allowedType, params);
+            return stat;
+        }, identity);
+        const opened = { ok: true, path: realPath, fd, stat: openedStat };
+        fd = null;
+        return opened;
+    }
+    catch (error) {
+        if (error instanceof FsSafeError)
+            return { ok: false, reason: "validation", error };
+        if (isExpectedPathError(error)) {
+            return { ok: false, reason: "path", error };
+        }
+        return { ok: false, reason: "io", error };
+    }
+    finally {
+        if (fd !== null) {
+            ioFs.closeSync(fd);
+        }
+    }
+}
+function assertAllowedStat(stat, allowedType, params) {
+    if (stat.isSymbolicLink() || !(allowedType === "directory" ? stat.isDirectory() : stat.isFile())) {
+        throw new FsSafeError("not-file", "path does not have the required file type");
+    }
+    if (params.rejectHardlinks && stat.isFile() && stat.nlink > 1n) {
+        throw new FsSafeError("hardlink", "path must not be hardlinked");
+    }
+    if (params.maxBytes !== undefined && stat.isFile() && stat.size > params.maxBytes) {
+        throw new FsSafeError("too-large", "file exceeds byte limit");
+    }
+}

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

@@ -0,0 +1,2 @@
+export declare function validatePinnedOperationPayload(payload: Record<string, unknown>): void;
+//# sourceMappingURL=pinned-operation.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/pinned-operation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pinned-operation.d.ts","sourceRoot":"","sources":["../src/pinned-operation.ts"],"names":[],"mappings":"AAEA,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAarF"}