@openclaw/openshell-sandbox 2026.9.2 → 2026.9.4

package/node_modules/@openclaw/fs-safe/dist/opened-realpath.js

@@ -0,0 +1,92 @@
+import fsSync from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { openedPathResolutionError } from "./opened-file-failure.js";
+import { sameFileIdentity } from "./file-identity.js";
+import { isNotFoundPathError } from "./path.js";
+export async function resolveOpenedFileRealPathForHandle(handle, ioPath) {
+    const handleStat = fsSync.fstatSync(handle.fd);
+    return (await resolveOpenedFileRealPathForFd(handle.fd, handleStat, ioPath)).realPath;
+}
+export async function resolveOpenedFileRealPathForFd(fd, handleStat, ioPath) {
+    const statOptions = typeof handleStat.dev === "bigint" || typeof handleStat.ino === "bigint"
+        ? { bigint: true } : undefined;
+    const fdCandidates = process.platform === "linux"
+        ? [`/proc/self/fd/${fd}`, `/dev/fd/${fd}`]
+        : [];
+    for (const fdPath of fdCandidates) {
+        try {
+            const fdRealPath = fsSync.realpathSync.native(fdPath);
+            const fdRealStat = statOptions ? fsSync.statSync(fdRealPath, statOptions) : fsSync.statSync(fdRealPath);
+            if (sameFileIdentity(handleStat, fdRealStat)) {
+                return { realPath: fdRealPath, stat: fdRealStat };
+            }
+        }
+        catch {
+            // try next fd path
+        }
+    }
+    try {
+        const ioRealPath = fsSync.realpathSync.native(ioPath);
+        const ioRealStat = statOptions ? fsSync.statSync(ioRealPath, statOptions) : fsSync.statSync(ioRealPath);
+        if (sameFileIdentity(handleStat, ioRealStat)) {
+            return { realPath: ioRealPath, stat: ioRealStat };
+        }
+    }
+    catch (err) {
+        if (!isNotFoundPathError(err)) {
+            // Windows can fail here on a deleted-but-open file. Brand only this
+            // resolver operation; the caller must still prove unlink on the same fd.
+            if (process.platform === "win32" && err instanceof Error &&
+                ["EPERM", "EBADF"].includes(err.code ?? "")) {
+                throw openedPathResolutionError(err);
+            }
+            throw err;
+        }
+    }
+    const parentResolved = await resolveOpenedFileRealPathFromParent(handleStat, ioPath, statOptions);
+    if (parentResolved) {
+        return parentResolved;
+    }
+    throw openedPathResolutionError();
+}
+async function resolveOpenedFileRealPathFromParent(handleStat, ioPath, statOptions) {
+    let parentReal;
+    try {
+        parentReal = fsSync.realpathSync.native(path.dirname(ioPath));
+    }
+    catch (err) {
+        if (isNotFoundPathError(err)) {
+            return null;
+        }
+        throw err;
+    }
+    let entries;
+    try {
+        entries = await fs.readdir(parentReal);
+    }
+    catch (err) {
+        if (isNotFoundPathError(err)) {
+            return null;
+        }
+        throw err;
+    }
+    for (const entry of entries.toSorted()) {
+        const candidatePath = path.join(parentReal, entry);
+        try {
+            const candidateStat = statOptions ? fsSync.lstatSync(candidatePath, statOptions) : fsSync.lstatSync(candidatePath);
+            if (candidateStat.isFile() && sameFileIdentity(handleStat, candidateStat)) {
+                const realPath = fsSync.realpathSync.native(candidatePath);
+                const stat = statOptions ? fsSync.statSync(realPath, statOptions) : fsSync.statSync(realPath);
+                if (sameFileIdentity(handleStat, stat))
+                    return { realPath, stat };
+            }
+        }
+        catch (err) {
+            if (!isNotFoundPathError(err)) {
+                throw err;
+            }
+        }
+    }
+    return null;
+}

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

@@ -0,0 +1,15 @@
+export type ExternalFileWriteOptions<T = void> = {
+    rootDir: string;
+    path: string;
+    write: (filePath: string) => Promise<T>;
+    maxBytes?: number;
+    mode?: number;
+    staging?: "workspace" | "sibling";
+    fallbackFileName?: string;
+};
+export type ExternalFileWriteResult<T = void> = {
+    path: string;
+    result: T;
+};
+export declare function writeExternalFileWithinRoot<T = void>(options: ExternalFileWriteOptions<T>): Promise<ExternalFileWriteResult<T>>;
+//# sourceMappingURL=output.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../src/output.ts"],"names":[],"mappings":"AAUA,MAAM,MAAM,wBAAwB,CAAC,CAAC,GAAG,IAAI,IAAI;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAClC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,uBAAuB,CAAC,CAAC,GAAG,IAAI,IAAI;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,CAAC,CAAC;CACX,CAAC;AAyDF,wBAAsB,2BAA2B,CAAC,CAAC,GAAG,IAAI,EACxD,OAAO,EAAE,wBAAwB,CAAC,CAAC,CAAC,GACnC,OAAO,CAAC,uBAAuB,CAAC,CAAC,CAAC,CAAC,CAgDrC"}

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

@@ -0,0 +1,123 @@
+import { randomUUID } from "node:crypto";
+import { writeCallbackSibling } from "./sibling-staged-file.js";
+import path from "node:path";
+import { normalizeMaxBytes } from "./byte-budget.js";
+import { FsSafeError } from "./errors.js";
+import { fitFileNameToPortableComponent, sanitizeUntrustedFileName } from "./filename.js";
+import { isPathInside } from "./path.js";
+import { root } from "./root.js";
+import { tempFile } from "./temp-target.js";
+const NON_PORTABLE_FILE_NAME_CHARACTERS = /[\u0000-\u001f\u007f-\u009f<>:"/\\|?*]/u;
+function tempFileNameForTarget(targetPath, fallbackFileName) {
+    const fallback = sanitizeUntrustedFileName(fallbackFileName ?? "output.bin", "output.bin");
+    return sanitizeUntrustedFileName(path.basename(targetPath), fallback);
+}
+function sanitizedTargetPath(targetPath, fallbackFileName) {
+    const basename = path.basename(targetPath);
+    if (!NON_PORTABLE_FILE_NAME_CHARACTERS.test(basename)) {
+        return targetPath;
+    }
+    const sanitized = tempFileNameForTarget(targetPath, fallbackFileName);
+    return sanitized === basename ? targetPath : path.join(path.dirname(targetPath), sanitized);
+}
+function ensureTrailingSep(value) {
+    return value.endsWith(path.sep) ? value : `${value}${path.sep}`;
+}
+function toRootPathInput(params) {
+    if (!path.isAbsolute(params.targetPath)) {
+        return params.targetPath;
+    }
+    const absoluteTarget = path.resolve(params.targetPath);
+    const rootDir = path.resolve(params.rootDir);
+    if (isPathInside(ensureTrailingSep(rootDir), absoluteTarget)) {
+        return path.relative(rootDir, absoluteTarget);
+    }
+    if (isPathInside(ensureTrailingSep(params.rootReal), absoluteTarget)) {
+        return path.relative(params.rootReal, absoluteTarget);
+    }
+    return params.targetPath;
+}
+function assertFileTargetPath(targetPath) {
+    const basename = path.basename(targetPath);
+    if (!targetPath ||
+        targetPath === "." ||
+        targetPath.endsWith("/") ||
+        targetPath.endsWith("\\") ||
+        !basename ||
+        basename === "." ||
+        basename === "..") {
+        throw new FsSafeError("invalid-path", "target path must name a file");
+    }
+}
+export async function writeExternalFileWithinRoot(options) {
+    const maxBytes = normalizeMaxBytes(options.maxBytes);
+    const targetRoot = await root(options.rootDir);
+    const requestedTargetPath = options.path;
+    if (requestedTargetPath.length === 0) {
+        throw new FsSafeError("invalid-path", "target path is required");
+    }
+    assertFileTargetPath(requestedTargetPath);
+    const rawTargetPath = toRootPathInput({
+        rootDir: targetRoot.rootDir,
+        rootReal: targetRoot.rootReal,
+        targetPath: requestedTargetPath,
+    });
+    assertFileTargetPath(rawTargetPath);
+    const targetPath = sanitizedTargetPath(rawTargetPath, options.fallbackFileName);
+    const finalPath = await targetRoot.resolve(targetPath);
+    if (options.staging === "sibling") {
+        const parentPath = path.dirname(targetPath);
+        if (parentPath !== ".") {
+            await targetRoot.mkdir(parentPath);
+        }
+        const siblingFinalPath = await targetRoot.resolve(targetPath);
+        const result = await writeExternalFileViaSibling({
+            finalPath: siblingFinalPath,
+            write: options.write,
+            fallbackFileName: options.fallbackFileName,
+            maxBytes,
+            mode: options.mode,
+        });
+        return { path: siblingFinalPath, result };
+    }
+    const staged = await tempFile({
+        prefix: "fs-safe-output",
+        fileName: tempFileNameForTarget(targetPath, options.fallbackFileName),
+    });
+    try {
+        const result = await options.write(staged.path);
+        await targetRoot.copyIn(targetPath, staged.path, {
+            maxBytes,
+            mode: options.mode,
+            mkdir: true,
+            sourceHardlinks: "reject",
+        });
+        return { path: finalPath, result };
+    }
+    finally {
+        await staged.cleanup();
+    }
+}
+function buildSiblingTempPath(targetPath, fallbackFileName) {
+    const prefix = `.fs-safe-output-${process.pid}-${randomUUID()}-`;
+    const suffix = ".part";
+    const safeTail = fitFileNameToPortableComponent({
+        prefix,
+        fileName: tempFileNameForTarget(targetPath, fallbackFileName),
+        suffix,
+    });
+    return path.join(path.dirname(targetPath), `${prefix}${safeTail}${suffix}`);
+}
+async function writeExternalFileViaSibling(params) {
+    const finalPath = path.resolve(params.finalPath);
+    const { result } = await writeCallbackSibling({
+        tempPath: buildSiblingTempPath(finalPath, params.fallbackFileName),
+        write: params.write,
+        resolveFinalPath: () => finalPath,
+        mode: params.mode,
+        maxBytes: params.maxBytes,
+        syncTempFile: true,
+        syncParentDir: true,
+    });
+    return result;
+}

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

@@ -0,0 +1,31 @@
+export type WindowsAceFlags = {
+    raw: number;
+    objectInherit: boolean;
+    containerInherit: boolean;
+    noPropagateInherit: boolean;
+    inheritOnly: boolean;
+    inherited: boolean;
+    successfulAccess: boolean;
+    failedAccess: boolean;
+};
+export type WindowsAccessControlEntry = {
+    sid: string;
+    mask: number;
+    aceType: "allow" | "deny";
+    flags: WindowsAceFlags;
+};
+export type OwnerAndDaclResult = {
+    status: "supported";
+    ownerSid: string;
+    currentUserSid: string;
+    daclPresent: boolean;
+    isLocal: boolean;
+    complete: boolean;
+    unsupportedAceTypes: number[];
+    aces: WindowsAccessControlEntry[];
+} | {
+    status: "unsupported-platform";
+    platform: NodeJS.Platform;
+};
+export declare function readOwnerAndDacl(targetPath: string): OwnerAndDaclResult;
+//# sourceMappingURL=owner-dacl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"owner-dacl.d.ts","sourceRoot":"","sources":["../src/owner-dacl.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,eAAe,GAAG;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,OAAO,CAAC;IACvB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,kBAAkB,EAAE,OAAO,CAAC;IAC5B,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,OAAO,CAAC;IACnB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC;IAC1B,KAAK,EAAE,eAAe,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAC1B;IACE,MAAM,EAAE,WAAW,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,OAAO,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,IAAI,EAAE,yBAAyB,EAAE,CAAC;CACnC,GACD;IACE,MAAM,EAAE,sBAAsB,CAAC;IAC/B,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC;CAC3B,CAAC;AAEN,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,kBAAkB,CA6BvE"}

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

@@ -0,0 +1,28 @@
+import { FsSafeError } from "./errors.js";
+import { getNativeBinding } from "./native.js";
+export function readOwnerAndDacl(targetPath) {
+    if (process.platform !== "win32") {
+        return { status: "unsupported-platform", platform: process.platform };
+    }
+    const native = getNativeBinding();
+    if (!native) {
+        throw new FsSafeError("helper-unavailable", "Windows owner and DACL facts require the matching optional native platform package; " +
+            "install @openclaw/fs-safe with optional dependencies enabled on a supported platform and use FS_SAFE_NATIVE_MODE=auto or require");
+    }
+    const facts = native.readOwnerAndDacl(targetPath);
+    return {
+        status: "supported",
+        ownerSid: facts.ownerSid,
+        currentUserSid: facts.currentUserSid,
+        daclPresent: facts.daclPresent,
+        isLocal: facts.isLocal,
+        complete: facts.aceListComplete,
+        unsupportedAceTypes: [...facts.unsupportedAceTypes],
+        aces: facts.aces.map((entry) => ({
+            sid: entry.sid,
+            mask: entry.mask,
+            aceType: entry.aceType,
+            flags: { ...entry.flags },
+        })),
+    };
+}

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

@@ -0,0 +1,25 @@
+import { type RootPathAliasPolicy } from "./root-path.js";
+export type PathAliasPolicy = RootPathAliasPolicy;
+export declare const PATH_ALIAS_POLICIES: {
+    readonly strict: Readonly<{
+        allowFinalSymlinkForUnlink: false;
+        allowFinalHardlinkForUnlink: false;
+    }>;
+    readonly unlinkTarget: Readonly<{
+        allowFinalSymlinkForUnlink: true;
+        allowFinalHardlinkForUnlink: true;
+    }>;
+};
+export declare function assertNoPathAliasEscape(params: {
+    absolutePath: string;
+    rootPath: string;
+    boundaryLabel: string;
+    policy?: PathAliasPolicy;
+}): Promise<void>;
+export declare function assertNoHardlinkedFinalPath(params: {
+    filePath: string;
+    root: string;
+    boundaryLabel: string;
+    allowFinalHardlinkForUnlink?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=path-policy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"path-policy.d.ts","sourceRoot":"","sources":["../src/path-policy.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,mBAAmB,EACzB,MAAM,gBAAgB,CAAC;AAIxB,MAAM,MAAM,eAAe,GAAG,mBAAmB,CAAC;AAElD,eAAO,MAAM,mBAAmB;;;;;;;;;CAA2B,CAAC;AAE5D,wBAAsB,uBAAuB,CAAC,MAAM,EAAE;IACpD,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,eAAe,CAAC;CAC1B,GAAG,OAAO,CAAC,IAAI,CAAC,CAiBhB;AAED,wBAAsB,2BAA2B,CAAC,MAAM,EAAE;IACxD,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACvC,GAAG,OAAO,CAAC,IAAI,CAAC,CAqBhB"}

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

@@ -0,0 +1,44 @@
+import fs from "node:fs";
+import { ROOT_PATH_ALIAS_POLICIES, resolveRootPath, } from "./root-path.js";
+import { isNotFoundPathError } from "./path.js";
+import { shortPath } from "./error-detail.js";
+export const PATH_ALIAS_POLICIES = ROOT_PATH_ALIAS_POLICIES;
+export async function assertNoPathAliasEscape(params) {
+    const resolved = await resolveRootPath({
+        absolutePath: params.absolutePath,
+        rootPath: params.rootPath,
+        boundaryLabel: params.boundaryLabel,
+        policy: params.policy,
+    });
+    const allowFinalSymlink = params.policy?.allowFinalSymlinkForUnlink === true;
+    if (allowFinalSymlink && resolved.kind === "symlink") {
+        return;
+    }
+    await assertNoHardlinkedFinalPath({
+        filePath: resolved.canonicalPath,
+        root: resolved.rootPath,
+        boundaryLabel: params.boundaryLabel,
+        allowFinalHardlinkForUnlink: params.policy?.allowFinalHardlinkForUnlink,
+    });
+}
+export async function assertNoHardlinkedFinalPath(params) {
+    if (params.allowFinalHardlinkForUnlink) {
+        return;
+    }
+    let stat;
+    try {
+        stat = fs.statSync(params.filePath);
+    }
+    catch (err) {
+        if (isNotFoundPathError(err)) {
+            return;
+        }
+        throw err;
+    }
+    if (!stat.isFile()) {
+        return;
+    }
+    if (stat.nlink > 1) {
+        throw new Error(`Hardlinked path is not allowed under ${params.boundaryLabel} (${shortPath(params.root)}): ${shortPath(params.filePath)}`);
+    }
+}

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

@@ -0,0 +1,21 @@
+import fs from "node:fs";
+export { assertNoUnsafeDeviceReadPath, isUnsafeDeviceReadPath, matchUnsafeDeviceReadPath, type UnsafeDeviceReadPathMatch, type UnsafeDeviceReadPathOptions, type UnsafeDeviceReadPathReason, } from "./device-path.js";
+export declare function normalizeWindowsPathForComparison(input: string): string;
+export declare function isNodeError(value: unknown): value is NodeJS.ErrnoException;
+export declare function hasNodeErrorCode(value: unknown, code: string): boolean;
+export declare function assertNoNulPathInput(filePath: string, message?: string): void;
+export declare function isNotFoundPathError(value: unknown): boolean;
+export declare function isSymlinkOpenError(value: unknown): boolean;
+export declare function isPathInside(root: string, target: string): boolean;
+export declare function isPathRelativeEscape(relativePath: string): boolean;
+export declare function resolveSafeBaseDir(rootDir: string): string;
+export declare function isWithinDir(rootDir: string, targetPath: string): boolean;
+export declare function safeRealpathSync(targetPath: string, cache?: Map<string, string>): string | null;
+export declare function isPathInsideWithRealpath(basePath: string, candidatePath: string, opts?: {
+    requireRealpath?: boolean;
+    cache?: Map<string, string>;
+}): boolean;
+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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../src/path.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,SAAS,CAAC;AAMzB,OAAO,EACL,4BAA4B,EAC5B,sBAAsB,EACtB,yBAAyB,EACzB,KAAK,yBAAyB,EAC9B,KAAK,2BAA2B,EAChC,KAAK,0BAA0B,GAChC,MAAM,kBAAkB,CAAC;AAM1B,wBAAgB,iCAAiC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAWvE;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,cAAc,CAI1E;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAEtE;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,SAA6B,GAAG,IAAI,CAIjG;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAE3D;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAE1D;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CA4BlE;AAED,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAElE;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAG1D;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAExE;AAED,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,GAAG,IAAI,CAa/F;AAED,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,EACrB,IAAI,CAAC,EAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAChE,OAAO,CAUT;AAED,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,EAAE,CAAC,KAAK,GAAG,IAAI,CAMhE;AAED,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE,CA0BpE;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAOrF"}

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

@@ -0,0 +1,136 @@
+import fs from "node:fs";
+import path from "node:path";
+import { FsSafeError } from "./errors.js";
+import { isDriveRelativePath } from "./safe-path-segment.js";
+export { assertNoUnsafeDeviceReadPath, isUnsafeDeviceReadPath, matchUnsafeDeviceReadPath, } from "./device-path.js";
+const NOT_FOUND_CODES = new Set(["ENOENT", "ENOTDIR"]);
+const SYMLINK_OPEN_CODES = new Set(["ELOOP", "EINVAL", "ENOTSUP"]);
+const POSIX_SEPARATOR_CHAR_CODE = 0x2f;
+export function normalizeWindowsPathForComparison(input) {
+    let normalized = path.win32.normalize(input);
+    if (normalized.startsWith("\\\\?\\")) {
+        normalized = normalized.slice(4);
+        if (normalized.toUpperCase().startsWith("UNC\\")) {
+            normalized = `\\\\${normalized.slice(4)}`;
+        }
+    }
+    // Lowercase only: this value feeds Windows containment math, so surrounding
+    // whitespace is part of the path and must not be trimmed away.
+    return normalized.replaceAll("/", "\\").toLowerCase();
+}
+export function isNodeError(value) {
+    return Boolean(value && typeof value === "object" && "code" in value);
+}
+export function hasNodeErrorCode(value, code) {
+    return isNodeError(value) && value.code === code;
+}
+export function assertNoNulPathInput(filePath, message = "path contains a NUL byte") {
+    if (filePath.includes("\0")) {
+        throw new FsSafeError("invalid-path", message);
+    }
+}
+export function isNotFoundPathError(value) {
+    return isNodeError(value) && typeof value.code === "string" && NOT_FOUND_CODES.has(value.code);
+}
+export function isSymlinkOpenError(value) {
+    return isNodeError(value) && typeof value.code === "string" && SYMLINK_OPEN_CODES.has(value.code);
+}
+export function isPathInside(root, target) {
+    if (process.platform === "win32") {
+        const rootForCompare = normalizeWindowsPathForComparison(path.win32.resolve(root));
+        const targetForCompare = normalizeWindowsPathForComparison(path.win32.resolve(target));
+        const relative = path.win32.relative(rootForCompare, targetForCompare);
+        const firstSegment = relative.split(path.win32.sep)[0];
+        return (relative === "" || (firstSegment !== ".." && !path.win32.isAbsolute(relative)));
+    }
+    if (root.length > 0 &&
+        root.charCodeAt(0) === POSIX_SEPARATOR_CHAR_CODE &&
+        target.length >= root.length &&
+        target.charCodeAt(0) === POSIX_SEPARATOR_CHAR_CODE &&
+        !target.includes("/..") &&
+        (target === root ||
+            (target.startsWith(root) && target.charCodeAt(root.length) === POSIX_SEPARATOR_CHAR_CODE))) {
+        return true;
+    }
+    const resolvedRoot = path.resolve(root);
+    const resolvedTarget = path.resolve(target);
+    const relative = path.relative(resolvedRoot, resolvedTarget);
+    const firstSegment = relative.split(path.posix.sep)[0];
+    return relative === "" || (firstSegment !== ".." && !path.isAbsolute(relative));
+}
+export function isPathRelativeEscape(relativePath) {
+    return relativePath === ".." || relativePath.startsWith(`..${path.sep}`) || path.isAbsolute(relativePath);
+}
+export function resolveSafeBaseDir(rootDir) {
+    const resolved = path.resolve(rootDir);
+    return resolved.endsWith(path.sep) ? resolved : `${resolved}${path.sep}`;
+}
+export function isWithinDir(rootDir, targetPath) {
+    return isPathInside(rootDir, targetPath);
+}
+export function safeRealpathSync(targetPath, cache) {
+    const cached = cache?.get(targetPath);
+    if (cached) {
+        return cached;
+    }
+    try {
+        const resolved = fs.realpathSync(targetPath);
+        cache?.set(targetPath, resolved);
+        cache?.set(resolved, resolved);
+        return resolved;
+    }
+    catch {
+        return null;
+    }
+}
+export function isPathInsideWithRealpath(basePath, candidatePath, opts) {
+    if (!isPathInside(basePath, candidatePath)) {
+        return false;
+    }
+    const baseReal = safeRealpathSync(basePath, opts?.cache);
+    const candidateReal = safeRealpathSync(candidatePath, opts?.cache);
+    if (!baseReal || !candidateReal) {
+        return opts?.requireRealpath === false;
+    }
+    return isPathInside(baseReal, candidateReal);
+}
+export function safeStatSync(targetPath) {
+    try {
+        return fs.statSync(targetPath);
+    }
+    catch {
+        return null;
+    }
+}
+export function splitSafeRelativePath(relativePath) {
+    if (relativePath.length === 0 || relativePath === ".") {
+        return [];
+    }
+    assertNoNulPathInput(relativePath, "relative path contains a NUL byte");
+    if (relativePath.includes("\\")) {
+        throw new FsSafeError("invalid-path", "relative path must use forward slashes");
+    }
+    if (path.posix.isAbsolute(relativePath) ||
+        path.win32.isAbsolute(relativePath) ||
+        relativePath.startsWith("//")) {
+        throw new FsSafeError("invalid-path", "relative path must not be absolute");
+    }
+    const segments = relativePath.split("/").filter((segment) => segment.length > 0 && segment !== ".");
+    for (const segment of segments) {
+        if (segment === "..") {
+            throw new FsSafeError("invalid-path", "relative path must not contain '..'");
+        }
+        if (isDriveRelativePath(segment)) {
+            throw new FsSafeError("invalid-path", "relative path must not contain a drive letter");
+        }
+    }
+    return segments;
+}
+export function resolveSafeRelativePath(rootDir, relativePath) {
+    const root = path.resolve(rootDir);
+    const target = path.resolve(root, ...splitSafeRelativePath(relativePath));
+    if (!isPathInside(root, target)) {
+        throw new FsSafeError("outside-workspace", "relative path escapes root");
+    }
+    return target;
+}

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

@@ -0,0 +1,25 @@
+export declare const DEFAULT_PERMISSION_EXEC_TIMEOUT_MS = 30000;
+export type PermissionCommandFailure = {
+    command: string;
+    durationMs: number;
+    timedOut: boolean;
+    exitCode: number | null;
+    signal: string | null;
+    stderr: string;
+};
+export declare function formatPermissionErrorDetail(value: string): string;
+export declare class PermissionCommandError extends Error implements PermissionCommandFailure {
+    readonly command: string;
+    readonly durationMs: number;
+    readonly timedOut: boolean;
+    readonly exitCode: number | null;
+    readonly signal: string | null;
+    readonly stderr: string;
+    constructor(command: string, durationMs: number, cause: unknown, timeoutMs?: number);
+}
+export declare function getPermissionCommandFailure(error: unknown, command: string, durationMs: number): PermissionCommandFailure | undefined;
+export declare function executePermissionCommand(command: string, args: string[], timeoutMs?: number): Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+//# sourceMappingURL=permission-exec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"permission-exec.d.ts","sourceRoot":"","sources":["../src/permission-exec.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,kCAAkC,QAAS,CAAC;AAEzD,MAAM,MAAM,wBAAwB,GAAG;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGjE;AAgBD,qBAAa,sBAAuB,SAAQ,KAAM,YAAW,wBAAwB;IACnF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB,YACE,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,OAAO,EACd,SAAS,SAAqC,EAc/C;CACF;AAED,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GACjB,wBAAwB,GAAG,SAAS,CAgBtC;AAED,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,SAAS,SAAqC,GAC7C,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAa7C"}

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

@@ -0,0 +1,74 @@
+import { execFile } from "node:child_process";
+import path from "node:path";
+import { promisify } from "node:util";
+import { formatErrorDetail } from "./error-detail.js";
+const execFileAsync = promisify(execFile);
+export const DEFAULT_PERMISSION_EXEC_TIMEOUT_MS = 30_000;
+export function formatPermissionErrorDetail(value) {
+    const formatted = formatErrorDetail(value);
+    return formatted.length > 400 ? `${formatted.slice(0, 399)}…` : formatted;
+}
+function commandFailureFields(error) {
+    const fields = error && typeof error === "object" ? error : {};
+    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() : ""),
+    };
+}
+export class PermissionCommandError extends Error {
+    command;
+    durationMs;
+    timedOut;
+    exitCode;
+    signal;
+    stderr;
+    constructor(command, durationMs, cause, timeoutMs = DEFAULT_PERMISSION_EXEC_TIMEOUT_MS) {
+        const fields = commandFailureFields(cause);
+        super(fields.timedOut
+            ? `Windows permission inspection timed out after ${timeoutMs}ms`
+            : `Windows permission command ${formatPermissionErrorDetail(path.win32.basename(command))} failed (exit code ${fields.exitCode}, signal ${formatPermissionErrorDetail(fields.signal ?? "none")})`, { cause });
+        this.name = "PermissionCommandError";
+        this.command = command;
+        this.durationMs = Math.round(durationMs);
+        this.timedOut = fields.timedOut;
+        this.exitCode = fields.exitCode;
+        this.signal = fields.signal;
+        this.stderr = fields.stderr;
+    }
+}
+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 (!error || typeof error !== "object" ||
+        !("code" in error || "signal" in error || "killed" in error || "stderr" in error)) {
+        return undefined;
+    }
+    return { command, durationMs: Math.round(durationMs), ...commandFailureFields(error) };
+}
+export async function executePermissionCommand(command, args, timeoutMs = DEFAULT_PERMISSION_EXEC_TIMEOUT_MS) {
+    const startedAt = performance.now();
+    try {
+        return (await execFileAsync(command, args, {
+            encoding: "utf8",
+            windowsHide: true,
+            maxBuffer: 1024 * 1024,
+            timeout: timeoutMs,
+            killSignal: "SIGKILL",
+        }));
+    }
+    catch (err) {
+        throw new PermissionCommandError(command, performance.now() - startedAt, err, timeoutMs);
+    }
+}

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

@@ -0,0 +1,4 @@
+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-public.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissions-public.d.ts","sourceRoot":"","sources":["../src/permissions-public.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,sBAAsB,EACtB,2BAA2B,EAC3B,sBAAsB,EACtB,eAAe,EACf,eAAe,EACf,eAAe,EACf,eAAe,EACf,QAAQ,EACR,QAAQ,EACR,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,KAAK,cAAc,GACpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,sBAAsB,EACtB,KAAK,6BAA6B,GACnC,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,gBAAgB,EAChB,KAAK,kBAAkB,EACvB,KAAK,yBAAyB,EAC9B,KAAK,eAAe,GACrB,MAAM,iBAAiB,CAAC"}

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

@@ -0,0 +1,3 @@
+export { formatOctal, formatPermissionDetail, formatPermissionRemediation, inspectPathPermissions, isGroupReadable, isGroupWritable, isWorldReadable, isWorldWritable, modeBits, safeStat, } from "./permissions.js";
+export { createPrivateDirectory, } from "./private-directory.js";
+export { readOwnerAndDacl, } from "./owner-dacl.js";