@openclaw/openshell-sandbox 2026.9.5 → 2026.9.6

package/node_modules/@openclaw/fs-safe/dist/file-store-boundary.js

@@ -1,26 +1,23 @@
-import syncFs, {} from "node:fs";
+import syncFs from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { createByteLimitTransform } from "./bounded-read-stream.js";
-import { normalizeMaxBytes } from "./byte-budget.js";
 import { pipeline } from "node:stream/promises";
 import { FsSafeError } from "./errors.js";
 import { assertSyncStoreDirectoryReceipt, ensureSyncStoreDirectory, } from "./file-store-sync-directory.js";
-import { isPathInside } from "./path.js";
+import { isPathInside, splitSafeRelativePath } from "./path.js";
 import { resolveOpenedFileRealPathForHandle, root } from "./root.js";
 import { ensureTrailingSep } from "./root-context.js";
 import { RootHandle } from "./root-impl.js";
 import { prepareSecretFileWrite } from "./secret-file.js";
 import { resolveSecureTempRoot } from "./secure-temp-dir.js";
 import { recursiveMkdirPath } from "./recursive-mkdir-path.js";
-import { assertNoWindowsPathAlias, pathForWindowsFilesystem } from "./windows-path-alias.js";
-function parentRelativePath(relativePath) {
-    const parent = path.posix.dirname(relativePath);
-    return parent === "." ? "" : parent;
-}
+import { readRegularFile } from "./regular-file.js";
+import { errorCauseOptions } from "./root-errors.js";
+import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
 export async function ensureParentInRoot(scopedRoot, relativePath, mode) {
-    const parent = parentRelativePath(relativePath);
-    if (!parent) {
+    const parent = path.posix.dirname(relativePath);
+    if (parent === ".") {
         return;
     }
     await scopedRoot.mkdir(parent);
@@ -28,10 +25,9 @@ export async function ensureParentInRoot(scopedRoot, relativePath, mode) {
 }
 export async function openWritableStoreRoot(params) {
     assertNoWindowsPathAlias(params.rootDir, "filesystem", "store root uses a Windows filesystem namespace alias");
-    const maxBytes = normalizeMaxBytes(params.maxBytes);
     await fs.mkdir(recursiveMkdirPath(params.rootDir), { recursive: true, mode: params.dirMode });
     await fs.chmod(params.rootDir, params.dirMode).catch(() => undefined);
-    return await root(params.rootDir, { hardlinks: "reject", maxBytes });
+    return await root(params.rootDir, { hardlinks: "reject", maxBytes: params.maxBytes });
 }
 export async function openPrivateStoreLockRoot(params) {
     const { parentGuard } = await prepareSecretFileWrite(params);
@@ -66,15 +62,8 @@ async function chmodDirectoryInRootBestEffort(scopedRoot, relativePath, mode) {
         await handle.close().catch(() => undefined);
     }
 }
-function createMaxBytesTransform(maxBytes) {
-    const limit = normalizeMaxBytes(maxBytes);
-    if (limit === undefined) {
-        return undefined;
-    }
-    return createByteLimitTransform(limit, () => new FsSafeError("too-large", `file exceeds maximum size of ${limit} bytes`));
-}
 export async function writeStreamToTempSource(params) {
-    const maxBytes = normalizeMaxBytes(params.maxBytes);
+    const maxBytes = params.maxBytes;
     const tempRoot = resolveSecureTempRoot({
         fallbackPrefix: "fs-safe-file-store",
         unsafeFallbackLabel: "file store temp dir",
@@ -90,7 +79,7 @@ export async function writeStreamToTempSource(params) {
         writable.once("close", () => {
             handleClosedByStream = true;
         });
-        const limiter = createMaxBytesTransform(maxBytes);
+        const limiter = maxBytes === undefined ? undefined : createByteLimitTransform(maxBytes, () => new FsSafeError("too-large", `file exceeds maximum size of ${maxBytes} bytes`));
         if (limiter) {
             await pipeline(params.stream, limiter, writable);
         }
@@ -116,13 +105,6 @@ export async function writeStreamToTempSource(params) {
         throw err;
     }
 }
-export function assertSyncDirectoryGuard(guard) {
-    assertSyncStoreDirectoryReceipt({
-        dir: guard.dir,
-        realPath: guard.realPath,
-        exactStat: guard.exactStat,
-    });
-}
 export function ensureParentSync(params) {
     assertNoWindowsPathAlias(params.rootDir, "filesystem", "store root uses a Windows filesystem namespace alias");
     assertNoWindowsPathAlias(params.filePath, "filesystem", "store path uses a Windows filesystem namespace alias");
@@ -134,13 +116,62 @@ export function ensureParentSync(params) {
     });
 }
 export function ensureStoreDirectorySync(params) {
-    const receipt = ensureSyncStoreDirectory(params);
-    const guard = {
-        dir: receipt.dir,
-        realPath: receipt.realPath,
-        stat: syncFs.lstatSync(pathForWindowsFilesystem(receipt.dir)),
-        exactStat: receipt.exactStat,
-    };
-    assertSyncDirectoryGuard(guard);
+    const guard = ensureSyncStoreDirectory(params);
+    assertSyncStoreDirectoryReceipt(guard);
     return guard;
 }
+export function assertRelativePath(relativePath) {
+    const raw = relativePath.trim();
+    if (!raw || raw !== relativePath) {
+        throw new FsSafeError("invalid-path", "store key must be non-empty and unpadded");
+    }
+    const segments = splitSafeRelativePath(raw);
+    if (segments.length === 0 ||
+        segments.join("/") !== raw ||
+        raw.normalize("NFC") !== raw ||
+        segments.some((segment) => /[ .]$/u.test(segment))) {
+        throw new FsSafeError("invalid-path", "store key must use one canonical relative spelling");
+    }
+    return raw;
+}
+export function resolveStorePath(rootDir, relativePath) {
+    const key = assertRelativePath(relativePath);
+    // FileStore constructors snapshot an absolute root before this helper runs.
+    // Do not re-resolve it: Node drops the trailing separator from an exact
+    // Windows namespace drive root such as `\\?\C:\`.
+    const root = path.isAbsolute(rootDir) ? rootDir : path.resolve(rootDir);
+    // The immutable key already passed segment validation; keep the containment check.
+    const target = path.resolve(root, key);
+    if (!isPathInside(root, target)) {
+        throw new FsSafeError("outside-workspace", "relative path escapes root");
+    }
+    return target;
+}
+// Store operation boundaries admit the primitive limit before reaching this helper.
+export function assertFileStoreMaxBytes(size, limit) {
+    if (limit !== undefined && size > limit) {
+        throw new FsSafeError("too-large", `file exceeds maximum size of ${limit} bytes`);
+    }
+}
+export async function readFileStoreCopySource(params) {
+    assertNoWindowsPathAlias(params.sourcePath, "filesystem", "source path uses a Windows filesystem namespace alias");
+    const sourceStat = syncFs.lstatSync(params.sourcePath);
+    if (sourceStat.isSymbolicLink() || !sourceStat.isFile()) {
+        throw new FsSafeError("not-file", "source path is not a file");
+    }
+    assertFileStoreMaxBytes(sourceStat.size, params.maxBytes);
+    try {
+        return (await readRegularFile({ filePath: params.sourcePath, maxBytes: params.maxBytes }))
+            .buffer;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes("regular file") || message.includes("not a regular file")) {
+            throw new FsSafeError("not-file", "source path is not a file", errorCauseOptions(error));
+        }
+        if (message.includes(`exceeds ${params.maxBytes} bytes`)) {
+            throw new FsSafeError("too-large", `file exceeds maximum size of ${params.maxBytes} bytes`, errorCauseOptions(error));
+        }
+        throw error;
+    }
+}

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

@@ -9,4 +9,3 @@ export declare function pruneExpiredStoreEntries(params: {
     dirMode: number;
     options: FileStorePruneOptions;
 }): Promise<void>;
-//# sourceMappingURL=file-store-prune.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/file-store-prune.js

@@ -6,7 +6,11 @@ import { isPathInside } from "./path.js";
 import { realpathSync } from "./realpath.js";
 import { recursiveMkdirPath } from "./recursive-mkdir-path.js";
 import { root } from "./root.js";
+import { nonrecursiveRemovalKind } from "./root-remove.js";
 import { getFsSafeTestHooks } from "./test-hooks.js";
+const REMOVE_EMPTY_DIRECTORY_OPTIONS = Object.freeze({
+    [nonrecursiveRemovalKind]: "directory",
+});
 export async function pruneExpiredStoreEntries(params) {
     const now = Date.now();
     const recursive = params.options.recursive ?? false;
@@ -70,7 +74,7 @@ export async function pruneExpiredStoreEntries(params) {
                     await assertRootGuard();
                     // Keep empty-dir pruning on the same root-bounded remove path as files;
                     // the Root fallback handles empty directories without recursive delete.
-                    await scopedRoot.remove(relativePath).catch(() => undefined);
+                    await scopedRoot.remove(relativePath, REMOVE_EMPTY_DIRECTORY_OPTIONS).catch(() => undefined);
                 }
                 continue;
             }

package/node_modules/@openclaw/fs-safe/dist/file-store-sync-directory.d.ts

@@ -13,4 +13,3 @@ export declare function ensureSyncStoreDirectory(params: {
 }): SyncStoreDirectoryReceipt;
 export declare function assertSyncStoreDirectoryReceipt(receipt: SyncStoreDirectoryReceipt): void;
 export {};
-//# sourceMappingURL=file-store-sync-directory.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/file-store-sync-directory.js

@@ -11,7 +11,9 @@ function changedStoreDirectory(messagePrefix, cause) {
     return new FsSafeError("outside-workspace", `${messagePrefix} directory escapes root`, { cause });
 }
 function storeDirectoryRealPath(dir) {
-    const realPath = realpathSync(pathForWindowsFilesystem(dir));
+    const operationPath = pathForWindowsFilesystem(dir);
+    const realPath = process.platform === "win32"
+        ? realpathSync(operationPath) : realpathSync.native(operationPath);
     assertNoWindowsPathAlias(realPath, "filesystem");
     return realPath;
 }
@@ -26,111 +28,6 @@ function inspectStoreDirectory(params) {
         return stat;
     }, params.expected);
 }
-function observeStoreDirectory(params) {
-    return {
-        dir: params.dir,
-        stat: inspectStoreDirectory(params),
-    };
-}
-function inspectReceiptCurrent(receipt, messagePrefix, root) {
-    try {
-        const stat = inspectStoreDirectory({
-            dir: receipt.dir,
-            expected: receipt.stat,
-            messagePrefix,
-            root,
-        });
-        if (stat.dev !== receipt.stat.dev || stat.ino !== receipt.stat.ino) {
-            throw changedStoreDirectory(messagePrefix);
-        }
-        return stat;
-    }
-    catch (error) {
-        if (error instanceof FsSafeError && error.code === "outside-workspace")
-            throw error;
-        throw changedStoreDirectory(messagePrefix, error);
-    }
-}
-function assertRootCurrent(rootReceipt, rootReal, messagePrefix) {
-    const stat = inspectReceiptCurrent(rootReceipt, messagePrefix, true);
-    try {
-        if (storeDirectoryRealPath(rootReceipt.dir) !== rootReal) {
-            throw changedStoreDirectory(messagePrefix);
-        }
-    }
-    catch (error) {
-        if (error instanceof FsSafeError && error.code === "outside-workspace")
-            throw error;
-        throw changedStoreDirectory(messagePrefix, error);
-    }
-    return stat;
-}
-function assertAdmittedEdgeCurrent(receipts, rootReal, messagePrefix) {
-    const rootReceipt = receipts[0];
-    const targetIndex = receipts.length - 1;
-    const targetReceipt = receipts[targetIndex];
-    if (!rootReceipt || !targetReceipt) {
-        throw new FsSafeError("helper-failed", "store directory receipt is missing");
-    }
-    const rootStat = assertRootCurrent(rootReceipt, rootReal, messagePrefix);
-    if (targetIndex === 0)
-        return rootStat;
-    const parent = receipts[targetIndex - 1];
-    if (!parent)
-        throw new FsSafeError("helper-failed", "store directory receipt is missing");
-    if (targetIndex > 1)
-        inspectReceiptCurrent(parent, messagePrefix, false);
-    const targetStat = inspectReceiptCurrent(targetReceipt, messagePrefix, false);
-    if (path.dirname(targetReceipt.dir) !== parent.dir) {
-        throw changedStoreDirectory(messagePrefix);
-    }
-    return targetStat;
-}
-function assertModeTargetCurrent(receipts, rootReal, messagePrefix) {
-    const target = receipts.at(-1);
-    if (!target)
-        throw new FsSafeError("helper-failed", "store directory receipt is missing");
-    const stat = assertAdmittedEdgeCurrent(receipts, rootReal, messagePrefix);
-    let targetReal;
-    try {
-        targetReal = storeDirectoryRealPath(target.dir);
-    }
-    catch (error) {
-        throw changedStoreDirectory(messagePrefix, error);
-    }
-    if (!isPathInside(rootReal, targetReal))
-        throw changedStoreDirectory(messagePrefix);
-    assertAdmittedEdgeCurrent(receipts, rootReal, messagePrefix);
-    return stat;
-}
-function assertReceiptChain(receipts, rootReal, messagePrefix) {
-    const rootReceipt = receipts[0];
-    const finalReceipt = receipts.at(-1);
-    if (!rootReceipt || !finalReceipt) {
-        throw new FsSafeError("helper-failed", "store directory receipt is missing");
-    }
-    assertRootCurrent(rootReceipt, rootReal, messagePrefix);
-    let finalStat = rootReceipt.stat;
-    for (const [index, receipt] of receipts.entries()) {
-        if (index === 0)
-            continue;
-        finalStat = inspectReceiptCurrent(receipt, messagePrefix, false);
-    }
-    let finalReal;
-    try {
-        finalReal = storeDirectoryRealPath(finalReceipt.dir);
-    }
-    catch (error) {
-        throw changedStoreDirectory(messagePrefix, error);
-    }
-    if (!isPathInside(rootReal, finalReal))
-        throw changedStoreDirectory(messagePrefix);
-    assertRootCurrent(rootReceipt, rootReal, messagePrefix);
-    if (finalReceipt !== rootReceipt) {
-        finalStat = inspectReceiptCurrent(finalReceipt, messagePrefix, false);
-    }
-    return { finalReal, finalStat };
-}
 function directoryOpenFlags() {
     const { O_DIRECTORY, O_NOFOLLOW, O_NONBLOCK, O_RDONLY } = fs.constants;
     if ([O_DIRECTORY, O_NOFOLLOW, O_NONBLOCK, O_RDONLY]
@@ -162,106 +59,209 @@ function hasErrorCode(error, code) {
     }
     return false;
 }
-function openStoreDirectoryForMode(params) {
-    let openError;
-    try {
-        return fs.openSync(pathForWindowsFilesystem(params.receipt.dir), directoryOpenFlags());
-    }
-    catch (error) {
-        openError = error;
+class StoreDirectoryChain {
+    messagePrefix;
+    receipts = [];
+    rootReal;
+    constructor(rootDir, messagePrefix) {
+        this.messagePrefix = messagePrefix;
+        this.observe(rootDir);
+        this.rootReal = storeDirectoryRealPath(rootDir);
+    }
+    observe(dir) {
+        this.receipts.push({
+            dir,
+            stat: inspectStoreDirectory({
+                dir,
+                messagePrefix: this.messagePrefix,
+                root: this.receipts.length === 0,
+            }),
+        });
     }
-    const searchFlags = hasErrorCode(openError, "EACCES") ? directorySearchFlags() : undefined;
-    if (searchFlags !== undefined) {
+    inspectReceipt(receipt, root = false) {
         try {
-            return fs.openSync(pathForWindowsFilesystem(params.receipt.dir), searchFlags);
+            const stat = inspectStoreDirectory({
+                dir: receipt.dir,
+                expected: receipt.stat,
+                messagePrefix: this.messagePrefix,
+                root,
+            });
+            if (stat.dev !== receipt.stat.dev || stat.ino !== receipt.stat.ino) {
+                throw changedStoreDirectory(this.messagePrefix);
+            }
+            return stat;
         }
-        catch (searchError) {
-            openError = createSuppressedError(searchError, openError, "ordinary and search-only directory opens both failed");
+        catch (error) {
+            if (error instanceof FsSafeError && error.code === "outside-workspace")
+                throw error;
+            throw changedStoreDirectory(this.messagePrefix, error);
         }
     }
-    try {
-        assertModeTargetCurrent(params.receipts, params.rootReal, params.messagePrefix);
-    }
-    catch (boundaryError) {
-        throw changedStoreDirectory(params.messagePrefix, createSuppressedError(boundaryError, openError, "directory acquisition and boundary revalidation both failed"));
-    }
-    if (hasErrorCode(openError, "EACCES")) {
-        throw new FsSafeError("permission-unverified", `${params.messagePrefix} directory cannot be safely mode-repaired through a Node descriptor`, { cause: openError });
-    }
-    throw openError;
-}
-function requestedDirectoryMode(mode) {
-    return BigInt(mode & 0o7777);
-}
-function inspectOpenedStoreDirectory(descriptor, receipt, messagePrefix) {
-    try {
-        const stat = inspectFileIdentitySync(() => fs.fstatSync(descriptor, { bigint: true }), receipt.stat);
-        if (!stat.isDirectory() || stat.isSymbolicLink()) {
-            throw changedStoreDirectory(messagePrefix);
+    assertRoot() {
+        const root = this.receipts[0];
+        const stat = this.inspectReceipt(root, true);
+        try {
+            if (storeDirectoryRealPath(root.dir) !== this.rootReal) {
+                throw changedStoreDirectory(this.messagePrefix);
+            }
+        }
+        catch (error) {
+            if (error instanceof FsSafeError && error.code === "outside-workspace")
+                throw error;
+            throw changedStoreDirectory(this.messagePrefix, error);
         }
         return stat;
     }
-    catch (error) {
-        if (error instanceof FsSafeError && error.code === "outside-workspace")
-            throw error;
-        throw changedStoreDirectory(messagePrefix, error);
-    }
-}
-function finalizeDirectoryMode(params) {
-    const receipt = params.receipts.at(-1);
-    if (!receipt)
-        throw new FsSafeError("helper-failed", "store directory receipt is missing");
-    const requestedMode = requestedDirectoryMode(params.mode);
-    if ((receipt.stat.mode & 4095n) === requestedMode || process.platform === "win32") {
-        const current = assertAdmittedEdgeCurrent(params.receipts, params.rootReal, params.messagePrefix);
-        // Identity can remain stable while permissions change after the first receipt.
-        if (process.platform === "win32" || (current.mode & 4095n) === requestedMode) {
-            return { ...receipt, stat: current };
+    assertEdge(canonicalRoot = true) {
+        const targetIndex = this.receipts.length - 1;
+        const rootStat = canonicalRoot
+            ? this.assertRoot() : this.inspectReceipt(this.receipts[0], true);
+        if (targetIndex === 0)
+            return rootStat;
+        const parent = this.receipts[targetIndex - 1];
+        if (targetIndex > 1)
+            this.inspectReceipt(parent);
+        const target = this.receipts[targetIndex];
+        const targetStat = this.inspectReceipt(target);
+        if (path.dirname(target.dir) !== parent.dir) {
+            throw changedStoreDirectory(this.messagePrefix);
         }
-    }
-    // Repair owns the stronger pre/post mode-target fence below, including an
-    // admission check on acquisition failure; no earlier admission is needed.
-    const descriptor = openStoreDirectoryForMode({
-        receipt,
-        receipts: params.receipts,
-        rootReal: params.rootReal,
-        messagePrefix: params.messagePrefix,
-    });
-    let finalStat;
-    let operationFailed = false;
-    let operationError;
-    try {
-        const opened = inspectOpenedStoreDirectory(descriptor, receipt, params.messagePrefix);
-        assertModeTargetCurrent(params.receipts, params.rootReal, params.messagePrefix);
-        if ((opened.mode & 4095n) !== requestedMode) {
-            fs.fchmodSync(descriptor, Number(requestedMode));
+        return targetStat;
+    }
+    assertModeTarget() {
+        const root = this.receipts[0];
+        const target = this.receipts.at(-1);
+        // The target's canonical observation shares the exact identity fence. Keep
+        // the trailing root canonical check: an ancestor relocation can retain IDs.
+        this.assertEdge(false);
+        let targetReal;
+        try {
+            targetReal = storeDirectoryRealPath(target.dir);
         }
-        const finalized = inspectOpenedStoreDirectory(descriptor, receipt, params.messagePrefix);
-        const pathname = assertModeTargetCurrent(params.receipts, params.rootReal, params.messagePrefix);
-        if ((finalized.mode & 4095n) !== requestedMode ||
-            (pathname.mode & 4095n) !== requestedMode) {
-            throw new FsSafeError("insecure-permissions", `${params.messagePrefix} directory mode could not be finalized`);
+        catch (error) {
+            throw changedStoreDirectory(this.messagePrefix, error);
         }
-        finalStat = pathname;
-    }
-    catch (error) {
-        operationFailed = true;
-        operationError = error;
+        if (target === root ? targetReal !== this.rootReal : !isPathInside(this.rootReal, targetReal)) {
+            throw changedStoreDirectory(this.messagePrefix);
+        }
+        return this.assertEdge();
+    }
+    finish(dir) {
+        const root = this.receipts[0];
+        const target = this.receipts.at(-1);
+        this.assertRoot();
+        let finalStat = root.stat;
+        for (const [index, receipt] of this.receipts.entries()) {
+            if (index === 0)
+                continue;
+            finalStat = this.inspectReceipt(receipt);
+        }
+        let finalReal;
+        try {
+            finalReal = storeDirectoryRealPath(target.dir);
+        }
+        catch (error) {
+            throw changedStoreDirectory(this.messagePrefix, error);
+        }
+        if (!isPathInside(this.rootReal, finalReal))
+            throw changedStoreDirectory(this.messagePrefix);
+        this.assertRoot();
+        if (target !== root)
+            finalStat = this.inspectReceipt(target);
+        return { dir, realPath: finalReal, exactStat: finalStat };
+    }
+    openForMode(receipt) {
+        let openError;
+        try {
+            return fs.openSync(pathForWindowsFilesystem(receipt.dir), directoryOpenFlags());
+        }
+        catch (error) {
+            openError = error;
+        }
+        const searchFlags = hasErrorCode(openError, "EACCES") ? directorySearchFlags() : undefined;
+        if (searchFlags !== undefined) {
+            try {
+                return fs.openSync(pathForWindowsFilesystem(receipt.dir), searchFlags);
+            }
+            catch (searchError) {
+                openError = createSuppressedError(searchError, openError, "ordinary and search-only directory opens both failed");
+            }
+        }
+        try {
+            this.assertModeTarget();
+        }
+        catch (boundaryError) {
+            throw changedStoreDirectory(this.messagePrefix, createSuppressedError(boundaryError, openError, "directory acquisition and boundary revalidation both failed"));
+        }
+        if (hasErrorCode(openError, "EACCES")) {
+            throw new FsSafeError("permission-unverified", `${this.messagePrefix} directory cannot be safely mode-repaired through a Node descriptor`, { cause: openError });
+        }
+        throw openError;
     }
-    try {
-        fs.closeSync(descriptor);
+    inspectOpened(descriptor, receipt) {
+        try {
+            const stat = inspectFileIdentitySync(() => fs.fstatSync(descriptor, { bigint: true }), receipt.stat);
+            if (!stat.isDirectory() || stat.isSymbolicLink()) {
+                throw changedStoreDirectory(this.messagePrefix);
+            }
+            return stat;
+        }
+        catch (error) {
+            if (error instanceof FsSafeError && error.code === "outside-workspace")
+                throw error;
+            throw changedStoreDirectory(this.messagePrefix, error);
+        }
     }
-    catch (closeError) {
-        if (operationFailed) {
-            throw createSuppressedError(closeError, operationError, "store directory finalization and close both failed");
+    finalizeMode(mode) {
+        const receipt = this.receipts.at(-1);
+        const requestedMode = BigInt(mode & 0o7777);
+        if ((receipt.stat.mode & 4095n) === requestedMode || process.platform === "win32") {
+            const current = this.assertEdge();
+            // Identity can remain stable while permissions change after the first receipt.
+            if (process.platform === "win32" || (current.mode & 4095n) === requestedMode) {
+                this.receipts[this.receipts.length - 1] = { ...receipt, stat: current };
+                return;
+            }
+        }
+        // Repair owns the stronger pre/post mode-target fence below, including an
+        // admission check on acquisition failure; no earlier admission is needed.
+        const descriptor = this.openForMode(receipt);
+        let finalStat;
+        let operationFailed = false;
+        let operationError;
+        try {
+            const opened = this.inspectOpened(descriptor, receipt);
+            this.assertModeTarget();
+            if ((opened.mode & 4095n) !== requestedMode) {
+                fs.fchmodSync(descriptor, Number(requestedMode));
+            }
+            const finalized = this.inspectOpened(descriptor, receipt);
+            const pathname = this.assertModeTarget();
+            if ((finalized.mode & 4095n) !== requestedMode ||
+                (pathname.mode & 4095n) !== requestedMode) {
+                throw new FsSafeError("insecure-permissions", `${this.messagePrefix} directory mode could not be finalized`);
+            }
+            finalStat = pathname;
         }
-        throw closeError;
+        catch (error) {
+            operationFailed = true;
+            operationError = error;
+        }
+        try {
+            fs.closeSync(descriptor);
+        }
+        catch (closeError) {
+            if (operationFailed) {
+                throw createSuppressedError(closeError, operationError, "store directory finalization and close both failed");
+            }
+            throw closeError;
+        }
+        if (operationFailed)
+            throw operationError;
+        if (!finalStat)
+            throw new FsSafeError("helper-failed", "store directory mode receipt is missing");
+        this.receipts[this.receipts.length - 1] = { ...receipt, stat: finalStat };
     }
-    if (operationFailed)
-        throw operationError;
-    if (!finalStat)
-        throw new FsSafeError("helper-failed", "store directory mode receipt is missing");
-    return { ...receipt, stat: finalStat };
 }
 export function ensureSyncStoreDirectory(params) {
     assertNoWindowsPathAlias(params.rootDir, "filesystem", "store root uses a Windows filesystem namespace alias");
@@ -275,53 +275,23 @@ export function ensureSyncStoreDirectory(params) {
         throw new FsSafeError("outside-workspace", "file path escapes store root");
     }
     fs.mkdirSync(recursiveMkdirPath(pathForWindowsFilesystem(rootDir)), { recursive: true, mode: params.mode });
-    const receipts = [observeStoreDirectory({
-            dir: rootDir,
-            messagePrefix: params.messagePrefix,
-            root: true,
-        })];
-    const rootReal = storeDirectoryRealPath(rootDir);
-    receipts[0] = finalizeDirectoryMode({
-        receipts,
-        rootReal,
-        mode: params.mode,
-        messagePrefix: params.messagePrefix,
-    });
+    const chain = new StoreDirectoryChain(rootDir, params.messagePrefix);
+    chain.finalizeMode(params.mode);
     let current = rootDir;
     for (const segment of relative.split(path.sep).filter(Boolean)) {
         current = path.join(current, segment);
-        let receipt;
         try {
-            receipt = observeStoreDirectory({
-                dir: current,
-                messagePrefix: params.messagePrefix,
-                root: false,
-            });
+            chain.observe(current);
         }
         catch (error) {
             if (error.code !== "ENOENT")
                 throw error;
             fs.mkdirSync(pathForWindowsFilesystem(current), { mode: params.mode });
-            receipt = observeStoreDirectory({
-                dir: current,
-                messagePrefix: params.messagePrefix,
-                root: false,
-            });
+            chain.observe(current);
         }
-        receipts.push(receipt);
-        receipts[receipts.length - 1] = finalizeDirectoryMode({
-            receipts,
-            rootReal,
-            mode: params.mode,
-            messagePrefix: params.messagePrefix,
-        });
+        chain.finalizeMode(params.mode);
     }
-    const finalChain = assertReceiptChain(receipts, rootReal, params.messagePrefix);
-    return {
-        dir,
-        realPath: finalChain.finalReal,
-        exactStat: finalChain.finalStat,
-    };
+    return chain.finish(dir);
 }
 export function assertSyncStoreDirectoryReceipt(receipt) {
     try {

package/node_modules/@openclaw/fs-safe/dist/file-store-sync-write.d.ts

@@ -7,4 +7,3 @@ export declare function writeFileSyncAtomic(params: {
     dirMode: number;
     mode: number;
 }): string;
-//# sourceMappingURL=file-store-sync-write.d.ts.map