@openclaw/openshell-sandbox 2026.9.1 → 2026.9.3

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

@@ -0,0 +1,275 @@
+import { createTarEntryPlanner } from "./archive-tar.js";
+import { inspectTar, replayTar } from "./archive-tar-stream.js";
+import { runPinnedWriteHelper } from "./pinned-write.js";
+import { constants as fsConstants } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { createArchiveOutputPathTracker, resolveArchiveOutputPath, stripArchivePath, validateArchiveEntryPath, } from "./archive-entry.js";
+import { createPipelineTimeoutError, waitForDeadline, withExtractionDeadline, } from "./archive-deadline.js";
+import { assertArchiveEntryCountWithinLimit, assertArchiveEntryPathComponentsWithinLimit, createByteBudgetTracker, createExtractBudgetTransform, resolveExtractLimits, resolveTarMeterLimits, } from "./archive-limits.js";
+import { assertPortableArchiveKind, resolveArchiveKind } from "./archive-kind.js";
+import { prepareArchiveDestinationDir, preparePrivateArchiveOutputPath, withStagedArchiveDestination, } from "./archive-staging.js";
+import { mergePlannedArchiveIntoDestination } from "./archive-merge.js";
+import { loadZipArchiveWithPreflight } from "./archive-zip-preflight.js";
+import { isZipSymlinkEntry, zipEntryDeclaredSize, zipEntryMode, } from "./archive-zip-entry.js";
+import { createZipIntegrityTransform, normalizeZipIntegrityError, } from "./archive-zip-integrity.js";
+import { FsSafeError } from "./errors.js";
+import { ArchiveSecurityError } from "./archive-errors.js";
+import { extractNativeArchive } from "./archive-native.js";
+import { stageArchiveFileForExtraction } from "./archive-input.js";
+import { getNativeBinding } from "./native.js";
+import { resolveArchiveFilteredEntryPolicy, shouldExtractArchiveEntry, } from "./archive-policy.js";
+import { writeSiblingTempFile } from "./sibling-temp.js";
+export { isWindowsDrivePath, normalizeArchiveEntryPath, resolveArchiveOutputPath, stripArchivePath, validateArchiveEntryPath, } from "./archive-entry.js";
+export { resolveArchiveKind, resolvePackedRootDir } from "./archive-kind.js";
+export { readArchiveEntry } from "./archive-read.js";
+export { inspectTarArchive } from "./archive-tar-inspect.js";
+export { ARCHIVE_LIMIT_ERROR_CODE, ArchiveLimitError, DEFAULT_MAX_ARCHIVE_BYTES_ZIP, DEFAULT_MAX_ENTRIES, DEFAULT_MAX_EXTRACTED_BYTES, DEFAULT_MAX_ENTRY_BYTES, DEFAULT_MAX_META_ENTRY_BYTES, DEFAULT_MAX_ENTRY_PATH_COMPONENTS, } from "./archive-limits.js";
+export { ArchiveFormatError } from "./archive-errors.js";
+export { ArchiveSecurityError } from "./archive-staging.js";
+export { createArchiveSymlinkTraversalError, mergeExtractedTreeIntoDestination, prepareArchiveDestinationDir, prepareArchiveOutputPath, withStagedArchiveDestination, } from "./archive-staging.js";
+export { createTarEntryPreflightChecker } from "./archive-tar.js";
+export { loadZipArchiveWithPreflight, readZipCentralDirectoryEntryCount, } from "./archive-zip-preflight.js";
+const SUPPORTS_NOFOLLOW = process.platform !== "win32" && "O_NOFOLLOW" in fsConstants;
+const OPEN_WRITE_CREATE_FLAGS = fsConstants.O_WRONLY |
+    fsConstants.O_CREAT |
+    fsConstants.O_EXCL |
+    (SUPPORTS_NOFOLLOW ? fsConstants.O_NOFOLLOW : 0);
+async function readZipEntryStream(entry) {
+    if (typeof entry.nodeStream === "function") {
+        return entry.nodeStream();
+    }
+    // Old JSZip: fall back to buffering, but still extract via a stream.
+    const buf = await entry.async("nodebuffer");
+    return Readable.from(buf);
+}
+function resolveZipOutputPath(params) {
+    validateArchiveEntryPath(params.entryPath);
+    const canonicalPath = stripArchivePath(params.entryPath, 0);
+    if (!canonicalPath)
+        return null;
+    const relPath = stripArchivePath(canonicalPath, params.strip);
+    if (!relPath) {
+        return null;
+    }
+    validateArchiveEntryPath(relPath);
+    return {
+        canonicalPath,
+        relPath,
+        outPath: resolveArchiveOutputPath({
+            rootDir: params.destinationDir,
+            relPath,
+            originalPath: params.entryPath,
+        }),
+    };
+}
+async function writeZipFileEntry(params) {
+    params.deadline.check();
+    params.budget.startEntry();
+    const readable = await readZipEntryStream(params.entry);
+    const destinationPath = params.outPath;
+    let tempHandle = null;
+    let handleClosedByStream = false;
+    try {
+        await writeSiblingTempFile({
+            dir: path.dirname(destinationPath),
+            chmodDir: false,
+            mode: 0o600,
+            writeTemp: async (tempPath) => {
+                tempHandle = await fs.open(tempPath, OPEN_WRITE_CREATE_FLAGS, 0o600);
+                const writable = tempHandle.createWriteStream();
+                writable.once("close", () => {
+                    handleClosedByStream = true;
+                });
+                try {
+                    await pipeline(readable, createExtractBudgetTransform({ onChunkBytes: params.budget.addBytes }), createZipIntegrityTransform(params.entry), writable, { signal: params.deadline.signal });
+                }
+                catch (err) {
+                    throw normalizeZipIntegrityError(createPipelineTimeoutError(err, params.deadline));
+                }
+                params.deadline.check();
+                if (!handleClosedByStream) {
+                    await tempHandle.close().catch(() => undefined);
+                    handleClosedByStream = true;
+                }
+                tempHandle = null;
+                return destinationPath;
+            },
+            resolveFinalPath: (filePath) => filePath,
+        });
+    }
+    catch (err) {
+        // Failures here happen before the temp has been committed. The destination
+        // parent may already be untrusted, so cleanup must stay limited to temp state.
+        throw err;
+    }
+    finally {
+        const openTempHandle = tempHandle;
+        if (openTempHandle && !handleClosedByStream) {
+            await openTempHandle.close().catch(() => undefined);
+        }
+    }
+}
+async function extractZip(params) {
+    const limits = resolveExtractLimits(params.limits);
+    const stagedArchive = await stageArchiveFileForExtraction({
+        archivePath: params.archivePath,
+        limits,
+        deadline: params.deadline,
+    });
+    try {
+        const destinationRealDir = await prepareArchiveDestinationDir(params.destDir);
+        params.deadline.check();
+        const buffer = await fs.readFile(stagedArchive.path, { signal: params.deadline.signal });
+        params.deadline.check();
+        const zip = await waitForDeadline(loadZipArchiveWithPreflight(buffer, limits), params.deadline);
+        params.deadline.check();
+        const entries = Object.values(zip.files);
+        const strip = Math.max(0, Math.floor(params.stripComponents ?? 0));
+        assertArchiveEntryCountWithinLimit(entries.length, limits);
+        const budget = createByteBudgetTracker(limits);
+        const trackOutputPath = createArchiveOutputPathTracker();
+        await withStagedArchiveDestination({
+            destinationRealDir,
+            run: async (stagingDir) => {
+                const stagingRealDir = await fs.realpath(stagingDir);
+                const acceptedEntries = [];
+                for (const entry of entries) {
+                    params.deadline.check();
+                    const output = resolveZipOutputPath({
+                        entryPath: entry.name,
+                        strip,
+                        destinationDir: stagingRealDir,
+                    });
+                    if (!output) {
+                        continue;
+                    }
+                    assertArchiveEntryPathComponentsWithinLimit(output.relPath, limits);
+                    trackOutputPath(output.relPath, entry.name);
+                    const isSymlink = isZipSymlinkEntry(entry);
+                    const entryKind = isSymlink ? "symlink" : entry.dir ? "directory" : "file";
+                    const entrySize = zipEntryDeclaredSize(entry);
+                    if (!shouldExtractArchiveEntry({
+                        filter: params.entryFilter,
+                        onFiltered: params.onFiltered,
+                        entry: { path: output.canonicalPath, kind: entryKind, size: entrySize },
+                    })) {
+                        continue;
+                    }
+                    if (isSymlink) {
+                        throw new ArchiveSecurityError("entry-link", `zip entry is a link: ${entry.name}`);
+                    }
+                    const mode = zipEntryMode(entry, params.entryModes);
+                    acceptedEntries.push({ path: output.relPath, kind: entry.dir ? "directory" : "file", mode });
+                    await preparePrivateArchiveOutputPath({
+                        destinationDir: stagingRealDir,
+                        destinationRealDir: stagingRealDir,
+                        relPath: output.relPath,
+                        outPath: output.outPath,
+                        originalPath: entry.name,
+                        isDirectory: entry.dir,
+                        deadline: params.deadline,
+                    });
+                    if (entry.dir) {
+                        continue;
+                    }
+                    await writeZipFileEntry({
+                        entry,
+                        outPath: output.outPath,
+                        budget,
+                        deadline: params.deadline,
+                    });
+                }
+                params.deadline.check();
+                await mergePlannedArchiveIntoDestination({
+                    entries: acceptedEntries,
+                    sourceDir: stagingRealDir,
+                    destinationDir: params.destDir,
+                    destinationRealDir,
+                    deadline: params.deadline,
+                });
+                params.deadline.check();
+            },
+        });
+    }
+    finally {
+        await stagedArchive.cleanup();
+    }
+}
+export async function extractArchive(params) {
+    const onFiltered = resolveArchiveFilteredEntryPolicy(params.onFiltered);
+    const kind = params.kind ?? resolveArchiveKind(params.archivePath);
+    if (!kind) {
+        throw new Error(`unsupported archive: ${params.archivePath}`);
+    }
+    const label = kind === "zip" ? "extract zip" : "extract tar";
+    const limits = resolveExtractLimits(params.limits);
+    const tarLimits = resolveTarMeterLimits(limits);
+    const native = getNativeBinding();
+    // Read the declared public fields before private adapters copy options: class
+    // getters and inherited policy must survive identically on every backend.
+    const options = {
+        archivePath: params.archivePath, destDir: params.destDir,
+        stripComponents: params.stripComponents, limits,
+        entryModes: params.entryModes, entryFilter: params.entryFilter, onFiltered,
+    };
+    if (native) {
+        await withExtractionDeadline(params.timeoutMs, label, async (deadline) => extractNativeArchive({ ...options, binding: native, kind, tarLimits, deadline }));
+        return;
+    }
+    assertPortableArchiveKind(kind);
+    if (kind === "tar") {
+        await withExtractionDeadline(params.timeoutMs, label, async (deadline) => {
+            const stagedArchive = await stageArchiveFileForExtraction({
+                archivePath: options.archivePath,
+                limits,
+                deadline,
+            });
+            try {
+                await extractWasmTar({ archivePath: stagedArchive.path, options, limits, tarLimits, deadline });
+            }
+            finally {
+                await stagedArchive.cleanup();
+            }
+        });
+        return;
+    }
+    await withExtractionDeadline(params.timeoutMs, label, async (deadline) => extractZip({ ...options, deadline }));
+}
+async function extractWasmTar(params) {
+    const { options, deadline, tarLimits } = params;
+    const manifest = [];
+    await inspectTar({ archivePath: params.archivePath, limits: tarLimits, signal: deadline.signal,
+        onMember: (entry) => { manifest.push(entry); } });
+    deadline.check();
+    const destinationRealDir = await prepareArchiveDestinationDir(options.destDir);
+    await withStagedArchiveDestination({ destinationRealDir, run: async (stagingPath) => {
+            const stagingDir = await fs.realpath(stagingPath);
+            const planEntry = createTarEntryPlanner({ ...options, rootDir: destinationRealDir, limits: params.limits });
+            const accepted = manifest.flatMap((entry) => {
+                deadline.check();
+                const planned = planEntry(entry);
+                return planned ? [{ ...entry, ...planned }] : [];
+            });
+            await replayTar({ archivePath: params.archivePath, limits: tarLimits, signal: deadline.signal, members: accepted,
+                async consume(member, payload) {
+                    deadline.check();
+                    await preparePrivateArchiveOutputPath({ destinationDir: stagingDir, destinationRealDir: stagingDir,
+                        relPath: member.path, outPath: path.join(stagingDir, member.path), originalPath: member.path,
+                        isDirectory: member.kind === "directory", deadline });
+                    if (member.kind === "file") {
+                        await runPinnedWriteHelper({ rootPath: stagingDir, relativeParentPath: path.posix.dirname(member.path),
+                            basename: path.posix.basename(member.path), mkdir: false, mode: 0o600, overwrite: false,
+                            maxBytes: member.size, input: { kind: "stream", stream: Readable.from(payload) } });
+                    }
+                    deadline.check();
+                },
+            });
+            deadline.check();
+            await mergePlannedArchiveIntoDestination({ entries: accepted, sourceDir: stagingDir,
+                destinationDir: options.destDir, destinationRealDir, deadline });
+            deadline.check();
+        } });
+}

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

@@ -0,0 +1,2 @@
+export declare function createAsyncLock(): <T>(fn: () => Promise<T>) => Promise<T>;
+//# sourceMappingURL=async-lock.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"async-lock.d.ts","sourceRoot":"","sources":["../src/async-lock.ts"],"names":[],"mappings":"AAAA,wBAAgB,eAAe,KAEE,CAAC,MAAM,MAAM,OAAO,CAAC,CAAC,CAAC,KAAG,OAAO,CAAC,CAAC,CAAC,CAapE"}

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

@@ -0,0 +1,17 @@
+export function createAsyncLock() {
+    let lock = Promise.resolve();
+    return async function withLock(fn) {
+        const prev = lock;
+        let release;
+        lock = new Promise((resolve) => {
+            release = resolve;
+        });
+        await prev;
+        try {
+            return await fn();
+        }
+        finally {
+            release?.();
+        }
+    };
+}

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

@@ -0,0 +1,5 @@
+export { replaceFileAtomic, replaceFileAtomicSync, type RenameIdentityPolicy, type ReplaceFileAtomicFileSystem, type ReplaceFileAtomicOptions, type ReplaceFileAtomicRestoreCleanup, type ReplaceFileAtomicRestoreFailureDetails, type ReplaceFileAtomicResult, type ReplaceFileCopyFallbackRestorePolicy, type ReplaceFileDestinationHardlinkPolicy, type ReplaceFileAtomicSyncFileSystem, type ReplaceFileAtomicSyncOptions, } from "./replace-file.js";
+export { writeTextAtomic, type WriteTextAtomicOptions } from "./text-atomic.js";
+export { replaceDirectoryAtomic, type ReplaceDirectoryAtomicOptions } from "./replace-directory.js";
+export { movePathWithCopyFallback, type MovePathPublicationReceipt, type MovePathWithCopyFallbackOptions, } from "./move-path.js";
+//# sourceMappingURL=atomic.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"atomic.d.ts","sourceRoot":"","sources":["../src/atomic.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,KAAK,oBAAoB,EACzB,KAAK,2BAA2B,EAChC,KAAK,wBAAwB,EAC7B,KAAK,+BAA+B,EACpC,KAAK,sCAAsC,EAC3C,KAAK,uBAAuB,EAC5B,KAAK,oCAAoC,EACzC,KAAK,oCAAoC,EACzC,KAAK,+BAA+B,EACpC,KAAK,4BAA4B,GAClC,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,eAAe,EAAE,KAAK,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAChF,OAAO,EAAE,sBAAsB,EAAE,KAAK,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AACpG,OAAO,EACL,wBAAwB,EACxB,KAAK,0BAA0B,EAC/B,KAAK,+BAA+B,GACrC,MAAM,gBAAgB,CAAC"}

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

@@ -0,0 +1,4 @@
+export { replaceFileAtomic, replaceFileAtomicSync, } from "./replace-file.js";
+export { writeTextAtomic } from "./text-atomic.js";
+export { replaceDirectoryAtomic } from "./replace-directory.js";
+export { movePathWithCopyFallback, } from "./move-path.js";

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

@@ -0,0 +1,4 @@
+import { Transform } from "node:stream";
+export declare function createMaxBytesTransform(maxBytes: number): Transform;
+export declare function createByteLimitTransform(maxBytes: number, overflowError: (bytes: number) => Error): Transform;
+//# sourceMappingURL=bounded-read-stream.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/bounded-read-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounded-read-stream.d.ts","sourceRoot":"","sources":["../src/bounded-read-stream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAIxC,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAMnE;AAED,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,KAAK,GACtC,SAAS,CAaX"}

package/node_modules/@openclaw/fs-safe/dist/bounded-read-stream.js

@@ -0,0 +1,21 @@
+import { Transform } from "node:stream";
+import { normalizeMaxBytes } from "./byte-budget.js";
+import { FsSafeError } from "./errors.js";
+export function createMaxBytesTransform(maxBytes) {
+    normalizeMaxBytes(maxBytes);
+    return createByteLimitTransform(maxBytes, (bytes) => new FsSafeError("too-large", `file exceeds limit of ${maxBytes} bytes (got at least ${bytes})`));
+}
+export function createByteLimitTransform(maxBytes, overflowError) {
+    let bytes = 0;
+    return new Transform({
+        transform(chunk, _encoding, callback) {
+            const buffer = chunk instanceof Buffer ? chunk : Buffer.from(chunk);
+            bytes += buffer.byteLength;
+            if (bytes > maxBytes) {
+                callback(overflowError(bytes));
+                return;
+            }
+            callback(null, buffer);
+        },
+    });
+}

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

@@ -0,0 +1,14 @@
+import type { FileHandle } from "node:fs/promises";
+type ReadableFileHandle = Pick<FileHandle, "read">;
+/**
+ * Reads from the handle's current offset without closing it. A bounded read
+ * consumes at most maxBytes + 1 bytes so growth after an earlier stat cannot
+ * force an unbounded allocation.
+ */
+export declare function readFileHandleBounded(handle: ReadableFileHandle, maxBytes: number): Promise<Buffer>;
+/** Async bounded read from a numeric descriptor. The caller owns the descriptor. */
+export declare function readFileDescriptorBounded(fd: number, maxBytes: number): Promise<Buffer>;
+/** Sync bounded read from a numeric descriptor. The caller owns the descriptor. */
+export declare function readFileDescriptorBoundedSync(fd: number, maxBytes: number): Buffer;
+export {};
+//# sourceMappingURL=bounded-read.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bounded-read.d.ts","sourceRoot":"","sources":["../src/bounded-read.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAMnD,KAAK,kBAAkB,GAAG,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;AA+DnD;;;;GAIG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,kBAAkB,EAC1B,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC,CAMjB;AAyBD,oFAAoF;AACpF,wBAAsB,yBAAyB,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAK7F;AAED,mFAAmF;AACnF,wBAAgB,6BAA6B,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAalF"}

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

@@ -0,0 +1,106 @@
+import fs from "node:fs";
+import { normalizeMaxBytes } from "./byte-budget.js";
+import { FsSafeError } from "./errors.js";
+const READ_CHUNK_BYTES = 64 * 1024;
+function createScratchBuffer(maxBytes) {
+    const initialReadBytes = Number.isFinite(maxBytes)
+        ? Math.min(READ_CHUNK_BYTES, maxBytes + 1)
+        : READ_CHUNK_BYTES;
+    return Buffer.allocUnsafe(Math.max(1, initialReadBytes));
+}
+function nextReadLength(total, maxBytes, capacity) {
+    return Number.isFinite(maxBytes)
+        ? Math.min(capacity, maxBytes - total + 1)
+        : capacity;
+}
+function appendChunk(params) {
+    const total = params.total + params.bytesRead;
+    if (total > params.maxBytes) {
+        throw new FsSafeError("too-large", `file exceeds limit of ${params.maxBytes} bytes (got at least ${total})`);
+    }
+    params.chunks.push(Buffer.from(params.scratch.subarray(0, params.bytesRead)));
+    return total;
+}
+async function readBoundedAsync(maxBytes, readChunk, observeRegularFileSize) {
+    normalizeMaxBytes(maxBytes);
+    const chunks = [];
+    let total = 0;
+    const size = observeRegularFileSize?.();
+    if (size !== undefined) {
+        const first = Buffer.allocUnsafe(Math.min(maxBytes, size) + 1);
+        const bytesRead = await readChunk(first, first.length);
+        if (bytesRead === 0)
+            return first.subarray(0, 0);
+        // Short reads can occur before EOF. Only accept one when a fresh fd size
+        // observation proves we consumed at least the entire current file size.
+        const currentSize = bytesRead < first.length ? observeRegularFileSize?.() : undefined;
+        if (currentSize !== undefined && bytesRead >= currentSize)
+            return first.subarray(0, bytesRead);
+        total = appendChunk({ chunks, scratch: first, bytesRead, total, maxBytes });
+    }
+    const scratch = createScratchBuffer(maxBytes);
+    while (true) {
+        const length = nextReadLength(total, maxBytes, scratch.length);
+        const bytesRead = await readChunk(scratch, length);
+        if (bytesRead === 0) {
+            return Buffer.concat(chunks, total);
+        }
+        total = appendChunk({ chunks, scratch, bytesRead, total, maxBytes });
+    }
+}
+/**
+ * Reads from the handle's current offset without closing it. A bounded read
+ * consumes at most maxBytes + 1 bytes so growth after an earlier stat cannot
+ * force an unbounded allocation.
+ */
+export async function readFileHandleBounded(handle, maxBytes) {
+    normalizeMaxBytes(maxBytes);
+    const fd = "fd" in handle && typeof handle.fd === "number" ? handle.fd : undefined;
+    return await readBoundedAsync(maxBytes, async (scratch, length) => {
+        return (await handle.read(scratch, 0, length, null)).bytesRead;
+    }, fd === undefined ? undefined : () => regularFileSize(fd));
+}
+function regularFileSize(fd) {
+    try {
+        const stat = fs.fstatSync(fd);
+        return stat.isFile() && Number.isSafeInteger(stat.size) && stat.size >= 0
+            ? stat.size : undefined;
+    }
+    catch {
+        // Size is only an optimization hint; retain the reader's original errors.
+        return undefined;
+    }
+}
+function readDescriptorChunk(fd, scratch, length) {
+    return new Promise((resolve, reject) => {
+        fs.read(fd, scratch, 0, length, null, (error, bytesRead) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(bytesRead);
+        });
+    });
+}
+/** Async bounded read from a numeric descriptor. The caller owns the descriptor. */
+export async function readFileDescriptorBounded(fd, maxBytes) {
+    normalizeMaxBytes(maxBytes);
+    return await readBoundedAsync(maxBytes, async (scratch, length) => {
+        return await readDescriptorChunk(fd, scratch, length);
+    }, () => regularFileSize(fd));
+}
+/** Sync bounded read from a numeric descriptor. The caller owns the descriptor. */
+export function readFileDescriptorBoundedSync(fd, maxBytes) {
+    normalizeMaxBytes(maxBytes);
+    const chunks = [];
+    const scratch = createScratchBuffer(maxBytes);
+    let total = 0;
+    while (true) {
+        const length = nextReadLength(total, maxBytes, scratch.length);
+        const bytesRead = fs.readSync(fd, scratch, 0, length, null);
+        if (bytesRead === 0) {
+            return Buffer.concat(chunks, total);
+        }
+        total = appendChunk({ chunks, scratch, bytesRead, total, maxBytes });
+    }
+}

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

@@ -0,0 +1,4 @@
+export declare function normalizeMaxBytes(value: number | undefined, options?: {
+    defaultValue?: number;
+}): number | undefined;
+//# sourceMappingURL=byte-budget.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"byte-budget.d.ts","sourceRoot":"","sources":["../src/byte-budget.ts"],"names":[],"mappings":"AAAA,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAO,GACtC,MAAM,GAAG,SAAS,CASpB"}

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

@@ -0,0 +1,9 @@
+export function normalizeMaxBytes(value, options = {}) {
+    const selected = value === undefined ? options.defaultValue : value;
+    if (selected === undefined || selected === Number.POSITIVE_INFINITY)
+        return selected;
+    if (!Number.isSafeInteger(selected) || selected < 0) {
+        throw new RangeError("maxBytes must be a non-negative safe integer or Infinity");
+    }
+    return selected;
+}

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

@@ -0,0 +1,3 @@
+export { configureFsSafePython, configureFsSafeNative, getFsSafeNativeConfig, type FsSafePythonConfig, type FsSafeNativeConfig, type FsSafeNativeMode, } from "./native-config.js";
+export { configureFsSafeLocks, getFsSafeLockConfig, type FsSafeLockConfig, } from "./lock-config.js";
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,GACtB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,KAAK,gBAAgB,GACtB,MAAM,kBAAkB,CAAC"}

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

@@ -0,0 +1,2 @@
+export { configureFsSafePython, configureFsSafeNative, getFsSafeNativeConfig, } from "./native-config.js";
+export { configureFsSafeLocks, getFsSafeLockConfig, } from "./lock-config.js";

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

@@ -0,0 +1,2 @@
+export type ContainmentGuarantee = "kernel-atomic" | "best-effort";
+//# sourceMappingURL=containment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"containment.d.ts","sourceRoot":"","sources":["../src/containment.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,oBAAoB,GAAG,eAAe,GAAG,aAAa,CAAC"}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,12 @@
+export declare function resolveMutationComparablePaths(rawPath: string): Promise<Set<string>>;
+export type DenyMutationPolicy = {
+    paths?: readonly string[];
+    prefixes?: readonly string[];
+};
+type DenyMutationCheckOptions = {
+    protectAncestors?: boolean;
+};
+export declare function assertMutationNotDenied(filePath: string, policy: DenyMutationPolicy | undefined, options?: DenyMutationCheckOptions): Promise<void>;
+export declare function mergeDenyMutationPolicies(defaultPolicy: DenyMutationPolicy | undefined, callPolicy: DenyMutationPolicy | undefined): DenyMutationPolicy | undefined;
+export {};
+//# sourceMappingURL=deny-mutations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deny-mutations.d.ts","sourceRoot":"","sources":["../src/deny-mutations.ts"],"names":[],"mappings":"AAKA,wBAAsB,8BAA8B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAI1F;AAMD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9B,CAAC;AAEF,KAAK,wBAAwB,GAAG;IAC9B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAqBF,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,kBAAkB,GAAG,SAAS,EACtC,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,IAAI,CAAC,CAiCf;AAED,wBAAgB,yBAAyB,CACvC,aAAa,EAAE,kBAAkB,GAAG,SAAS,EAC7C,UAAU,EAAE,kBAAkB,GAAG,SAAS,GACzC,kBAAkB,GAAG,SAAS,CAWhC"}

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

@@ -0,0 +1,69 @@
+import path from "node:path";
+import { FsSafeError } from "./errors.js";
+import { assertNoNulPathInput, isPathInside } from "./path.js";
+import { resolvePathViaExistingAncestor } from "./root-path-existing.js";
+export async function resolveMutationComparablePaths(rawPath) {
+    assertNoNulPathInput(rawPath, "path contains a NUL byte");
+    const resolved = path.resolve(rawPath);
+    return new Set([resolved, await resolvePathViaExistingAncestor(resolved)]);
+}
+function isSamePath(left, right) {
+    return isPathInside(left, right) && isPathInside(right, left);
+}
+function hasPolicyEntries(policy) {
+    return Boolean(policy?.paths?.length || policy?.prefixes?.length);
+}
+function policyPathEntries(entries) {
+    const paths = [];
+    for (const entry of entries ?? []) {
+        if (entry.length === 0) {
+            throw new FsSafeError("invalid-path", "deny mutation paths must be non-empty");
+        }
+        assertNoNulPathInput(entry, "deny mutation path contains a NUL byte");
+        if (!path.isAbsolute(entry)) {
+            throw new FsSafeError("invalid-path", "deny mutation paths must be absolute");
+        }
+        paths.push(entry);
+    }
+    return paths;
+}
+export async function assertMutationNotDenied(filePath, policy, options = {}) {
+    if (!hasPolicyEntries(policy)) {
+        return;
+    }
+    const targetPaths = await resolveMutationComparablePaths(filePath);
+    for (const deniedPath of policyPathEntries(policy.paths)) {
+        const deniedPaths = await resolveMutationComparablePaths(deniedPath);
+        for (const target of targetPaths) {
+            for (const denied of deniedPaths) {
+                if (isSamePath(denied, target) ||
+                    (options.protectAncestors === true && isPathInside(target, denied))) {
+                    throw new FsSafeError("denied-path", "path is denied by denyMutations policy");
+                }
+            }
+        }
+    }
+    for (const deniedPrefix of policyPathEntries(policy.prefixes)) {
+        const deniedPaths = await resolveMutationComparablePaths(deniedPrefix);
+        for (const target of targetPaths) {
+            for (const denied of deniedPaths) {
+                if (isPathInside(denied, target) ||
+                    (options.protectAncestors === true && isPathInside(target, denied))) {
+                    throw new FsSafeError("denied-path", "path is denied by denyMutations policy");
+                }
+            }
+        }
+    }
+}
+export function mergeDenyMutationPolicies(defaultPolicy, callPolicy) {
+    if (!defaultPolicy) {
+        return callPolicy;
+    }
+    if (!callPolicy) {
+        return defaultPolicy;
+    }
+    return {
+        paths: [...(defaultPolicy.paths ?? []), ...(callPolicy.paths ?? [])],
+        prefixes: [...(defaultPolicy.prefixes ?? []), ...(callPolicy.prefixes ?? [])],
+    };
+}

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

@@ -0,0 +1,15 @@
+export type UnsafeDeviceReadPathReason = "posix-device" | "posix-fd" | "windows-device";
+export type UnsafeDeviceReadPathMatch = {
+    path: string;
+    reason: UnsafeDeviceReadPathReason;
+};
+export type UnsafeDeviceReadPathOptions = {
+    cwd?: string;
+    platform?: NodeJS.Platform;
+};
+export declare const WINDOWS_RESERVED_DEVICE_NAMES: ReadonlySet<string>;
+export declare function isWindowsReservedDeviceName(name: string): boolean;
+export declare function matchUnsafeDeviceReadPath(filePath: string, options?: UnsafeDeviceReadPathOptions): UnsafeDeviceReadPathMatch | undefined;
+export declare function isUnsafeDeviceReadPath(filePath: string, options?: UnsafeDeviceReadPathOptions): boolean;
+export declare function assertNoUnsafeDeviceReadPath(filePath: string, options?: UnsafeDeviceReadPathOptions): void;
+//# sourceMappingURL=device-path.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"device-path.d.ts","sourceRoot":"","sources":["../src/device-path.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,0BAA0B,GAClC,cAAc,GACd,UAAU,GACV,gBAAgB,CAAC;AAErB,MAAM,MAAM,yBAAyB,GAAG;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,0BAA0B,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG;IACxC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC;CAC5B,CAAC;AAcF,eAAO,MAAM,6BAA6B,EAAE,WAAW,CAAC,MAAM,CAgC5D,CAAC;AAsEH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEjE;AAcD,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,2BAAgC,GACxC,yBAAyB,GAAG,SAAS,CAWvC;AAED,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,2BAA2B,GACpC,OAAO,CAET;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,2BAA2B,GACpC,IAAI,CAON"}