@openclaw/openshell-sandbox 2026.9.4 → 2026.9.6

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

@@ -1,8 +1,17 @@
 import path from "node:path";
 import { WINDOWS_RESERVED_DEVICE_NAMES } from "./device-path.js";
-const WINDOWS_INVALID_FILE_NAME_CHARACTERS = new Set('<>:"/\\|?*');
-function trimWindowsIgnoredSuffix(value) {
-    let end = value.length;
+import { maxNormalizedUtf8Bytes } from "./unicode-path.js";
+import { hasWindowsDrivePrefix } from "./windows-path-syntax.js";
+const INVALID_FILE_NAME_CHARACTERS = /[\u0000-\u001f\u007f-\u009f<>:"/\\|?*]/g;
+const HAS_INVALID_FILE_NAME_CHARACTER = /[\u0000-\u001f\u007f-\u009f<>:"/\\|?*]/;
+const HAS_RETAINED_FILE_NAME_CHARACTER = /[^\u0000-\u001f\u007f-\u009f<>:"/\\|?*\s]/;
+function canStartWindowsDeviceName(character) {
+    const folded = character | 0x20;
+    return folded === 0x61 || folded === 0x63 || folded === 0x6c ||
+        folded === 0x6e || folded === 0x70;
+}
+function windowsDeviceStemEnd(value, stemEnd) {
+    let end = stemEnd;
     while (end > 0) {
         const character = value.charCodeAt(end - 1);
         if (character !== 0x20 && character !== 0x2e) {
@@ -10,21 +19,53 @@ function trimWindowsIgnoredSuffix(value) {
         }
         end -= 1;
     }
-    return end === value.length ? value : value.slice(0, end);
+    return end;
 }
-function suffixWindowsReservedDeviceName(fileName) {
+export function suffixWindowsReservedDeviceName(fileName) {
+    if (!canStartWindowsDeviceName(fileName.charCodeAt(0))) {
+        return fileName;
+    }
     const extensionIndex = fileName.indexOf(".");
     const baseNameEnd = extensionIndex < 0 ? fileName.length : extensionIndex;
-    const baseName = fileName.slice(0, baseNameEnd);
-    const deviceBaseName = trimWindowsIgnoredSuffix(baseName);
-    if (!WINDOWS_RESERVED_DEVICE_NAMES.has(deviceBaseName.toUpperCase())) {
+    const deviceBaseNameEnd = windowsDeviceStemEnd(fileName, baseNameEnd);
+    if (deviceBaseNameEnd === 0 ||
+        deviceBaseNameEnd > 7 ||
+        !WINDOWS_RESERVED_DEVICE_NAMES.has(fileName.slice(0, deviceBaseNameEnd).toUpperCase())) {
         return fileName;
     }
-    return `${baseName}_${fileName.slice(baseNameEnd)}`;
+    return `${fileName.slice(0, baseNameEnd)}_${fileName.slice(baseNameEnd)}`;
 }
 const PORTABLE_FILE_NAME_BYTES = 255;
+const SANITIZED_FILE_NAME_CODE_UNITS = 200;
+const SAFE_FALLBACK_FILE_NAME = "file";
+/**
+ * Uses native string and regexp operations to recognize the full sanitizer's
+ * bounded fixed points. The separate non-global regexp keeps this predicate
+ * stateless, and the authoritative device-name transform remains the final
+ * admission check.
+ */
+function isBoundedSanitizedFileName(fileName, trimmedFileName) {
+    return typeof fileName === "string" &&
+        fileName.length > 0 &&
+        fileName.length <= SANITIZED_FILE_NAME_CODE_UNITS &&
+        fileName !== "." &&
+        fileName !== ".." &&
+        trimmedFileName === fileName &&
+        !HAS_INVALID_FILE_NAME_CHARACTER.test(fileName) &&
+        suffixWindowsReservedDeviceName(fileName) === fileName;
+}
 function normalizedFileNameBytes(value) {
-    return Math.max(Buffer.byteLength(value.normalize("NFC"), "utf8"), Buffer.byteLength(value.normalize("NFD"), "utf8"));
+    return maxNormalizedUtf8Bytes(value, true);
+}
+function truncateCodeUnitsWithoutSplittingSurrogate(value, limit) {
+    if (value.length <= limit)
+        return value;
+    let truncated = value.slice(0, limit);
+    const trailingCodeUnit = truncated.charCodeAt(truncated.length - 1);
+    if (trailingCodeUnit >= 0xd800 && trailingCodeUnit <= 0xdbff) {
+        truncated = truncated.slice(0, -1);
+    }
+    return truncated;
 }
 /** Keeps short names exact and trims only the filename tail of a composite temp name. */
 export function fitFileNameToPortableComponent(params) {
@@ -58,34 +99,40 @@ export function fitFileNameToPortableComponent(params) {
     }
     return `${codePoints.slice(0, low).join("")}${tailSuffix}`;
 }
-export function sanitizeUntrustedFileName(fileName, fallbackName) {
-    const trimmed = typeof fileName === "string" ? fileName.trim() : "";
-    if (!trimmed) {
-        return fallbackName;
-    }
-    let base = path.posix.basename(trimmed);
-    base = path.win32.basename(base);
-    let cleaned = "";
-    for (let i = 0; i < base.length; i++) {
-        const code = base.charCodeAt(i);
-        if (code < 0x20 ||
-            (code >= 0x7f && code <= 0x9f) ||
-            WINDOWS_INVALID_FILE_NAME_CHARACTERS.has(base[i])) {
-            continue;
-        }
-        cleaned += base[i];
+function sanitizeFileNameCandidate(fileName) {
+    if (typeof fileName !== "string")
+        return undefined;
+    const trimmed = fileName.trim();
+    if (!trimmed)
+        return undefined;
+    if (isBoundedSanitizedFileName(fileName, trimmed))
+        return fileName;
+    // Basename selection cannot manufacture a character, and the complete
+    // sanitizer removes this same invalid set before its final trim.
+    if (!HAS_RETAINED_FILE_NAME_CHARACTER.test(trimmed))
+        return undefined;
+    let base = trimmed;
+    if (base.includes("/"))
+        base = path.posix.basename(base);
+    if (base.includes("\\") || hasWindowsDrivePrefix(base)) {
+        base = path.win32.basename(base);
     }
-    base = cleaned.trim();
+    base = base.replace(INVALID_FILE_NAME_CHARACTERS, "").trim();
     if (!base || base === "." || base === "..") {
-        return fallbackName;
+        return undefined;
     }
-    base = suffixWindowsReservedDeviceName(base);
-    if (base.length > 200) {
-        base = base.slice(0, 200);
-        const trailingCodeUnit = base.charCodeAt(base.length - 1);
-        if (trailingCodeUnit >= 0xd800 && trailingCodeUnit <= 0xdbff) {
-            base = base.slice(0, -1);
-        }
+    base = truncateCodeUnitsWithoutSplittingSurrogate(base, SANITIZED_FILE_NAME_CODE_UNITS);
+    let safeBase = suffixWindowsReservedDeviceName(base);
+    if (safeBase.length > SANITIZED_FILE_NAME_CODE_UNITS) {
+        // The safety suffix is the final invariant. Shorten the unsuffixed tail so
+        // truncation cannot turn a padded reserved stem back into a device name.
+        base = truncateCodeUnitsWithoutSplittingSurrogate(base, SANITIZED_FILE_NAME_CODE_UNITS - 1);
+        safeBase = suffixWindowsReservedDeviceName(base);
     }
-    return base;
+    return safeBase;
+}
+export function sanitizeUntrustedFileName(fileName, fallbackName) {
+    return (sanitizeFileNameCandidate(fileName) ??
+        sanitizeFileNameCandidate(fallbackName) ??
+        SAFE_FALLBACK_FILE_NAME);
 }

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

@@ -10,4 +10,3 @@ export declare function pathExists(filePath: string): Promise<boolean>;
  * semantics.
  */
 export declare function pathExistsSync(filePath: string): boolean;
-//# sourceMappingURL=fs.d.ts.map

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

@@ -1,5 +1,5 @@
 import fs from "node:fs";
-import fsp from "node:fs/promises";
+import { pathForWindowsFilesystem } from "./windows-path-alias.js";
 /**
  * Returns true when `fs.stat()` can stat the path.
  *
@@ -8,7 +8,7 @@ import fsp from "node:fs/promises";
  */
 export async function pathExists(filePath) {
     try {
-        await fsp.stat(filePath);
+        fs.statSync(pathForWindowsFilesystem(filePath));
         return true;
     }
     catch {
@@ -21,7 +21,7 @@ export async function pathExists(filePath) {
  */
 export function pathExistsSync(filePath) {
     try {
-        fs.statSync(filePath);
+        fs.statSync(pathForWindowsFilesystem(filePath));
         return true;
     }
     catch {

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

@@ -1,3 +1,6 @@
+import { type RootBoundaryIdentity } from "./root-boundary.js";
+import { type MutationDirectoryObservation } from "./pinned-mutation-observation.js";
+import type { PinnedCreatedDirectoryReceipt, PinnedMutationAdmissionReceipt, PinnedMutationAuthorizationToken } from "./pinned-write-types.js";
 /**
  * Creates each missing path component from `rootReal` down to `targetPath`,
  * guarding every step. Returns the real (symlink-resolved) path of the final
@@ -8,7 +11,15 @@ export declare function mkdirPathComponentsWithGuards(params: {
     rootReal: string;
     targetPath: string;
     beforeComponent?: (componentPath: string) => Promise<void> | void;
+    beforeCreateComponent?: (componentPath: string, prospectiveTargetPath: string, retainedTargetPath: string | undefined, parent: MutationDirectoryObservation) => Promise<PinnedMutationAdmissionReceipt | undefined> | PinnedMutationAdmissionReceipt | undefined;
+    beforeUseComponent?: (componentPath: string, prospectiveTargetPath: string, retainedTargetPath: string | undefined) => Promise<void> | void;
+    afterCreateComponent?: (receipt: PinnedCreatedDirectoryReceipt) => PinnedMutationAuthorizationToken | undefined;
+    assertBeforeMutation?: () => void;
     mode?: number;
+    private?: boolean;
     rejectSymlinks?: boolean;
+    revalidateParentAfterBeforeComponent?: boolean;
+    synchronousAuthorizationIncludesFence?: boolean;
+    retainedTargetPath?: string;
+    rootIdentity?: RootBoundaryIdentity;
 }): Promise<string>;
-//# sourceMappingURL=guarded-mkdir.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/guarded-mkdir.js

@@ -1,17 +1,81 @@
-import fsSync from "node:fs";
+import fsSync, {} from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { assertAsyncDirectoryGuard, createAsyncDirectoryGuard } from "./directory-guard.js";
+import { createDirectoryWithAdmission } from "./create.js";
+import { assertAsyncDirectoryGuard, createAsyncDirectoryGuard, inspectDirectoryIdentitySync, } from "./directory-guard.js";
 import { FsSafeError } from "./errors.js";
-import { isNotFoundPathError, isPathRelativeEscape } from "./path.js";
-import { directoryComponentNotDirectoryError } from "./root-errors.js";
-function isSameOrChildPath(candidate, parent) {
-    const parentPrefix = parent.endsWith(path.sep) ? parent : `${parent}${path.sep}`;
-    return candidate === parent || candidate.startsWith(parentPrefix);
+import { hasNodeErrorCode, isNotFoundPathError, isPathRelativeEscape } from "./path.js";
+import { directoryComponentNotDirectoryError, rootPathChangedError } from "./root-errors.js";
+import { assertNoWindowsPathAlias, pathForWindowsFilesystem, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
+import { realpathSync } from "./realpath.js";
+import { admitPathInsideRoot } from "./root-boundary.js";
+import { checkedMutationDirectory } from "./pinned-mutation-observation.js";
+import { createPathSegmentRoute, joinPathSegmentRoute, } from "./path-segment-route.js";
+function sameDirectoryFacts(left, right) {
+    return left.dev === right.dev && left.ino === right.ino && left.mode === right.mode &&
+        left.nlink === right.nlink;
+}
+function isDirectoryCollision(error) {
+    return hasNodeErrorCode(error, "EEXIST") ||
+        (error instanceof FsSafeError && error.code === "already-exists");
+}
+function inspectGuardCurrent(parent) {
+    const stat = inspectDirectoryIdentitySync(parent.dir, parent.stat);
+    if (realpathSync.native(parent.dir) !== parent.realPath) {
+        throw new FsSafeError("path-mismatch", "directory changed during operation");
+    }
+    return stat;
+}
+function observedGuard(parent) {
+    return checkedMutationDirectory(parent.dir, parent.realPath, parent.stat);
+}
+function createdDirectoryEvidence(admission, parent, childPath) {
+    try {
+        const parentAfter = inspectGuardCurrent(parent);
+        const childBefore = inspectDirectoryIdentitySync(childPath);
+        const realPath = realpathSync.native(childPath);
+        if (realPath !== childPath)
+            return undefined;
+        const childAfter = inspectDirectoryIdentitySync(childPath, childBefore);
+        if (!sameDirectoryFacts(childBefore, childAfter))
+            return undefined;
+        const child = checkedMutationDirectory(childPath, realPath, childAfter);
+        const receipt = Object.freeze({
+            admission,
+            parent: checkedMutationDirectory(parent.dir, parent.realPath, parentAfter),
+            child,
+        });
+        return Object.freeze({
+            receipt,
+            guard: Object.freeze({ dir: childPath, realPath, stat: childAfter }),
+        });
+    }
+    catch {
+        // Failed optional evidence leaves the existing ordered admission in charge.
+        return undefined;
+    }
+}
+function sameAbsolutePath(left, right) {
+    return path.relative(path.resolve(left), path.resolve(right)) === "";
+}
+function suppliedExactRootIdentity(identity) {
+    return typeof identity?.dev === "bigint" && typeof identity.ino === "bigint"
+        ? { dev: identity.dev, ino: identity.ino }
+        : undefined;
+}
+function assertGuardMatchesRootIdentity(guard, expected) {
+    if (guard.stat.dev !== expected.dev || guard.stat.ino !== expected.ino) {
+        throw rootPathChangedError();
+    }
+}
+function isPromiseLike(value) {
+    return typeof value?.then === "function";
 }
 async function realpathOrThrowNotFile(target) {
     try {
-        return path.resolve(fsSync.realpathSync.native(target));
+        const canonical = realpathSync.native(pathForWindowsFilesystem(target));
+        assertNoWindowsPathAlias(canonical, "filesystem", "canonical directory uses a Windows filesystem namespace alias");
+        return resolvePathPreservingWindowsRoot(canonical);
     }
     catch (error) {
         if (isNotFoundPathError(error)) {
@@ -29,38 +93,157 @@ async function realpathOrThrowNotFile(target) {
  * re-deriving it from the original, possibly-symlinked, lexical path.
  */
 export async function mkdirPathComponentsWithGuards(params) {
-    const root = path.resolve(params.rootReal);
-    const rootCanonical = path.resolve(fsSync.realpathSync.native(root));
-    const target = path.resolve(params.targetPath);
-    const relative = path.relative(root, target);
-    if (isPathRelativeEscape(relative)) {
+    const rawRootReal = params.rootReal;
+    assertNoWindowsPathAlias(rawRootReal, "filesystem", "root directory uses a Windows filesystem namespace alias");
+    const rawTargetPath = params.targetPath;
+    assertNoWindowsPathAlias(rawTargetPath, "filesystem", "target directory uses a Windows filesystem namespace alias");
+    const root = resolvePathPreservingWindowsRoot(rawRootReal);
+    const target = resolvePathPreservingWindowsRoot(rawTargetPath);
+    const suppliedIdentity = suppliedExactRootIdentity(params.rootIdentity);
+    const configuredRootGuard = await createAsyncDirectoryGuard(root, { bigint: true });
+    const checkedRootIdentity = suppliedIdentity ?? {
+        dev: configuredRootGuard.stat.dev,
+        ino: configuredRootGuard.stat.ino,
+    };
+    assertGuardMatchesRootIdentity(configuredRootGuard, checkedRootIdentity);
+    assertNoWindowsPathAlias(configuredRootGuard.realPath);
+    const rootCanonical = resolvePathPreservingWindowsRoot(configuredRootGuard.realPath);
+    const rootGuard = rootCanonical === root
+        ? configuredRootGuard
+        : await createAsyncDirectoryGuard(rootCanonical, { bigint: true });
+    assertGuardMatchesRootIdentity(rootGuard, checkedRootIdentity);
+    const admissionParams = {
+        candidatePath: target,
+        rootIdentity: checkedRootIdentity,
+    };
+    // Derive the suffix from the caller's trusted root spelling first. The
+    // canonical spelling is also accepted after both names have been bound to
+    // the same exact root object above.
+    const admittedTarget = admitPathInsideRoot({ rootPath: root, ...admissionParams }) ??
+        (rootCanonical === root
+            ? undefined
+            : admitPathInsideRoot({ rootPath: rootCanonical, ...admissionParams }));
+    if (!admittedTarget || isPathRelativeEscape(admittedTarget.relativePath)) {
         throw new FsSafeError("outside-workspace", "directory is outside workspace root");
     }
-    let current = root;
-    for (const part of relative.split(path.sep).filter(Boolean)) {
+    let current = rootCanonical;
+    let currentGuard = rootGuard;
+    const parts = admittedTarget.relativePath.split(path.sep).filter(Boolean);
+    let partRoute;
+    let retainedTargetPath = params.retainedTargetPath &&
+        sameAbsolutePath(path.dirname(params.retainedTargetPath), target)
+        ? params.retainedTargetPath
+        : undefined;
+    let retainedParentPath = retainedTargetPath ? path.dirname(retainedTargetPath) : undefined;
+    for (let index = 0; index < parts.length; index += 1) {
+        const part = parts[index];
         const next = path.join(current, part);
-        const parentGuard = await createAsyncDirectoryGuard(current);
-        await assertAsyncDirectoryGuard(parentGuard);
+        const parentGuard = currentGuard;
+        assertNoWindowsPathAlias(parentGuard.realPath, "filesystem", "canonical parent directory uses a Windows filesystem namespace alias");
+        let created = false;
+        let createReceipt;
+        if (!params.revalidateParentAfterBeforeComponent) {
+            await assertAsyncDirectoryGuard(parentGuard);
+        }
         await params.beforeComponent?.(next);
-        try {
-            await fs.mkdir(next, { mode: params.mode });
+        if (params.revalidateParentAfterBeforeComponent) {
+            await assertAsyncDirectoryGuard(parentGuard);
+        }
+        let shouldCreate = true;
+        if (params.beforeCreateComponent) {
+            let missing = false;
+            try {
+                fsSync.lstatSync(next);
+            }
+            catch (error) {
+                if (!isNotFoundPathError(error))
+                    throw error;
+                missing = true;
+            }
+            shouldCreate = missing;
+            if (missing) {
+                let prospectiveParent = retainedParentPath;
+                if (!prospectiveParent) {
+                    partRoute ??= createPathSegmentRoute(parts);
+                    prospectiveParent = joinPathSegmentRoute(next, partRoute, index + 1);
+                }
+                const authorization = params.beforeCreateComponent(next, prospectiveParent, retainedTargetPath, observedGuard(parentGuard));
+                if (isPromiseLike(authorization)) {
+                    createReceipt = await authorization;
+                    await assertAsyncDirectoryGuard(parentGuard);
+                }
+                else {
+                    createReceipt = authorization;
+                    // A synchronous authorization must still end at a live pathname
+                    // fence immediately before the authority callback and mkdir.
+                    if (!params.synchronousAuthorizationIncludesFence)
+                        inspectGuardCurrent(parentGuard);
+                }
+            }
+        }
+        if (shouldCreate) {
+            params.assertBeforeMutation?.();
+            // Both policy and ordinary mkdir must renew the parent after callbacks.
+            inspectGuardCurrent(parentGuard);
+            try {
+                if (params.private) {
+                    await createDirectoryWithAdmission(next, {
+                        private: true,
+                        mode: params.mode,
+                        assertBeforeMutation: params.assertBeforeMutation,
+                    }, {
+                        expectedParentIdentity: {
+                            dev: parentGuard.stat.dev, ino: parentGuard.stat.ino, realPath: parentGuard.realPath,
+                        },
+                    });
+                }
+                else {
+                    await fs.mkdir(next, { mode: params.mode });
+                }
+                created = true;
+            }
+            catch (error) {
+                if (!isDirectoryCollision(error))
+                    throw error;
+            }
         }
-        catch (error) {
-            if (!error || typeof error !== "object" || !("code" in error) || error.code !== "EEXIST") {
-                throw error;
+        let createdAuthorization;
+        let createdEvidence;
+        if (created && createReceipt && params.afterCreateComponent) {
+            createdEvidence = createdDirectoryEvidence(createReceipt, parentGuard, next);
+            if (createdEvidence) {
+                createdAuthorization = params.afterCreateComponent(createdEvidence.receipt);
             }
         }
-        const stat = fsSync.lstatSync(next);
-        if ((params.rejectSymlinks && stat.isSymbolicLink()) || (!stat.isSymbolicLink() && !stat.isDirectory())) {
+        if (params.beforeUseComponent && !createdAuthorization) {
+            let prospectiveParent = retainedParentPath;
+            if (!prospectiveParent) {
+                partRoute ??= createPathSegmentRoute(parts);
+                prospectiveParent = joinPathSegmentRoute(next, partRoute, index + 1);
+            }
+            await params.beforeUseComponent(next, prospectiveParent, retainedTargetPath);
+            await assertAsyncDirectoryGuard(parentGuard);
+        }
+        const stat = createdAuthorization ? undefined : fsSync.lstatSync(next);
+        if (stat && ((params.rejectSymlinks && stat.isSymbolicLink()) ||
+            (!stat.isSymbolicLink() && !stat.isDirectory()))) {
             throw directoryComponentNotDirectoryError();
         }
         // Node's recursive mkdir follows symlinks in missing components. Build one
         // segment at a time and realpath-check each segment before descending.
-        const nextReal = await realpathOrThrowNotFile(next);
-        if (!isSameOrChildPath(nextReal, rootCanonical)) {
+        const nextReal = createdAuthorization && createdEvidence
+            ? createdEvidence.receipt.child.canonicalPath
+            : await realpathOrThrowNotFile(next);
+        const admittedNextReal = admitPathInsideRoot({
+            rootPath: rootCanonical,
+            candidatePath: nextReal,
+            rootIdentity: checkedRootIdentity,
+        });
+        if (!admittedNextReal) {
             throw new FsSafeError("outside-workspace", "directory escaped workspace root");
         }
-        if (stat.isSymbolicLink()) {
+        const admittedNextPath = admittedNextReal.path;
+        if (stat?.isSymbolicLink()) {
             // An existing path component may legitimately be a symlink to a real
             // directory inside the root (e.g. a skill-bank layout). We already
             // verified above that it resolves inside the root, so treat the
@@ -70,18 +253,29 @@ export async function mkdirPathComponentsWithGuards(params) {
             // every subsequent segment. Callers that need the final directory
             // (e.g. to guard it themselves after this function returns) must use
             // the returned resolved path, not their own lexical parent path.
-            const targetStat = fsSync.statSync(nextReal);
+            const targetStat = fsSync.statSync(admittedNextPath);
             if (!targetStat.isDirectory()) {
                 throw directoryComponentNotDirectoryError();
             }
-            await createAsyncDirectoryGuard(nextReal);
+            currentGuard = await createAsyncDirectoryGuard(admittedNextPath, { bigint: true });
+            assertNoWindowsPathAlias(currentGuard.realPath, "filesystem", "canonical directory uses a Windows filesystem namespace alias");
             await assertAsyncDirectoryGuard(parentGuard);
-            current = nextReal;
+            retainedTargetPath = undefined;
+            retainedParentPath = undefined;
+            current = admittedNextPath;
             continue;
         }
-        await createAsyncDirectoryGuard(next);
-        await assertAsyncDirectoryGuard(parentGuard);
-        current = next;
+        if (createdAuthorization && createdEvidence) {
+            currentGuard = createdEvidence.guard;
+        }
+        else {
+            currentGuard = await createAsyncDirectoryGuard(admittedNextPath, { bigint: true });
+        }
+        assertNoWindowsPathAlias(currentGuard.realPath, "filesystem", "canonical directory uses a Windows filesystem namespace alias");
+        if (!createdAuthorization || !createdEvidence) {
+            await assertAsyncDirectoryGuard(parentGuard);
+        }
+        current = admittedNextPath;
     }
     return current;
 }

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

@@ -13,25 +13,20 @@ export declare function guardedRename(params: {
     onRenamed?: () => void;
     from: string;
     to: string;
-    targetRoot?: string;
-    verifyAfter?: boolean;
 }): Promise<void>;
 export declare function guardedRenameSync(params: {
     from: string;
     to: string;
-    targetRoot?: string;
-    verifyAfter?: boolean;
 }): void;
 export declare function guardedRm(params: {
     target: string;
+    assertBeforeMutation?: () => void;
     recursive?: boolean;
-    force?: boolean;
-    verifyAfter?: boolean;
 }): Promise<void>;
 export declare function guardedRmSync(params: {
     target: string;
+    assertBeforeMutation?: () => void;
     recursive?: boolean;
     force?: boolean;
     verifyAfter?: boolean;
 }): void;
-//# sourceMappingURL=guarded-mutation.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/guarded-mutation.js

@@ -1,7 +1,7 @@
 import fsSync, {} from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { assertAsyncDirectoryGuard, assertSyncDirectoryGuard, createAsyncDirectoryGuard, createNearestExistingDirectoryGuard, createNearestExistingSyncDirectoryGuard, createSyncDirectoryGuard, } from "./directory-guard.js";
+import { assertAsyncDirectoryGuard, assertSyncDirectoryGuard, createAsyncDirectoryGuard, createSyncDirectoryGuard, } from "./directory-guard.js";
 export async function withAsyncDirectoryGuards(guards, mutate, options = {}) {
     for (const guard of guards) {
         await assertAsyncDirectoryGuard(guard);
@@ -44,39 +44,38 @@ export function withSyncDirectoryGuards(guards, mutate, options = {}) {
 }
 export async function guardedRename(params) {
     const sourceGuard = await createAsyncDirectoryGuard(path.dirname(params.from));
-    const targetGuard = params.targetRoot
-        ? await createNearestExistingDirectoryGuard(params.targetRoot, path.dirname(params.to))
-        : await createAsyncDirectoryGuard(path.dirname(params.to));
+    const targetGuard = await createAsyncDirectoryGuard(path.dirname(params.to));
     await withAsyncDirectoryGuards([sourceGuard, targetGuard], async () => {
         if (params.onSourceInspected) {
-            params.onSourceInspected(await fs.lstat(params.from, { bigint: true }));
+            params.onSourceInspected(fsSync.lstatSync(params.from, { bigint: true }));
         }
         // Authority must survive all awaited guards; do not yield before rename dispatch.
         params.assertBeforeRename?.();
         await fs.rename(params.from, params.to);
         params.onRenamed?.();
-    }, { verifyAfter: params.verifyAfter });
+    });
 }
 export function guardedRenameSync(params) {
     const sourceGuard = createSyncDirectoryGuard(path.dirname(params.from));
-    const targetGuard = params.targetRoot
-        ? createNearestExistingSyncDirectoryGuard(params.targetRoot, path.dirname(params.to))
-        : createSyncDirectoryGuard(path.dirname(params.to));
-    withSyncDirectoryGuards([sourceGuard, targetGuard], () => fsSync.renameSync(params.from, params.to), { verifyAfter: params.verifyAfter });
+    const targetGuard = createSyncDirectoryGuard(path.dirname(params.to));
+    withSyncDirectoryGuards([sourceGuard, targetGuard], () => fsSync.renameSync(params.from, params.to));
 }
 export async function guardedRm(params) {
     const guard = await createAsyncDirectoryGuard(path.dirname(params.target));
     await withAsyncDirectoryGuards([guard], async () => {
+        params.assertBeforeMutation?.();
         await fs.rm(params.target, {
             ...(params.recursive !== undefined ? { recursive: params.recursive } : {}),
-            ...(params.force !== undefined ? { force: params.force } : {}),
         });
-    }, { verifyAfter: params.verifyAfter });
+    });
 }
 export function guardedRmSync(params) {
     const guard = createSyncDirectoryGuard(path.dirname(params.target));
-    withSyncDirectoryGuards([guard], () => fsSync.rmSync(params.target, {
-        ...(params.recursive !== undefined ? { recursive: params.recursive } : {}),
-        ...(params.force !== undefined ? { force: params.force } : {}),
-    }), { verifyAfter: params.verifyAfter });
+    withSyncDirectoryGuards([guard], () => {
+        params.assertBeforeMutation?.();
+        fsSync.rmSync(params.target, {
+            ...(params.recursive !== undefined ? { recursive: params.recursive } : {}),
+            ...(params.force !== undefined ? { force: params.force } : {}),
+        });
+    }, { verifyAfter: params.verifyAfter });
 }

package/node_modules/@openclaw/fs-safe/dist/guest-dispatch-python.d.ts

@@ -0,0 +1 @@
+export declare const GUEST_FILESYSTEM_DISPATCH_PYTHON: string;