@openclaw/openshell-sandbox 2026.9.5 → 2026.9.7

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

@@ -1,26 +1,22 @@
-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 { rootFromDirectoryGuard } 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 = literalStoreRootPath(path.posix.dirname(relativePath));
+    if (parent === ".") {
         return;
     }
     await scopedRoot.mkdir(parent);
@@ -28,21 +24,14 @@ 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);
     // 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 },
-    }, { hardlinks: "reject" });
+    return rootFromDirectoryGuard(parentGuard, { hardlinks: "reject" });
 }
 async function chmodDirectoryInRootBestEffort(scopedRoot, relativePath, mode) {
     const dirPath = await scopedRoot.resolve(relativePath);
@@ -66,15 +55,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 +72,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 +98,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 +109,66 @@ 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;
 }
+// Store keys and directory-entry names are literal, unlike Root's home syntax.
+export function literalStoreRootPath(relativePath) {
+    return relativePath === "~" || relativePath.startsWith("~/") ? `./${relativePath}` : relativePath;
+}
+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

@@ -2,11 +2,16 @@ import fsSync, {} from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { FsSafeError } from "./errors.js";
+import { literalStoreRootPath } from "./file-store-boundary.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;
@@ -18,10 +23,10 @@ export async function pruneExpiredStoreEntries(params) {
     const rootGuard = {
         dir: rootReal,
         realPath: rootReal,
-        stat: fsSync.lstatSync(rootReal),
+        stat: fsSync.lstatSync(rootReal, { bigint: true }),
     };
     async function assertRootGuard() {
-        const stat = fsSync.lstatSync(rootGuard.dir);
+        const stat = fsSync.lstatSync(rootGuard.dir, { bigint: true });
         if (stat.isSymbolicLink() ||
             !stat.isDirectory() ||
             stat.dev !== rootGuard.stat.dev ||
@@ -31,7 +36,7 @@ export async function pruneExpiredStoreEntries(params) {
         }
     }
     async function readStableDirectory(dir) {
-        const before = observeOrNull(() => fsSync.lstatSync(dir));
+        const before = observeOrNull(() => fsSync.lstatSync(dir, { bigint: true }));
         if (!before || before.isSymbolicLink() || !before.isDirectory()) {
             return null;
         }
@@ -43,7 +48,7 @@ export async function pruneExpiredStoreEntries(params) {
         if (!entries) {
             return null;
         }
-        const after = observeOrNull(() => fsSync.lstatSync(dir));
+        const after = observeOrNull(() => fsSync.lstatSync(dir, { bigint: true }));
         if (!after || before.dev !== after.dev || before.ino !== after.ino) {
             return null;
         }
@@ -70,13 +75,13 @@ 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(literalStoreRootPath(relativePath), REMOVE_EMPTY_DIRECTORY_OPTIONS).catch(() => undefined);
                 }
                 continue;
             }
             if (stat.isFile() && now - stat.mtimeMs > params.options.ttlMs) {
                 await assertRootGuard();
-                await scopedRoot.remove(relativePath, {
+                await scopedRoot.remove(literalStoreRootPath(relativePath), {
                     assertBeforeMutation: () => {
                         // Removal preparation can outlive the expiry observation above.
                         const current = fsSync.lstatSync(fullPath);

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