@openclaw/openshell-sandbox 2026.9.1 → 2026.9.3

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

@@ -0,0 +1,95 @@
+import fs from "node:fs";
+import { Writable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { createGunzip } from "node:zlib";
+import { GzipInput, validateGzipContainerTail } from "./archive-gzip-tail.js";
+import { ArchiveFormatError } from "./archive-errors.js";
+import { TarParserStream } from "./archive-tar-wasm.js";
+async function gzipFile(filePath) {
+    const handle = await fs.promises.open(filePath, "r");
+    try {
+        const magic = Buffer.alloc(2);
+        const { bytesRead } = await handle.read(magic, 0, 2, 0);
+        return bytesRead === 2 && magic[0] === 31 && magic[1] === 139;
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function withTarStream(params, consume) {
+    const gzip = await gzipFile(params.archivePath);
+    const parser = new TarParserStream(params.limits, params.onMember);
+    const input = fs.createReadStream(params.archivePath, { highWaterMark: 65536 });
+    const decoder = gzip ? createGunzip() : undefined;
+    const gzipInput = decoder ? new GzipInput(decoder) : undefined;
+    const destroy = (error) => {
+        input.destroy(error);
+        gzipInput?.destroy(error);
+        decoder?.destroy(error);
+        parser.destroy(error);
+    };
+    const pumps = decoder && gzipInput
+        ? [pipeline(decoder, parser, { signal: params.signal }), pipeline(input, gzipInput, { signal: params.signal })]
+        : [pipeline(input, parser, { signal: params.signal })];
+    // Either pump tears down both routes; join every pump even after the first failure.
+    const settled = Promise.all(pumps.map((pump) => pump.then(() => undefined, (cause) => {
+        const error = cause instanceof Error ? cause : new Error(String(cause));
+        destroy(error);
+        return error;
+    }))).then((errors) => errors.find((error) => error !== undefined));
+    try {
+        const result = await consume(parser);
+        const error = await settled;
+        if (error)
+            throw error;
+        if (gzipInput)
+            await validateGzipContainerTail(params.archivePath, gzipInput.tailOffset, params.signal);
+        return result;
+    }
+    finally {
+        destroy();
+        await settled;
+    }
+}
+export async function inspectTar(params) {
+    await withTarStream(params, async (parser) => {
+        await pipeline(parser, new Writable({ write(_chunk, _encoding, callback) { callback(); } }));
+    });
+}
+/** Replay in physical order, retaining at most one decoded chunk. Every range
+ * comes from complete admission of the immutable staged input. */
+export async function replayTar(params) {
+    await withTarStream(params, async (parser) => {
+        const iterator = parser[Symbol.asyncIterator]();
+        let chunk = Buffer.alloc(0);
+        let position = 0;
+        async function* take(length) {
+            while (length > 0) {
+                if (!chunk.length) {
+                    const next = await iterator.next();
+                    if (next.done)
+                        throw new ArchiveFormatError("truncated admitted TAR range");
+                    chunk = next.value;
+                }
+                const count = Math.min(length, chunk.length);
+                const bytes = chunk.subarray(0, count);
+                chunk = chunk.subarray(count);
+                position += count;
+                length -= count;
+                yield bytes;
+            }
+        }
+        for (const member of params.members) {
+            if (member.offset < position)
+                throw new ArchiveFormatError("invalid admitted TAR range order");
+            for await (const _ of take(member.offset - position)) { /* Skip admitted gaps. */ }
+            const payload = take(member.size);
+            await params.consume(member, payload);
+            for await (const _ of payload) { /* Directories may carry ignored dump data. */ }
+            if (position !== member.offset + member.size)
+                throw new ArchiveFormatError("incomplete TAR range consumption");
+        }
+        // Includes unrequested/skipped members, trailer checks, and physical EOF.
+        while (!(await iterator.next()).done) { /* Drain the bounded parser stream. */ }
+    });
+}

package/node_modules/@openclaw/fs-safe/dist/archive-tar-wasm.d.ts

@@ -0,0 +1,18 @@
+import { Transform, type TransformCallback } from "node:stream";
+import type { TarMeterLimits } from "./archive-limits.js";
+import type { TarEntryInfo } from "./archive-tar.js";
+export type AdmittedTarMember = TarEntryInfo & {
+    offset: number;
+};
+/** Backpressure-aware transport only; all TAR semantics live in the Rust core. */
+export declare class TarParserStream extends Transform {
+    private readonly onMember?;
+    private abi;
+    constructor(limits: TarMeterLimits, onMember?: ((entry: AdmittedTarMember) => void) | undefined);
+    private bytes;
+    private text;
+    _transform(chunk: Buffer, _encoding: BufferEncoding, callback: TransformCallback): void;
+    _flush(callback: TransformCallback): void;
+    _destroy(error: Error | null, callback: (error: Error | null) => void): void;
+}
+//# sourceMappingURL=archive-tar-wasm.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/archive-tar-wasm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive-tar-wasm.d.ts","sourceRoot":"","sources":["../src/archive-tar-wasm.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEhE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,MAAM,MAAM,iBAAiB,GAAG,YAAY,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAuClE,kFAAkF;AAClF,qBAAa,eAAgB,SAAQ,SAAS;IAER,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC;IAD9D,OAAO,CAAC,GAAG,CAAkB;IAC7B,YAAY,MAAM,EAAE,cAAc,EAAmB,QAAQ,CAAC,GAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,aAAA,EAQjG;IACD,OAAO,CAAC,KAAK;IAQb,OAAO,CAAC,IAAI;IAIH,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAkB/F;IACQ,MAAM,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAKjD;IACQ,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,KAAK,IAAI,GAAG,IAAI,CAKpF;CACF"}

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

@@ -0,0 +1,99 @@
+import { classifyArchiveParserError } from "./archive-parser-errors.js";
+import { readFileSync } from "node:fs";
+import { Transform } from "node:stream";
+import { ArchiveFormatError } from "./archive-errors.js";
+// Node exposes WebAssembly without DOM globals; keep the private ABI types local.
+const wasm = globalThis.WebAssembly;
+let compiled;
+function instance() {
+    // src tests and dist consumers resolve the same generated package artifact.
+    compiled ??= new wasm.Module(readFileSync(new URL("../dist/archive-parser.wasm", import.meta.url)));
+    if (wasm.Module.imports(compiled).length)
+        throw new Error("TAR WASM unexpectedly requires host imports");
+    return new wasm.Instance(compiled).exports;
+}
+const types = new Map([
+    [0, "File"], [48, "File"], [49, "Link"], [50, "SymbolicLink"],
+    [51, "CharacterDevice"], [52, "BlockDevice"], [53, "Directory"],
+    [54, "FIFO"], [55, "ContiguousFile"], [68, "GNUDumpDir"],
+]);
+function parserError(message) {
+    const mapped = classifyArchiveParserError(message);
+    if (mapped)
+        return mapped;
+    return new ArchiveFormatError(message.replace(/^archive-header-invalid:/, "invalid TAR header:"));
+}
+/** Backpressure-aware transport only; all TAR semantics live in the Rust core. */
+export class TarParserStream extends Transform {
+    onMember;
+    abi;
+    constructor(limits, onMember) {
+        super();
+        this.onMember = onMember;
+        this.abi = instance();
+        if (this.abi.init(limits.maxEntries, limits.maxMetaEntryBytes, limits.maxDecodedBytes, limits.maxManifestBytes, Number(process.platform === "win32")) !== 0) {
+            this.abi.dispose();
+            this.abi = undefined;
+            throw new RangeError("invalid TAR parser limits");
+        }
+    }
+    bytes(pointer, length) {
+        const memory = this.abi.memory.buffer;
+        if (!Number.isInteger(pointer) || !Number.isInteger(length) || pointer < 0 || length < 0 ||
+            pointer > memory.byteLength || length > memory.byteLength - pointer) {
+            throw new ArchiveFormatError("invalid TAR WASM memory range");
+        }
+        return new Uint8Array(memory, pointer, length);
+    }
+    text() {
+        const abi = this.abi;
+        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(this.bytes(abi.text_ptr(), abi.text_len()));
+    }
+    _transform(chunk, _encoding, callback) {
+        try {
+            const abi = this.abi;
+            for (let offset = 0; offset < chunk.length;) {
+                const length = Math.min(65536, chunk.length - offset);
+                this.bytes(abi.input_ptr(), length).set(chunk.subarray(offset, offset + length));
+                const used = abi.push(length);
+                if (used < 0)
+                    throw parserError(this.text());
+                if (used === 0 || used > length)
+                    throw new ArchiveFormatError("TAR WASM made no progress");
+                offset += used;
+                const type = abi.member_type();
+                if (type >= 0)
+                    this.onMember?.({
+                        path: this.text(), type: types.get(type) ?? "Unsupported", size: abi.member_size(),
+                        mode: abi.member_mode(), offset: abi.member_offset(),
+                    });
+            }
+            callback(null, chunk);
+        }
+        catch (error) {
+            callback(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    _flush(callback) {
+        try {
+            if (this.abi.finish() !== 0)
+                throw parserError(this.text());
+            callback();
+        }
+        catch (error) {
+            callback(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    _destroy(error, callback) {
+        try {
+            this.abi?.dispose();
+        }
+        catch (cause) {
+            error ??= cause instanceof Error ? cause : new Error(String(cause));
+        }
+        finally {
+            this.abi = undefined;
+        }
+        callback(error);
+    }
+}

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

@@ -0,0 +1,19 @@
+import type { ArchiveExtractLimits } from "./archive-limits.js";
+import { type ArchivePlanEntry, type ArchivePlanOptions } from "./archive-plan.js";
+import { type ArchiveEntryFilter, type ArchiveFilteredEntryPolicy } from "./archive-policy.js";
+export type TarEntryInfo = {
+    path: string;
+    type: string;
+    size: number;
+    mode?: number;
+};
+export declare function createTarEntryPlanner(params: ArchivePlanOptions): (entry: TarEntryInfo) => ArchivePlanEntry | null;
+export declare function createTarEntryPreflightChecker(params: {
+    rootDir: string;
+    stripComponents?: number;
+    limits?: ArchiveExtractLimits;
+    escapeLabel?: string;
+    entryFilter?: ArchiveEntryFilter;
+    onFiltered?: ArchiveFilteredEntryPolicy;
+}): (entry: TarEntryInfo) => boolean;
+//# sourceMappingURL=archive-tar.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"archive-tar.d.ts","sourceRoot":"","sources":["../src/archive-tar.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACxB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,0BAA0B,EAChC,MAAM,qBAAqB,CAAC;AAE7B,MAAM,MAAM,YAAY,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AASvF,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,kBAAkB,GAC9D,CAAC,KAAK,EAAE,YAAY,KAAK,gBAAgB,GAAG,IAAI,CAQjD;AAED,wBAAgB,8BAA8B,CAAC,MAAM,EAAE;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,MAAM,CAAC,EAAE,oBAAoB,CAAC;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,UAAU,CAAC,EAAE,0BAA0B,CAAC;CACzC,GAAG,CAAC,KAAK,EAAE,YAAY,KAAK,OAAO,CAGnC"}

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

@@ -0,0 +1,21 @@
+import { createArchiveEntryPlanner, } from "./archive-plan.js";
+import { archiveEntryKindFromTarType, } from "./archive-policy.js";
+const BLOCKED_TAR_ENTRY_TYPES = new Set([
+    "BlockDevice",
+    "CharacterDevice",
+    "FIFO",
+    "Socket",
+]);
+export function createTarEntryPlanner(params) {
+    // Preserve inherited/getter-backed public options and per-entry policy reads.
+    const plan = createArchiveEntryPlanner(params, "tar");
+    return (entry) => {
+        const kind = BLOCKED_TAR_ENTRY_TYPES.has(entry.type) ? "blocked" : archiveEntryKindFromTarType(entry.type);
+        // The public checker accepts structural entry objects, including class getters.
+        return plan({ path: entry.path, kind, size: entry.size, mode: entry.mode });
+    };
+}
+export function createTarEntryPreflightChecker(params) {
+    const plan = createTarEntryPlanner(params);
+    return (entry) => plan(entry) !== null;
+}

package/node_modules/@openclaw/fs-safe/dist/archive-zip-admission.d.ts

@@ -0,0 +1,8 @@
+import type { ExtractionDeadline } from "./archive-deadline.js";
+import { type ResolvedArchiveExtractLimits } from "./archive-limits.js";
+import { type ZipDirectoryEntry } from "./archive-zip-directory.js";
+/** Admit physical records before a decoder can normalize or collapse names. */
+export declare function admitZipBuffer(input: Uint8Array, limits: ResolvedArchiveExtractLimits): number;
+/** The extraction input is already private and staged; read only bounded metadata. */
+export declare function admitZipFile(archivePath: string, limits: ResolvedArchiveExtractLimits, deadline: ExtractionDeadline, onEntry?: (entry: ZipDirectoryEntry) => void): Promise<number>;
+//# sourceMappingURL=archive-zip-admission.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/archive-zip-admission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive-zip-admission.d.ts","sourceRoot":"","sources":["../src/archive-zip-admission.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAA+C,KAAK,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAErH,OAAO,EAAoB,KAAK,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAUtF,+EAA+E;AAC/E,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,4BAA4B,GAAG,MAAM,CAU9F;AAED,sFAAsF;AACtF,wBAAsB,YAAY,CAChC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,4BAA4B,EAAE,QAAQ,EAAE,kBAAkB,EACvF,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GAC3C,OAAO,CAAC,MAAM,CAAC,CA+BjB"}

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

@@ -0,0 +1,60 @@
+import fs from "node:fs";
+import path from "node:path";
+import { ARCHIVE_LIMIT_ERROR_CODE, ArchiveLimitError } from "./archive-limits.js";
+import { openRootFile } from "./root-file.js";
+import { scanZipDirectory } from "./archive-zip-directory.js";
+import { zipFormat } from "./archive-zip-names.js";
+function checkSize(size, limits) {
+    if (size > limits.maxArchiveBytes) {
+        throw new ArchiveLimitError(ARCHIVE_LIMIT_ERROR_CODE.ARCHIVE_SIZE_EXCEEDS_LIMIT);
+    }
+    if (!Number.isSafeInteger(size) || size < 0)
+        zipFormat("invalid archive size");
+}
+/** Admit physical records before a decoder can normalize or collapse names. */
+export function admitZipBuffer(input, limits) {
+    checkSize(input.byteLength, limits);
+    const buffer = Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+    const scan = scanZipDirectory(buffer.length, limits);
+    let step = scan.next();
+    while (!step.done) {
+        const { offset, length } = step.value;
+        step = scan.next(buffer.subarray(offset, offset + length));
+    }
+    return step.value;
+}
+/** The extraction input is already private and staged; read only bounded metadata. */
+export async function admitZipFile(archivePath, limits, deadline, onEntry) {
+    deadline.check();
+    const opened = await openRootFile({
+        absolutePath: archivePath, rootPath: path.dirname(archivePath),
+        boundaryLabel: "staged ZIP archive", rejectSymlinks: true, rejectHardlinks: true,
+    });
+    if (!opened.ok)
+        throw opened.error ?? new Error("cannot open staged ZIP archive");
+    try {
+        checkSize(opened.stat.size, limits);
+        const scan = scanZipDirectory(opened.stat.size, limits, onEntry);
+        let step = scan.next();
+        while (!step.done) {
+            const { offset, length } = step.value;
+            const bytes = Buffer.alloc(length);
+            let received = 0;
+            while (received < length) {
+                deadline.check();
+                const count = await new Promise((resolve, reject) => {
+                    fs.read(opened.fd, bytes, received, length - received, offset + received, (error, count) => error ? reject(error) : resolve(count));
+                });
+                deadline.check();
+                if (!count)
+                    zipFormat("truncated staged record");
+                received += count;
+            }
+            step = scan.next(bytes);
+        }
+        return step.value;
+    }
+    finally {
+        fs.closeSync(opened.fd);
+    }
+}

package/node_modules/@openclaw/fs-safe/dist/archive-zip-count.d.ts

@@ -0,0 +1,2 @@
+export declare function readZipCentralDirectoryEntryCount(buffer: Buffer | Uint8Array): number | null;
+//# sourceMappingURL=archive-zip-count.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/archive-zip-count.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive-zip-count.d.ts","sourceRoot":"","sources":["../src/archive-zip-count.ts"],"names":[],"mappings":"AA4KA,wBAAgB,iCAAiC,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,GAAG,IAAI,CAU5F"}

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

@@ -0,0 +1,140 @@
+// Conservative public count hint; strict admission must not rely on its fallback.
+const ZIP_EOCD_SIGNATURE = 0x06054b50;
+const ZIP64_EOCD_SIGNATURE = 0x06064b50;
+const ZIP64_EOCD_LOCATOR_SIGNATURE = 0x07064b50;
+const ZIP_EOCD_MIN_BYTES = 22;
+const ZIP_EOCD_MAX_COMMENT_BYTES = 0xffff;
+const ZIP64_ENTRY_COUNT_SENTINEL = 0xffff;
+const ZIP64_UINT32_SENTINEL = 0xffffffff;
+const ZIP_CENTRAL_FILE_HEADER_SIGNATURE = 0x02014b50;
+const ZIP_CENTRAL_FILE_HEADER_MIN_BYTES = 46;
+const ZIP_CENTRAL_FILE_HEADER_NAME_LENGTH_OFFSET = 28;
+const ZIP_CENTRAL_FILE_HEADER_EXTRA_LENGTH_OFFSET = 30;
+const ZIP_CENTRAL_FILE_HEADER_COMMENT_LENGTH_OFFSET = 32;
+const ZIP_EOCD_TOTAL_ENTRIES_OFFSET = 10;
+const ZIP_EOCD_CENTRAL_DIRECTORY_SIZE_OFFSET = 12;
+const ZIP_EOCD_CENTRAL_DIRECTORY_OFFSET_OFFSET = 16;
+const ZIP_EOCD_COMMENT_LENGTH_OFFSET = 20;
+const ZIP64_EOCD_LOCATOR_BYTES = 20;
+const ZIP64_EOCD_OFFSET_OFFSET = 8;
+const ZIP64_EOCD_TOTAL_ENTRIES_OFFSET = 32;
+const ZIP64_EOCD_CENTRAL_DIRECTORY_SIZE_OFFSET = 40;
+const ZIP64_EOCD_CENTRAL_DIRECTORY_OFFSET_OFFSET = 48;
+function asBufferView(buffer) {
+    if (Buffer.isBuffer(buffer)) {
+        return buffer;
+    }
+    return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+}
+function readSafeUInt64LE(buffer, offset) {
+    const value = buffer.readBigUInt64LE(offset);
+    if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+        return Number.MAX_SAFE_INTEGER;
+    }
+    return Number(value);
+}
+function findZipEndOfCentralDirectory(buffer) {
+    if (buffer.byteLength < ZIP_EOCD_MIN_BYTES) {
+        return -1;
+    }
+    const minOffset = Math.max(0, buffer.byteLength - ZIP_EOCD_MIN_BYTES - ZIP_EOCD_MAX_COMMENT_BYTES);
+    for (let offset = buffer.byteLength - ZIP_EOCD_MIN_BYTES; offset >= minOffset; offset -= 1) {
+        if (buffer.readUInt32LE(offset) !== ZIP_EOCD_SIGNATURE) {
+            continue;
+        }
+        const commentLength = buffer.readUInt16LE(offset + ZIP_EOCD_COMMENT_LENGTH_OFFSET);
+        if (offset + ZIP_EOCD_MIN_BYTES + commentLength === buffer.byteLength) {
+            return offset;
+        }
+    }
+    return -1;
+}
+function readZip64CentralDirectoryInfo(buffer, eocdOffset) {
+    const locatorOffset = eocdOffset - ZIP64_EOCD_LOCATOR_BYTES;
+    if (locatorOffset < 0 || buffer.readUInt32LE(locatorOffset) !== ZIP64_EOCD_LOCATOR_SIGNATURE) {
+        return null;
+    }
+    const zip64EocdOffset = readSafeUInt64LE(buffer, locatorOffset + ZIP64_EOCD_OFFSET_OFFSET);
+    if (zip64EocdOffset < 0 ||
+        zip64EocdOffset + ZIP64_EOCD_CENTRAL_DIRECTORY_OFFSET_OFFSET + 8 > buffer.byteLength ||
+        buffer.readUInt32LE(zip64EocdOffset) !== ZIP64_EOCD_SIGNATURE) {
+        return null;
+    }
+    return {
+        declaredEntryCount: readSafeUInt64LE(buffer, zip64EocdOffset + ZIP64_EOCD_TOTAL_ENTRIES_OFFSET),
+        centralDirectorySize: readSafeUInt64LE(buffer, zip64EocdOffset + ZIP64_EOCD_CENTRAL_DIRECTORY_SIZE_OFFSET),
+        centralDirectoryOffset: readSafeUInt64LE(buffer, zip64EocdOffset + ZIP64_EOCD_CENTRAL_DIRECTORY_OFFSET_OFFSET),
+        endOfCentralDirectoryOffset: eocdOffset,
+    };
+}
+function readZipCentralDirectoryInfo(buffer) {
+    const eocdOffset = findZipEndOfCentralDirectory(buffer);
+    if (eocdOffset < 0) {
+        return null;
+    }
+    const declaredEntryCount = buffer.readUInt16LE(eocdOffset + ZIP_EOCD_TOTAL_ENTRIES_OFFSET);
+    const centralDirectorySize = buffer.readUInt32LE(eocdOffset + ZIP_EOCD_CENTRAL_DIRECTORY_SIZE_OFFSET);
+    const centralDirectoryOffset = buffer.readUInt32LE(eocdOffset + ZIP_EOCD_CENTRAL_DIRECTORY_OFFSET_OFFSET);
+    const usesZip64 = declaredEntryCount === ZIP64_ENTRY_COUNT_SENTINEL ||
+        centralDirectorySize === ZIP64_UINT32_SENTINEL ||
+        centralDirectoryOffset === ZIP64_UINT32_SENTINEL;
+    if (usesZip64) {
+        return (readZip64CentralDirectoryInfo(buffer, eocdOffset) ?? {
+            declaredEntryCount,
+            centralDirectoryOffset,
+            centralDirectorySize,
+            endOfCentralDirectoryOffset: eocdOffset,
+        });
+    }
+    return {
+        declaredEntryCount,
+        centralDirectoryOffset,
+        centralDirectorySize,
+        endOfCentralDirectoryOffset: eocdOffset,
+    };
+}
+function countZipCentralDirectoryHeaders(buffer, info) {
+    const start = info.centralDirectoryOffset;
+    const declaredEnd = start + info.centralDirectorySize;
+    const scanEnd = info.endOfCentralDirectoryOffset;
+    if (!Number.isSafeInteger(start) ||
+        !Number.isSafeInteger(declaredEnd) ||
+        !Number.isSafeInteger(scanEnd) ||
+        start < 0 ||
+        declaredEnd < start ||
+        scanEnd < start ||
+        scanEnd > buffer.byteLength) {
+        return null;
+    }
+    let offset = start;
+    let count = 0;
+    while (offset < scanEnd) {
+        if (scanEnd - offset < ZIP_CENTRAL_FILE_HEADER_MIN_BYTES) {
+            break;
+        }
+        if (buffer.readUInt32LE(offset) !== ZIP_CENTRAL_FILE_HEADER_SIGNATURE) {
+            break;
+        }
+        const nameLength = buffer.readUInt16LE(offset + ZIP_CENTRAL_FILE_HEADER_NAME_LENGTH_OFFSET);
+        const extraLength = buffer.readUInt16LE(offset + ZIP_CENTRAL_FILE_HEADER_EXTRA_LENGTH_OFFSET);
+        const commentLength = buffer.readUInt16LE(offset + ZIP_CENTRAL_FILE_HEADER_COMMENT_LENGTH_OFFSET);
+        const nextOffset = offset + ZIP_CENTRAL_FILE_HEADER_MIN_BYTES + nameLength + extraLength + commentLength;
+        if (nextOffset <= offset || nextOffset > scanEnd) {
+            return null;
+        }
+        count += 1;
+        offset = nextOffset;
+    }
+    return count > 0 || info.declaredEntryCount === 0 ? count : null;
+}
+export function readZipCentralDirectoryEntryCount(buffer) {
+    const view = asBufferView(buffer);
+    const info = readZipCentralDirectoryInfo(view);
+    if (!info) {
+        return null;
+    }
+    const countedEntryCount = countZipCentralDirectoryHeaders(view, info);
+    return countedEntryCount === null
+        ? info.declaredEntryCount
+        : Math.max(info.declaredEntryCount, countedEntryCount);
+}

package/node_modules/@openclaw/fs-safe/dist/archive-zip-directory.d.ts

@@ -0,0 +1,15 @@
+import { type ResolvedArchiveExtractLimits } from "./archive-limits.js";
+export type ZipRead = {
+    offset: number;
+    length: number;
+};
+export type ZipScan = Generator<ZipRead, number, Buffer>;
+export type ZipDirectoryEntry = {
+    index: number;
+    creatorSystem: number;
+    externalAttributes: number;
+    size: number;
+    path?: string;
+};
+export declare function scanZipDirectory(size: number, limits: ResolvedArchiveExtractLimits, onEntry?: (entry: ZipDirectoryEntry) => void): ZipScan;
+//# sourceMappingURL=archive-zip-directory.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/archive-zip-directory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive-zip-directory.d.ts","sourceRoot":"","sources":["../src/archive-zip-directory.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,4BAA4B,EAClC,MAAM,qBAAqB,CAAC;AAG7B,MAAM,MAAM,OAAO,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AACzD,MAAM,MAAM,OAAO,GAAG,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AACzD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAmIF,wBAAiB,gBAAgB,CAC/B,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,4BAA4B,EAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GAC/F,OAAO,CAkET"}