@openclaw/openshell-sandbox 2026.9.4 → 2026.9.6

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

@@ -2,40 +2,39 @@ 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 { assertSyncDirectoryGuard as assertDirectoryGuardSync, createSyncDirectoryGuard, } from "./directory-guard.js";
 import { FsSafeError } from "./errors.js";
-import { sameFileIdentity } from "./file-identity.js";
-import { isPathInside, isPathRelativeEscape } from "./path.js";
+import { assertSyncStoreDirectoryReceipt, ensureSyncStoreDirectory, } from "./file-store-sync-directory.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";
-function parentRelativePath(relativePath) {
-    const parent = path.posix.dirname(relativePath);
-    return parent === "." ? "" : parent;
-}
+import { recursiveMkdirPath } from "./recursive-mkdir-path.js";
+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);
     await chmodDirectoryInRootBestEffort(scopedRoot, parent, mode).catch(() => undefined);
 }
 export async function openWritableStoreRoot(params) {
-    const maxBytes = normalizeMaxBytes(params.maxBytes);
-    await fs.mkdir(params.rootDir, { recursive: true, mode: params.dirMode });
+    assertNoWindowsPathAlias(params.rootDir, "filesystem", "store root uses a Windows filesystem namespace alias");
+    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);
     // Bind to the admitted parent, never resolve a replacement into a fresh capability.
     return new RootHandle({
         rootDir: parentGuard.dir,
+        rootGuard: { dir: parentGuard.realPath, realPath: parentGuard.realPath, stat: parentGuard.stat },
         rootReal: parentGuard.realPath,
         rootWithSep: ensureTrailingSep(parentGuard.realPath),
         rootIdentity: { dev: parentGuard.stat.dev, ino: parentGuard.stat.ino },
@@ -63,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",
@@ -87,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);
         }
@@ -113,28 +105,9 @@ export async function writeStreamToTempSource(params) {
         throw err;
     }
 }
-export function assertSyncDirectoryGuard(guard) {
-    try {
-        assertDirectoryGuardSync(guard);
-    }
-    catch (error) {
-        if (error instanceof FsSafeError && error.code === "path-mismatch") {
-            throw new FsSafeError("path-mismatch", "store directory changed during write", {
-                cause: error,
-            });
-        }
-        throw error;
-    }
-}
-function chmodDirectorySyncBestEffort(dir, mode) {
-    try {
-        syncFs.chmodSync(dir, mode);
-    }
-    catch {
-        // Best-effort on platforms that do not enforce POSIX modes.
-    }
-}
 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");
     return ensureStoreDirectorySync({
         rootDir: params.rootDir,
         targetDir: path.dirname(path.resolve(params.filePath)),
@@ -143,47 +116,62 @@ export function ensureParentSync(params) {
     });
 }
 export function ensureStoreDirectorySync(params) {
-    const rootDir = path.resolve(params.rootDir);
-    const dir = path.resolve(params.targetDir);
-    const relative = path.relative(rootDir, dir);
-    if (isPathRelativeEscape(relative)) {
-        throw new FsSafeError("outside-workspace", "file path escapes store root");
+    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");
     }
-    syncFs.mkdirSync(rootDir, { recursive: true, mode: params.mode });
-    const rootStat = syncFs.lstatSync(rootDir);
-    if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) {
-        throw new FsSafeError("not-file", `${params.messagePrefix} root must be a directory: ${rootDir}`);
+    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");
     }
-    const rootReal = syncFs.realpathSync(rootDir);
-    chmodDirectorySyncBestEffort(rootDir, params.mode);
-    let current = rootDir;
-    for (const segment of path.relative(rootDir, dir).split(path.sep).filter(Boolean)) {
-        current = path.join(current, segment);
-        try {
-            const stat = syncFs.lstatSync(current);
-            if (stat.isSymbolicLink() || !stat.isDirectory()) {
-                throw new FsSafeError("not-file", `${params.messagePrefix} directory component must be a directory: ${current}`);
-            }
-        }
-        catch (error) {
-            if (error.code !== "ENOENT") {
-                throw error;
-            }
-            syncFs.mkdirSync(current, { mode: params.mode });
+    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));
         }
-        const currentRootStat = syncFs.lstatSync(rootDir);
-        const currentRootReal = syncFs.realpathSync(rootDir);
-        const currentReal = syncFs.realpathSync(current);
-        if (currentRootStat.isSymbolicLink() ||
-            !currentRootStat.isDirectory() ||
-            !sameFileIdentity(rootStat, currentRootStat) ||
-            currentRootReal !== rootReal ||
-            !isPathInside(rootReal, currentReal)) {
-            throw new FsSafeError("outside-workspace", `${params.messagePrefix} directory escapes root`);
+        if (message.includes(`exceeds ${params.maxBytes} bytes`)) {
+            throw new FsSafeError("too-large", `file exceeds maximum size of ${params.maxBytes} bytes`, errorCauseOptions(error));
         }
-        chmodDirectorySyncBestEffort(current, params.mode);
+        throw error;
     }
-    const guard = createSyncDirectoryGuard(dir);
-    assertSyncDirectoryGuard(guard);
-    return guard;
 }

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

@@ -3,15 +3,21 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { FsSafeError } from "./errors.js";
 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;
     const maxDepth = params.options.maxDepth;
     const pruneEmptyDirs = (recursive || maxDepth !== undefined) && (params.options.pruneEmptyDirs ?? false);
-    await fs.mkdir(params.rootDir, { recursive: true, mode: params.dirMode });
-    const rootReal = fsSync.realpathSync.native(params.rootDir);
+    await fs.mkdir(recursiveMkdirPath(params.rootDir), { recursive: true, mode: params.dirMode });
+    const rootReal = realpathSync.native(params.rootDir);
     const scopedRoot = await root(rootReal);
     const rootGuard = {
         dir: rootReal,
@@ -24,7 +30,7 @@ export async function pruneExpiredStoreEntries(params) {
             !stat.isDirectory() ||
             stat.dev !== rootGuard.stat.dev ||
             stat.ino !== rootGuard.stat.ino ||
-            fsSync.realpathSync.native(rootGuard.dir) !== rootGuard.realPath) {
+            realpathSync.native(rootGuard.dir) !== rootGuard.realPath) {
             throw new FsSafeError("path-mismatch", "store root changed during prune");
         }
     }
@@ -33,7 +39,7 @@ export async function pruneExpiredStoreEntries(params) {
         if (!before || before.isSymbolicLink() || !before.isDirectory()) {
             return null;
         }
-        const real = observeOrNull(() => fsSync.realpathSync.native(dir));
+        const real = observeOrNull(() => realpathSync.native(dir));
         if (!real || !isPathInside(rootReal, real)) {
             return null;
         }
@@ -68,13 +74,21 @@ 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;
             }
             if (stat.isFile() && now - stat.mtimeMs > params.options.ttlMs) {
                 await assertRootGuard();
-                await scopedRoot.remove(relativePath).catch(() => undefined);
+                await scopedRoot.remove(relativePath, {
+                    assertBeforeMutation: () => {
+                        // Removal preparation can outlive the expiry observation above.
+                        const current = fsSync.lstatSync(fullPath);
+                        if (!current.isFile() || !(now - current.mtimeMs > params.options.ttlMs)) {
+                            throw new FsSafeError("path-mismatch", "store entry is no longer an expired file");
+                        }
+                    },
+                }).catch(() => undefined);
             }
         }
         if (!pruneEmptyDirs) {

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

@@ -0,0 +1,15 @@
+import { type BigIntStats } from "node:fs";
+type StoreMessagePrefix = "private store" | "store";
+export type SyncStoreDirectoryReceipt = Readonly<{
+    dir: string;
+    realPath: string;
+    exactStat: BigIntStats;
+}>;
+export declare function ensureSyncStoreDirectory(params: {
+    rootDir: string;
+    targetDir: string;
+    mode: number;
+    messagePrefix: StoreMessagePrefix;
+}): SyncStoreDirectoryReceipt;
+export declare function assertSyncStoreDirectoryReceipt(receipt: SyncStoreDirectoryReceipt): void;
+export {};

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

@@ -0,0 +1,319 @@
+import fs, {} from "node:fs";
+import path from "node:path";
+import { FsSafeError } from "./errors.js";
+import { isPathInside, isPathRelativeEscape } from "./path.js";
+import { realpathSync } from "./realpath.js";
+import { recursiveMkdirPath } from "./recursive-mkdir-path.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
+import { createSuppressedError } from "./suppressed-error.js";
+import { assertNoWindowsPathAlias, pathForWindowsFilesystem, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
+function changedStoreDirectory(messagePrefix, cause) {
+    return new FsSafeError("outside-workspace", `${messagePrefix} directory escapes root`, { cause });
+}
+function storeDirectoryRealPath(dir) {
+    const operationPath = pathForWindowsFilesystem(dir);
+    const realPath = process.platform === "win32"
+        ? realpathSync(operationPath) : realpathSync.native(operationPath);
+    assertNoWindowsPathAlias(realPath, "filesystem");
+    return realPath;
+}
+function inspectStoreDirectory(params) {
+    assertNoWindowsPathAlias(params.dir, "filesystem");
+    return inspectFileIdentitySync(() => {
+        const stat = fs.lstatSync(pathForWindowsFilesystem(params.dir), { bigint: true });
+        if (stat.isSymbolicLink() || !stat.isDirectory()) {
+            const subject = params.root ? "root" : "directory component";
+            throw new FsSafeError("not-file", `${params.messagePrefix} ${subject} must be a directory: ${params.dir}`);
+        }
+        return stat;
+    }, params.expected);
+}
+function directoryOpenFlags() {
+    const { O_DIRECTORY, O_NOFOLLOW, O_NONBLOCK, O_RDONLY } = fs.constants;
+    if ([O_DIRECTORY, O_NOFOLLOW, O_NONBLOCK, O_RDONLY]
+        .some((flag) => typeof flag !== "number")) {
+        throw new FsSafeError("helper-unavailable", "no-follow directory mode descriptors are unavailable");
+    }
+    return O_RDONLY | O_DIRECTORY | O_NOFOLLOW | O_NONBLOCK;
+}
+function directorySearchFlags() {
+    // Linux O_PATH descriptors cannot be fchmoded, and /proc/self/fd would
+    // reintroduce a pathname mutation. Darwin O_SEARCH remains descriptor-bound.
+    if (process.platform !== "darwin" ||
+        (process.arch !== "x64" && process.arch !== "arm64"))
+        return undefined;
+    const { O_DIRECTORY, O_NOFOLLOW, O_NONBLOCK } = fs.constants;
+    if ([O_DIRECTORY, O_NOFOLLOW, O_NONBLOCK].some((flag) => typeof flag !== "number")) {
+        return undefined;
+    }
+    // Darwin SDK O_SEARCH = O_EXEC (0x40000000) | O_DIRECTORY on supported Node hosts.
+    return 0x40000000 | O_DIRECTORY | O_NOFOLLOW | O_NONBLOCK;
+}
+function hasErrorCode(error, code) {
+    if (error && typeof error === "object") {
+        if (error.code === code)
+            return true;
+        const combined = error;
+        return (combined.error !== error && hasErrorCode(combined.error, code)) ||
+            (combined.suppressed !== error && hasErrorCode(combined.suppressed, code));
+    }
+    return false;
+}
+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,
+            }),
+        });
+    }
+    inspectReceipt(receipt, root = false) {
+        try {
+            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 (error) {
+            if (error instanceof FsSafeError && error.code === "outside-workspace")
+                throw error;
+            throw changedStoreDirectory(this.messagePrefix, error);
+        }
+    }
+    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;
+    }
+    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);
+        }
+        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);
+        }
+        catch (error) {
+            throw changedStoreDirectory(this.messagePrefix, 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;
+    }
+    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);
+        }
+    }
+    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;
+        }
+        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 };
+    }
+}
+export function ensureSyncStoreDirectory(params) {
+    assertNoWindowsPathAlias(params.rootDir, "filesystem", "store root uses a Windows filesystem namespace alias");
+    assertNoWindowsPathAlias(params.targetDir, "filesystem", "store path uses a Windows filesystem namespace alias");
+    const rootDir = resolvePathPreservingWindowsRoot(params.rootDir);
+    const dir = resolvePathPreservingWindowsRoot(params.targetDir);
+    assertNoWindowsPathAlias(rootDir, "filesystem", "store root uses a Windows filesystem namespace alias");
+    assertNoWindowsPathAlias(dir, "filesystem", "store path uses a Windows filesystem namespace alias");
+    const relative = path.relative(rootDir, dir);
+    if (isPathRelativeEscape(relative)) {
+        throw new FsSafeError("outside-workspace", "file path escapes store root");
+    }
+    fs.mkdirSync(recursiveMkdirPath(pathForWindowsFilesystem(rootDir)), { recursive: true, mode: params.mode });
+    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);
+        try {
+            chain.observe(current);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+            fs.mkdirSync(pathForWindowsFilesystem(current), { mode: params.mode });
+            chain.observe(current);
+        }
+        chain.finalizeMode(params.mode);
+    }
+    return chain.finish(dir);
+}
+export function assertSyncStoreDirectoryReceipt(receipt) {
+    try {
+        assertNoWindowsPathAlias(receipt.realPath, "filesystem");
+        const stat = inspectStoreDirectory({
+            dir: receipt.dir,
+            expected: receipt.exactStat,
+            messagePrefix: "store",
+            root: false,
+        });
+        if (stat.dev !== receipt.exactStat.dev || stat.ino !== receipt.exactStat.ino ||
+            storeDirectoryRealPath(receipt.dir) !== receipt.realPath) {
+            throw new FsSafeError("path-mismatch", "store directory changed during write");
+        }
+    }
+    catch (error) {
+        if (error instanceof FsSafeError && error.code === "path-mismatch" &&
+            error.message !== "store directory changed during write") {
+            throw new FsSafeError("path-mismatch", "store directory changed during write", {
+                cause: error,
+            });
+        }
+        throw error;
+    }
+}

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

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