@openclaw/openshell-sandbox 2026.9.4 → 2026.9.5

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

@@ -1,4 +1,5 @@
-import type { DirEntry } from "./types.js";
+import type { RootDirectoryListing, RootDirectoryListingOptions } from "./root-directory-list.js";
+import type { PathStat } from "./types.js";
 export type RootWalkSymlinkPolicy = "skip" | "follow-within-root";
 export type RootWalkLimitBehavior = "truncate" | "throw";
 export type RootWalkDirectoryErrorBehavior = "throw" | "skip-and-report";
@@ -24,6 +25,7 @@ export type RootWalkEntryFilter = (entry: RootWalkDataEntry) => RootWalkEntryFil
 export type RootWalkOptions = {
     maxDepth?: number;
     maxEntries?: number;
+    order?: "sorted" | "filesystem";
     symlinkPolicy: RootWalkSymlinkPolicy;
     signal?: AbortSignal;
     limitBehavior?: RootWalkLimitBehavior;
@@ -32,9 +34,8 @@ export type RootWalkOptions = {
 };
 type RootWalkCapability = {
     rootReal: string;
-    list(relativePath: string, options: {
-        withFileTypes: true;
-    }): Promise<DirEntry[]>;
+    stat(relativePath: string): Promise<PathStat>;
+    list(relativePath: string, options: RootDirectoryListingOptions): Promise<RootDirectoryListing>;
 };
 export declare function walkRoot(root: RootWalkCapability, relativePath: string, options: RootWalkOptions): AsyncGenerator<RootWalkEntry>;
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"root-walk.d.ts","sourceRoot":"","sources":["../src/root-walk.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,oBAAoB,CAAC;AAClE,MAAM,MAAM,qBAAqB,GAAG,UAAU,GAAG,OAAO,CAAC;AACzD,MAAM,MAAM,8BAA8B,GAAG,OAAO,GAAG,iBAAiB,CAAC;AACzE,MAAM,MAAM,yBAAyB,GAAG,SAAS,GAAG,MAAM,GAAG,cAAc,CAAC;AAC5E,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,WAAW,GAAG,OAAO,CAAC;AACnE,MAAM,MAAM,iBAAiB,GAAG,qBAAqB,GAAG,iBAAiB,GAAG,WAAW,CAAC;AAExF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,qBAAqB,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,aAAa,GACrB,iBAAiB,GACjB;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,CAAC,CAAA;CAAE,GACpD;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,iBAAiB,CAAC;IAAC,IAAI,EAAE,CAAC,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAE/E,MAAM,MAAM,mBAAmB,GAAG,CAAC,KAAK,EAAE,iBAAiB,KAAK,yBAAyB,CAAC;AAE1F,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,qBAAqB,CAAC;IACrC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,aAAa,CAAC,EAAE,qBAAqB,CAAC;IACtC,WAAW,CAAC,EAAE,mBAAmB,CAAC;IAClC,gBAAgB,CAAC,EAAE,8BAA8B,CAAC;CACnD,CAAC;AAEF,KAAK,kBAAkB,GAAG;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,aAAa,EAAE,IAAI,CAAA;KAAE,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;CACnF,CAAC;AAqBF,wBAAuB,QAAQ,CAC7B,IAAI,EAAE,kBAAkB,EACxB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,eAAe,GACvB,cAAc,CAAC,aAAa,CAAC,CAyH/B"}
+{"version":3,"file":"root-walk.d.ts","sourceRoot":"","sources":["../src/root-walk.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,2BAA2B,EAAE,MAAM,0BAA0B,CAAC;AAClG,OAAO,KAAK,EAAY,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGrD,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,oBAAoB,CAAC;AAClE,MAAM,MAAM,qBAAqB,GAAG,UAAU,GAAG,OAAO,CAAC;AACzD,MAAM,MAAM,8BAA8B,GAAG,OAAO,GAAG,iBAAiB,CAAC;AACzE,MAAM,MAAM,yBAAyB,GAAG,SAAS,GAAG,MAAM,GAAG,cAAc,CAAC;AAC5E,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,WAAW,GAAG,OAAO,CAAC;AACnE,MAAM,MAAM,iBAAiB,GAAG,qBAAqB,GAAG,iBAAiB,GAAG,WAAW,CAAC;AAExF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,qBAAqB,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,aAAa,GACrB,iBAAiB,GACjB;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,CAAC,CAAA;CAAE,GACpD;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,iBAAiB,CAAC;IAAC,IAAI,EAAE,CAAC,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAE/E,MAAM,MAAM,mBAAmB,GAAG,CAAC,KAAK,EAAE,iBAAiB,KAAK,yBAAyB,CAAC;AAE1F,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,QAAQ,GAAG,YAAY,CAAC;IAChC,aAAa,EAAE,qBAAqB,CAAC;IACrC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,aAAa,CAAC,EAAE,qBAAqB,CAAC;IACtC,WAAW,CAAC,EAAE,mBAAmB,CAAC;IAClC,gBAAgB,CAAC,EAAE,8BAA8B,CAAC;CACnD,CAAC;AAEF,KAAK,kBAAkB,GAAG;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC9C,IAAI,CACF,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,oBAAoB,CAAC,CAAC;CAClC,CAAC;AAqBF,wBAAuB,QAAQ,CAC7B,IAAI,EAAE,kBAAkB,EACxB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,eAAe,GACvB,cAAc,CAAC,aAAa,CAAC,CAsK/B"}

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

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { FsSafeError } from "./errors.js";
 import { resolveRootPath } from "./root-path.js";
+import { createSuppressedError } from "./suppressed-error.js";
 function validateBudget(name, value) {
     if (value === undefined)
         return Number.POSITIVE_INFINITY;
@@ -25,6 +26,9 @@ export async function* walkRoot(root, relativePath, options) {
     if (!["skip", "follow-within-root"].includes(options.symlinkPolicy)) {
         throw new TypeError(`invalid root walk symlink policy: ${String(options.symlinkPolicy)}`);
     }
+    if (options.order !== undefined && !["sorted", "filesystem"].includes(options.order)) {
+        throw new TypeError(`invalid root walk order: ${String(options.order)}`);
+    }
     if (options.limitBehavior !== undefined &&
         !["truncate", "throw"].includes(options.limitBehavior)) {
         throw new TypeError(`invalid root walk limit behavior: ${String(options.limitBehavior)}`);
@@ -38,6 +42,12 @@ export async function* walkRoot(root, relativePath, options) {
     const visitedDirectories = new Set();
     let examined = 0;
     let truncated = false;
+    const admitEntry = () => {
+        if (examined >= maxEntries)
+            return false;
+        examined += 1;
+        return true;
+    };
     const onLimit = (atPath) => {
         if ((options.limitBehavior ?? "truncate") === "throw") {
             throw new FsSafeError("too-large", `root walk budget exceeded at ${atPath || "."}`);
@@ -45,9 +55,15 @@ export async function* walkRoot(root, relativePath, options) {
         truncated = true;
         return limitEntry(atPath);
     };
+    const onDirectoryError = (directory, error) => {
+        // Rethrow cancellation with any disposal failure already attached.
+        if (options.signal?.aborted || (options.onDirectoryError ?? "throw") === "throw")
+            throw error;
+        return { relativePath: directory, kind: "directory-error", size: 0, error };
+    };
     async function* visit(directory, depth) {
         options.signal?.throwIfAborted();
-        let entries;
+        let listing;
         try {
             const resolvedDirectory = await resolveRootPath({
                 absolutePath: path.resolve(root.rootReal, directory),
@@ -67,66 +83,100 @@ export async function* walkRoot(root, relativePath, options) {
                 .relative(root.rootReal, resolvedDirectory.canonicalPath)
                 .split(path.sep)
                 .join(path.posix.sep);
-            entries = await root.list(listingDirectory, { withFileTypes: true });
+            listing = await root.list(listingDirectory, {
+                order: options.order ?? "sorted",
+                signal: options.signal,
+                snapshot: maxEntries === Number.POSITIVE_INFINITY,
+                admitEntry,
+            });
         }
         catch (error) {
-            // Cancellation is never a recoverable directory read failure.
-            options.signal?.throwIfAborted();
-            if ((options.onDirectoryError ?? "throw") === "throw")
-                throw error;
-            yield { relativePath: directory, kind: "directory-error", size: 0, error };
+            yield onDirectoryError(directory, error);
             return;
         }
-        options.signal?.throwIfAborted();
-        for (const entry of entries) {
-            options.signal?.throwIfAborted();
-            const child = directory
-                ? path.posix.join(directory.split(path.sep).join(path.posix.sep), entry.name)
-                : entry.name;
-            if (examined >= maxEntries) {
-                yield onLimit(child);
-                return;
-            }
-            examined += 1;
-            let kind = entryKind(entry);
-            let size = entry.size;
-            if (kind === "symlink") {
-                if (options.symlinkPolicy === "skip") {
+        // A thrown undefined still needs to be retained if closing also fails.
+        let failed = false;
+        let operationError;
+        try {
+            const relativeDirectory = directory.split(path.sep).join(path.posix.sep);
+            while (true) {
+                let next;
+                try {
+                    next = await listing.next();
+                    options.signal?.throwIfAborted();
+                }
+                catch (error) {
+                    yield onDirectoryError(directory, error);
+                    return;
+                }
+                if (next === undefined)
+                    return;
+                const name = next.kind === "entry" ? next.entry.name : next.name;
+                const child = directory
+                    ? path.posix.join(relativeDirectory, name)
+                    : name;
+                if (next.kind === "limit") {
+                    yield onLimit(child);
+                    return;
+                }
+                const entry = next.entry;
+                let kind = entryKind(entry);
+                let size = entry.size;
+                if (kind === "symlink") {
+                    if (options.symlinkPolicy === "skip") {
+                        continue;
+                    }
+                    const resolved = await resolveRootPath({
+                        absolutePath: path.resolve(root.rootReal, child),
+                        rootPath: root.rootReal,
+                        rootCanonicalPath: root.rootReal,
+                        boundaryLabel: "root walk",
+                    });
+                    if (!resolved.exists) {
+                        continue;
+                    }
+                    const target = await root.stat(path.relative(root.rootReal, resolved.canonicalPath));
+                    kind = target.isDirectory ? "directory" : target.isFile ? "file" : "other";
+                    size = target.size;
+                }
+                const walkEntry = { relativePath: child, kind, size };
+                const filterResult = options.entryFilter?.(walkEntry) ?? "include";
+                if (!["include", "skip", "skip-subtree"].includes(filterResult)) {
+                    throw new TypeError(`invalid root walk entryFilter result: ${String(filterResult)}`);
+                }
+                if (filterResult === "include") {
+                    yield walkEntry;
+                }
+                if (kind !== "directory") {
                     continue;
                 }
-                const resolved = await resolveRootPath({
-                    absolutePath: path.resolve(root.rootReal, child),
-                    rootPath: root.rootReal,
-                    rootCanonicalPath: root.rootReal,
-                    boundaryLabel: "root walk",
-                });
-                if (!resolved.exists) {
+                if (filterResult === "skip-subtree") {
                     continue;
                 }
-                kind = resolved.kind === "directory" ? "directory" : resolved.kind === "file" ? "file" : "other";
-                size = entry.size;
-            }
-            const walkEntry = { relativePath: child, kind, size };
-            const filterResult = options.entryFilter?.(walkEntry) ?? "include";
-            if (!["include", "skip", "skip-subtree"].includes(filterResult)) {
-                throw new TypeError(`invalid root walk entryFilter result: ${String(filterResult)}`);
-            }
-            if (filterResult === "include") {
-                yield walkEntry;
-            }
-            if (kind !== "directory") {
-                continue;
+                if (depth >= maxDepth) {
+                    yield onLimit(child);
+                    return;
+                }
+                yield* visit(child, depth + 1);
+                if (truncated)
+                    return;
             }
-            if (filterResult === "skip-subtree") {
-                continue;
+        }
+        catch (error) {
+            failed = true;
+            operationError = error;
+            throw error;
+        }
+        finally {
+            try {
+                await listing[Symbol.asyncDispose]();
             }
-            if (depth >= maxDepth) {
-                yield onLimit(child);
-                return;
+            catch (closeError) {
+                if (failed) {
+                    throw createSuppressedError(closeError, operationError, "directory walk and close both failed");
+                }
+                throw closeError;
             }
-            yield* visit(child, depth + 1);
-            if (truncated)
-                return;
         }
     }
     yield* visit(relativePath, 0);

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

@@ -0,0 +1,68 @@
+import type { BigIntStats } from "node:fs";
+import { type DenyMutationPolicy } from "./deny-mutations.js";
+import { type AnyAsyncDirectoryGuard } from "./directory-guard.js";
+import type { PinnedWriteMutationAdmission } from "./pinned-write.js";
+import type { RootContext } from "./root-context.js";
+import { resolvePathInRoot } from "./root-context.js";
+import { type MutationSymlinkPolicy } from "./root-symlink-policy.js";
+import { type PreparedRootWriteParent } from "./root-write-complete-parent.js";
+export type PinnedWriteTarget = Readonly<{
+    rootReal: string;
+    targetPath: string;
+    relativeParentPath: string;
+    basename: string;
+    mode: number;
+    mutationAdmission?: PinnedWriteMutationAdmission;
+}>;
+export type GuardedWritePath = Awaited<ReturnType<typeof resolvePathInRoot>>;
+export type SelectedRootWriteTargetAdmission = Readonly<{
+    authorize(selectedTargetPath: string): Promise<void>;
+}>;
+export type GuardedRootWriteTarget = Readonly<{
+    resolvedPath: GuardedWritePath;
+    targetPath: string;
+    mutationAdmission?: PinnedWriteMutationAdmission;
+    selectedTargetAdmission?: SelectedRootWriteTargetAdmission;
+}>;
+export type RootWritePathSelection = Readonly<{
+    mutationAdmission: PinnedWriteMutationAdmission;
+    selectedTargetAdmission: SelectedRootWriteTargetAdmission;
+    operationTargetPath: string;
+    selectedPath: string;
+    parentGuard: AnyAsyncDirectoryGuard;
+}>;
+export type RetainedRootWriteSelection = RootWritePathSelection & Readonly<{
+    identity: Readonly<Pick<BigIntStats, "dev" | "ino">>;
+}>;
+export declare function retainRootWriteSelection(owner: object, selection: RetainedRootWriteSelection): void;
+export declare function createRootWriteSelectionForFd(selection: RootWritePathSelection, fd: number): RetainedRootWriteSelection;
+export declare function takeRootWriteSelection(owner: object): RetainedRootWriteSelection | undefined;
+export declare function assertRootWritePathSelectionSync(root: RootContext, selection: RootWritePathSelection): void;
+export declare function assertRootWriteSelectionSync(root: RootContext, selection: RetainedRootWriteSelection, verifyBinding: boolean, fd?: number): void;
+export declare function prepareRootWritePathSelection(params: Omit<RootWritePathSelection, "parentGuard"> & Readonly<{
+    preparedParent?: PreparedRootWriteParent;
+}>): Promise<RootWritePathSelection>;
+export declare function prepareGuardedRootWritePathSelection(guarded: {
+    mutationAdmission?: PinnedWriteMutationAdmission;
+    selectedTargetAdmission?: SelectedRootWriteTargetAdmission;
+} | undefined, selectedPath: string, operationTargetPath?: string, preparedParent?: PreparedRootWriteParent): Promise<RootWritePathSelection | undefined>;
+export declare function refreshRootWritePathSelection(selection: RootWritePathSelection): Promise<void>;
+/**
+ * Re-authorize a retained shared-JavaScript destination without recapturing
+ * either its pathname binding or its exact parent fence.
+ */
+export declare function refreshRootWriteSelection(root: RootContext, selection: RetainedRootWriteSelection, verifyBinding: boolean, fd?: number): Promise<void>;
+export declare function refreshRetainedRootWriteAdmission(root: RootContext, selection: RetainedRootWriteSelection, verifyBinding: boolean, fd?: number): Promise<void>;
+type GuardedWritePathOptions = {
+    relativePath: string;
+    denyMutations?: DenyMutationPolicy;
+    mutationSymlinks?: MutationSymlinkPolicy;
+    allowFinalSymlink?: boolean;
+    protectDeniedAncestors?: boolean;
+    shouldAssertNoPathAlias?: (resolved: GuardedWritePath) => Promise<boolean> | boolean;
+};
+export declare function resolveGuardedWritePathInRoot(root: RootContext, params: GuardedWritePathOptions): Promise<GuardedWritePath>;
+export declare function resolveGuardedWriteTargetInRoot(root: RootContext, params: GuardedWritePathOptions): Promise<GuardedRootWriteTarget>;
+export declare function resolvePinnedWriteTargetInRoot(root: RootContext, relativePath: string, requestedMode?: number, denyMutations?: DenyMutationPolicy, overwrite?: boolean, mutationSymlinks?: MutationSymlinkPolicy): Promise<PinnedWriteTarget>;
+export {};
+//# sourceMappingURL=root-write-admission.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/root-write-admission.d.ts.map

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

package/node_modules/@openclaw/fs-safe/dist/root-write-admission.js

@@ -0,0 +1,322 @@
+import fsSync from "node:fs";
+import path from "node:path";
+import { assertMutationNotDenied } from "./deny-mutations.js";
+import { assertAsyncDirectoryGuard, assertSyncDirectoryGuard, createAsyncDirectoryGuard, } from "./directory-guard.js";
+import { FsSafeError } from "./errors.js";
+import { isNotFoundPathError } from "./path.js";
+import { assertNoPathAliasEscape } from "./path-policy.js";
+import { preparePinnedWriteMutationAdmission, snapshotPinnedMutationPolicy, } from "./pinned-mutation-admission.js";
+import { admitPathInsideRoot } from "./root-boundary.js";
+import { resolvePathInRoot } from "./root-context.js";
+import { hardlinkedPathNotAllowedError, outsideWorkspaceError } from "./root-errors.js";
+import { inheritWriteTargetMode } from "./root-write-mode.js";
+import { mutationSymlinkResolution, } from "./root-symlink-policy.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
+import { realpathSync } from "./realpath.js";
+import { getFsSafeTestHooks } from "./test-hooks.js";
+import { assertPreparedRootWriteParentCurrent, } from "./root-write-complete-parent.js";
+const retainedRootWriteSelections = new WeakMap();
+export function retainRootWriteSelection(owner, selection) {
+    retainedRootWriteSelections.set(owner, selection);
+}
+export function createRootWriteSelectionForFd(selection, fd) {
+    const stat = inspectFileIdentitySync(() => fsSync.fstatSync(fd, { bigint: true }));
+    return Object.freeze({
+        ...selection,
+        identity: Object.freeze({ dev: stat.dev, ino: stat.ino }),
+    });
+}
+export function takeRootWriteSelection(owner) {
+    const selection = retainedRootWriteSelections.get(owner);
+    retainedRootWriteSelections.delete(owner);
+    return selection;
+}
+function writeSelectionChanged(cause) {
+    return new FsSafeError("path-mismatch", "write target changed during operation", {
+        cause: cause instanceof Error ? cause : undefined,
+    });
+}
+function inspectRegularSelectionPath(pathname, expected, follow) {
+    let observed;
+    try {
+        observed = inspectFileIdentitySync(() => follow
+            ? fsSync.statSync(pathname, { bigint: true })
+            : fsSync.lstatSync(pathname, { bigint: true }), expected);
+    }
+    catch (error) {
+        if (error instanceof FsSafeError && error.code === "path-mismatch")
+            throw error;
+        throw writeSelectionChanged(error);
+    }
+    if ((!follow && observed.isSymbolicLink()) || !observed.isFile()) {
+        throw writeSelectionChanged();
+    }
+    if (observed.nlink > 1n)
+        throw hardlinkedPathNotAllowedError();
+    return observed;
+}
+function sameNormalizedPathSpelling(left, right) {
+    // Windows can expose case-sensitive directories, so normalize separators
+    // and roots without using path.relative's case-folding comparison.
+    return path.resolve(left) === path.resolve(right);
+}
+function inspectSelectionBindingSync(root, selection, fd) {
+    inspectRegularSelectionPath(selection.selectedPath, selection.identity, false);
+    if (!sameNormalizedPathSpelling(selection.operationTargetPath, selection.selectedPath)) {
+        let operationRealPath;
+        try {
+            operationRealPath = realpathSync.native(selection.operationTargetPath);
+        }
+        catch (error) {
+            throw writeSelectionChanged(error);
+        }
+        const admitted = admitPathInsideRoot({
+            rootPath: root.rootReal,
+            candidatePath: operationRealPath,
+            rootIdentity: root.rootIdentity,
+        });
+        if (!admitted)
+            throw outsideWorkspaceError();
+        inspectRegularSelectionPath(admitted.path, selection.identity, true);
+    }
+    if (fd !== undefined) {
+        try {
+            inspectFileIdentitySync(() => fsSync.fstatSync(fd, { bigint: true }), selection.identity);
+        }
+        catch (error) {
+            if (error instanceof FsSafeError && error.code === "path-mismatch")
+                throw error;
+            throw writeSelectionChanged(error);
+        }
+    }
+}
+export function assertRootWritePathSelectionSync(root, selection) {
+    if (!sameNormalizedPathSpelling(selection.operationTargetPath, selection.selectedPath)) {
+        let operationRealPath;
+        try {
+            operationRealPath = realpathSync.native(selection.operationTargetPath);
+        }
+        catch (error) {
+            throw writeSelectionChanged(error);
+        }
+        const admitted = admitPathInsideRoot({
+            rootPath: root.rootReal,
+            candidatePath: operationRealPath,
+            rootIdentity: root.rootIdentity,
+        });
+        if (!admitted)
+            throw outsideWorkspaceError();
+        const selected = inspectRegularSelectionPath(selection.selectedPath, undefined, false);
+        inspectRegularSelectionPath(admitted.path, selected, true);
+    }
+    assertSyncDirectoryGuard(selection.parentGuard);
+}
+export function assertRootWriteSelectionSync(root, selection, verifyBinding, fd) {
+    if (verifyBinding)
+        inspectSelectionBindingSync(root, selection, fd);
+    assertSyncDirectoryGuard(selection.parentGuard);
+}
+async function authorizeRootWritePathSelection(selection, afterAwait) {
+    const selectedAdmissionPending = !sameNormalizedPathSpelling(selection.operationTargetPath, selection.selectedPath);
+    await selection.mutationAdmission.authorize(Object.freeze({
+        targetPath: selection.operationTargetPath,
+        mutationPath: selection.operationTargetPath,
+        phase: "parent",
+    }));
+    afterAwait?.(selectedAdmissionPending);
+    if (selectedAdmissionPending) {
+        await selection.selectedTargetAdmission.authorize(selection.selectedPath);
+        afterAwait?.(false);
+    }
+}
+export async function prepareRootWritePathSelection(params) {
+    const { preparedParent, ...selectionParams } = params;
+    if (preparedParent && (!sameNormalizedPathSpelling(preparedParent.operationTargetPath, params.operationTargetPath) ||
+        !sameNormalizedPathSpelling(preparedParent.parentGuard.dir, path.dirname(params.operationTargetPath))))
+        throw writeSelectionChanged();
+    const selection = Object.freeze({
+        ...selectionParams,
+        parentGuard: preparedParent?.parentGuard ??
+            await createAsyncDirectoryGuard(path.dirname(params.selectedPath), { bigint: true }),
+    });
+    await authorizeRootWritePathSelection(selection, preparedParent
+        ? (selectedAdmissionPending) => assertPreparedRootWriteParentCurrent(preparedParent, !selectedAdmissionPending)
+        : undefined);
+    if (preparedParent) {
+        if (!sameNormalizedPathSpelling(preparedParent.selectedTargetPath, params.selectedPath)) {
+            throw writeSelectionChanged();
+        }
+    }
+    else {
+        await assertAsyncDirectoryGuard(selection.parentGuard);
+    }
+    return selection;
+}
+export async function prepareGuardedRootWritePathSelection(guarded, selectedPath, operationTargetPath = selectedPath, preparedParent) {
+    if (!guarded?.mutationAdmission)
+        return undefined;
+    if (!guarded.selectedTargetAdmission)
+        throw writeSelectionChanged();
+    return await prepareRootWritePathSelection({
+        mutationAdmission: guarded.mutationAdmission,
+        selectedTargetAdmission: guarded.selectedTargetAdmission,
+        operationTargetPath,
+        selectedPath,
+        preparedParent,
+    });
+}
+export async function refreshRootWritePathSelection(selection) {
+    await authorizeRootWritePathSelection(selection);
+    await assertAsyncDirectoryGuard(selection.parentGuard);
+}
+/**
+ * Re-authorize a retained shared-JavaScript destination without recapturing
+ * either its pathname binding or its exact parent fence.
+ */
+export async function refreshRootWriteSelection(root, selection, verifyBinding, fd) {
+    await authorizeRootWritePathSelection(selection);
+    if (verifyBinding)
+        inspectSelectionBindingSync(root, selection, fd);
+    await assertAsyncDirectoryGuard(selection.parentGuard);
+}
+export async function refreshRetainedRootWriteAdmission(root, selection, verifyBinding, fd) {
+    await getFsSafeTestHooks()?.beforePinnedWriteParentAdmission?.(selection.operationTargetPath);
+    await refreshRootWriteSelection(root, selection, verifyBinding, fd);
+}
+export async function resolveGuardedWritePathInRoot(root, params) {
+    const resolvedPath = await resolvePathInRoot(root, params.relativePath, {
+        aliasErrorCode: "path-alias",
+        rejectAmbiguousParents: true,
+        allowFinalSymlink: params.allowFinalSymlink,
+        ...mutationSymlinkResolution(params.mutationSymlinks),
+    });
+    await assertMutationNotDenied(resolvedPath.resolved, params.denyMutations, params.protectDeniedAncestors ? { protectAncestors: true } : undefined);
+    if (await (params.shouldAssertNoPathAlias?.(resolvedPath) ?? true)) {
+        try {
+            await assertNoPathAliasEscape({
+                absolutePath: resolvedPath.resolved,
+                rootPath: resolvedPath.rootReal,
+                boundaryLabel: "root",
+            });
+        }
+        catch (error) {
+            throw new FsSafeError("path-alias", "path alias escape blocked", {
+                cause: error instanceof Error ? error : undefined,
+            });
+        }
+    }
+    return resolvedPath;
+}
+export async function resolveGuardedWriteTargetInRoot(root, params) {
+    const policy = params.denyMutations === undefined && params.mutationSymlinks === undefined
+        ? undefined
+        : snapshotPinnedMutationPolicy(params.denyMutations, params.mutationSymlinks);
+    const resolveCurrent = async () => await resolveGuardedWritePathInRoot(root, {
+        ...params,
+        denyMutations: policy?.denyMutations,
+        mutationSymlinks: policy?.mutationSymlinks,
+    });
+    const resolvedPath = await resolveCurrent();
+    if (!policy)
+        return { resolvedPath, targetPath: resolvedPath.resolved };
+    const relativeParent = path.relative(resolvedPath.rootReal, path.dirname(resolvedPath.resolved));
+    const prepared = await preparePinnedWriteMutationAdmission({
+        rootReal: resolvedPath.rootReal,
+        rootWithSep: resolvedPath.rootWithSep,
+        rootIdentity: root.rootIdentity,
+        resolvedTargetPath: resolvedPath.resolved,
+        originalPath: params.relativePath,
+        defaultRelativeParentPath: relativeParent
+            ? relativeParent.split(path.sep).join(path.posix.sep)
+            : "",
+        policy,
+        resolveCurrent,
+    });
+    const selectedTargetAdmission = Object.freeze({
+        async authorize(selectedTargetPath) {
+            const admitted = admitPathInsideRoot({
+                rootPath: root.rootReal,
+                candidatePath: selectedTargetPath,
+                rootIdentity: root.rootIdentity,
+            });
+            if (!admitted)
+                throw outsideWorkspaceError();
+            await resolveGuardedWritePathInRoot(root, {
+                relativePath: admitted.relativePath,
+                denyMutations: policy.denyMutations,
+                mutationSymlinks: policy.mutationSymlinks,
+            });
+        },
+    });
+    const targetPath = path.join(resolvedPath.rootReal, ...prepared.relativeParentPath.split("/").filter(Boolean), path.basename(resolvedPath.resolved));
+    return {
+        resolvedPath,
+        targetPath,
+        mutationAdmission: prepared.mutationAdmission,
+        selectedTargetAdmission,
+    };
+}
+export async function resolvePinnedWriteTargetInRoot(root, relativePath, requestedMode, denyMutations, overwrite = true, mutationSymlinks) {
+    // Snapshot mutable caller-owned policy before preflight so every admission
+    // in this operation authorizes the same rules.
+    const policy = denyMutations === undefined && mutationSymlinks === undefined
+        ? undefined
+        : snapshotPinnedMutationPolicy(denyMutations, mutationSymlinks);
+    const resolveCurrent = policy
+        ? async () => await resolveGuardedWritePathInRoot(root, {
+            relativePath,
+            denyMutations: policy.denyMutations,
+            mutationSymlinks: policy.mutationSymlinks,
+        })
+        : undefined;
+    const { rootReal, rootWithSep, resolved } = resolveCurrent
+        ? await resolveCurrent()
+        : await resolveGuardedWritePathInRoot(root, { relativePath });
+    const relativeResolved = path.relative(rootReal, resolved);
+    if (path.isAbsolute(relativeResolved))
+        throw outsideWorkspaceError();
+    const relativePosix = relativeResolved
+        ? relativeResolved.split(path.sep).join(path.posix.sep)
+        : "";
+    const basename = path.posix.basename(relativePosix);
+    if (!basename || basename === "." || basename === "/") {
+        throw new FsSafeError("invalid-path", "invalid target path");
+    }
+    if (!overwrite) {
+        try {
+            const existing = fsSync.statSync(resolved);
+            if (!existing.isFile())
+                throw new FsSafeError("not-file", "not a file");
+            if (existing.nlink > 1)
+                throw hardlinkedPathNotAllowedError();
+            throw new FsSafeError("already-exists", "file already exists");
+        }
+        catch (error) {
+            if (!isNotFoundPathError(error))
+                throw error;
+        }
+    }
+    const mode = overwrite
+        ? await inheritWriteTargetMode({
+            targetPath: resolved,
+            rootWithSep,
+            rootIdentity: root.rootIdentity,
+            requestedMode,
+        })
+        : requestedMode ?? 0o600;
+    let relativeParentPath = path.posix.dirname(relativePosix) === "." ? "" : path.posix.dirname(relativePosix);
+    let mutationAdmission;
+    if (policy) {
+        ({ relativeParentPath, mutationAdmission } = await preparePinnedWriteMutationAdmission({
+            rootReal,
+            rootWithSep,
+            rootIdentity: root.rootIdentity,
+            resolvedTargetPath: resolved,
+            originalPath: relativePath,
+            defaultRelativeParentPath: relativeParentPath,
+            policy,
+            resolveCurrent: resolveCurrent,
+        }));
+    }
+    return { rootReal, targetPath: resolved, relativeParentPath, basename, mode, mutationAdmission };
+}

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

@@ -0,0 +1,13 @@
+import { type RootBoundaryIdentity } from "./root-boundary.js";
+export declare function assertRootFallbackWritePath(expected: string | undefined, actual: string): void;
+export declare function withRootFallbackCompatibilityLock<T>(params: {
+    rootPath: string;
+    targetPath: string;
+    rootIdentity?: RootBoundaryIdentity;
+    assertBeforeMutation?: () => void;
+}, run: (binding: {
+    targetPath: string;
+    relativePath: string;
+    assertBeforeMutation: () => void;
+}) => Promise<T>): Promise<T>;
+//# sourceMappingURL=root-write-compatibility.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/root-write-compatibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-write-compatibility.d.ts","sourceRoot":"","sources":["../src/root-write-compatibility.ts"],"names":[],"mappings":"AAIA,OAAO,EAAuB,KAAK,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AA6CpF,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAI9F;AAED,wBAAsB,iCAAiC,CAAC,CAAC,EACvD,MAAM,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,oBAAoB,CAAC;IAAC,oBAAoB,CAAC,EAAE,MAAM,IAAI,CAAA;CAAE,EACxH,GAAG,EAAE,CAAC,OAAO,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,oBAAoB,EAAE,MAAM,IAAI,CAAA;CAAE,KAAK,OAAO,CAAC,CAAC,CAAC,GAC3G,OAAO,CAAC,CAAC,CAAC,CAkBZ"}