@openclaw/openshell-sandbox 2026.9.2 → 2026.9.3

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

@@ -0,0 +1,23 @@
+export class ArchiveSecurityError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+        this.name = "ArchiveSecurityError";
+    }
+}
+export class ArchiveFormatError extends Error {
+    code;
+    constructor(message, options) {
+        super(message, options);
+        this.name = "ArchiveFormatError";
+        this.code = "archive-header-invalid";
+    }
+}
+export function isArchiveFormatErrorMessage(message) {
+    return (message.includes("archive-header-invalid") ||
+        message.includes("archive entry size did not match its manifest"));
+}
+export function isArchiveTarPathErrorMessage(message) {
+    return message.includes("archive-gnu-path-invalid") || message.includes("archive-entry-path-invalid");
+}

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

@@ -0,0 +1,18 @@
+import { Writable } from "node:stream";
+import type { Gunzip } from "node:zlib";
+/** Track physical input, not the sum of bytes consumed across separate writes:
+ * gunzip can resume on a later chunk after leaving an earlier padding gap. */
+export declare class GzipInput extends Writable {
+    private readonly decoder;
+    private position;
+    private firstUnused;
+    constructor(decoder: Gunzip);
+    get tailOffset(): number;
+    _write(chunk: Buffer, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+    _final(callback: (error?: Error | null) => void): void;
+    _destroy(error: Error | null, callback: (error: Error | null) => void): void;
+}
+/** Check the immutable staged suffix from the first unused physical byte,
+ * including later chunks the decoder may have consumed, before returning. */
+export declare function validateGzipContainerTail(filePath: string, consumed: number, signal?: AbortSignal): Promise<void>;
+//# sourceMappingURL=archive-gzip-tail.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"archive-gzip-tail.d.ts","sourceRoot":"","sources":["../src/archive-gzip-tail.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAGxC;8EAC8E;AAC9E,qBAAa,SAAU,SAAQ,QAAQ;IAIzB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAHpC,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,WAAW,CAAqB;IAExC,YAA6B,OAAO,EAAE,MAAM,EAE3C;IAED,IAAI,UAAU,IAAI,MAAM,CAEvB;IAEQ,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,QAAQ,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,GAAG,IAAI,KAAK,IAAI,GAAG,IAAI,CAcxG;IAEQ,MAAM,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,GAAG,IAAI,KAAK,IAAI,GAAG,IAAI,CAE9D;IAEQ,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,KAAK,IAAI,GAAG,IAAI,CAGpF;CACF;AAED;6EAC6E;AAC7E,wBAAsB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAsBvH"}

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

@@ -0,0 +1,74 @@
+import fs from "node:fs/promises";
+import { Writable } from "node:stream";
+import { ArchiveFormatError } from "./archive-errors.js";
+/** Track physical input, not the sum of bytes consumed across separate writes:
+ * gunzip can resume on a later chunk after leaving an earlier padding gap. */
+export class GzipInput extends Writable {
+    decoder;
+    position = 0;
+    firstUnused;
+    constructor(decoder) {
+        super({ highWaterMark: 65536 });
+        this.decoder = decoder;
+    }
+    get tailOffset() {
+        return this.firstUnused ?? this.position;
+    }
+    _write(chunk, _encoding, callback) {
+        const before = this.decoder.bytesWritten;
+        this.decoder.write(chunk, (error) => {
+            if (error) {
+                callback(error);
+                return;
+            }
+            const used = this.decoder.bytesWritten - before;
+            if (!Number.isSafeInteger(used) || used < 0 || used > chunk.length ||
+                !Number.isSafeInteger(this.position + chunk.length)) {
+                callback(new ArchiveFormatError("invalid gzip consumed-input boundary"));
+                return;
+            }
+            if (used < chunk.length)
+                this.firstUnused ??= this.position + used;
+            this.position += chunk.length;
+            callback();
+        });
+    }
+    _final(callback) {
+        this.decoder.end(callback);
+    }
+    _destroy(error, callback) {
+        if (error || !this.writableFinished)
+            this.decoder.destroy(error ?? undefined);
+        callback(error);
+    }
+}
+/** Check the immutable staged suffix from the first unused physical byte,
+ * including later chunks the decoder may have consumed, before returning. */
+export async function validateGzipContainerTail(filePath, consumed, signal) {
+    signal?.throwIfAborted();
+    const handle = await fs.open(filePath, "r");
+    try {
+        const { size } = await handle.stat();
+        if (!Number.isSafeInteger(consumed) || consumed <= 0 || consumed > size) {
+            throw new ArchiveFormatError("invalid gzip consumed-input boundary");
+        }
+        if (consumed === size)
+            return;
+        const buffer = Buffer.allocUnsafe(65536);
+        let position = consumed;
+        while (position < size) {
+            signal?.throwIfAborted();
+            const { bytesRead } = await handle.read(buffer, 0, Math.min(buffer.length, size - position), position);
+            signal?.throwIfAborted();
+            if (bytesRead === 0)
+                throw new ArchiveFormatError("truncated gzip container padding");
+            if (buffer.subarray(0, bytesRead).some((byte) => byte !== 0)) {
+                throw new ArchiveFormatError("nonzero gzip container padding");
+            }
+            position += bytesRead;
+        }
+    }
+    finally {
+        await handle.close();
+    }
+}

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

@@ -0,0 +1,19 @@
+import type { FileHandle } from "node:fs/promises";
+import type { ExtractionDeadline } from "./archive-deadline.js";
+import { type ResolvedArchiveExtractLimits } from "./archive-limits.js";
+export type StagedArchiveFile = {
+    path: string;
+    cleanup: () => Promise<void>;
+};
+export declare function writeFileHandleFully(params: {
+    handle: FileHandle;
+    buffer: Buffer;
+    bytes: number;
+    deadline: ExtractionDeadline;
+}): Promise<void>;
+export declare function stageArchiveFileForExtraction(params: {
+    archivePath: string;
+    limits: ResolvedArchiveExtractLimits;
+    deadline: ExtractionDeadline;
+}): Promise<StagedArchiveFile>;
+//# sourceMappingURL=archive-input.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"archive-input.d.ts","sourceRoot":"","sources":["../src/archive-input.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAGnD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAGL,KAAK,4BAA4B,EAClC,MAAM,qBAAqB,CAAC;AAM7B,MAAM,MAAM,iBAAiB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,CAAC;AAM/E,wBAAsB,oBAAoB,CAAC,MAAM,EAAE;IACjD,MAAM,EAAE,UAAU,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,kBAAkB,CAAC;CAC9B,GAAG,OAAO,CAAC,IAAI,CAAC,CAchB;AAED,wBAAsB,6BAA6B,CAAC,MAAM,EAAE;IAC1D,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,4BAA4B,CAAC;IACrC,QAAQ,EAAE,kBAAkB,CAAC;CAC9B,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAiE7B"}

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

@@ -0,0 +1,92 @@
+import { constants as fsConstants } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { ARCHIVE_LIMIT_ERROR_CODE, ArchiveLimitError, } from "./archive-limits.js";
+import { FsSafeError } from "./errors.js";
+import { inspectFileIdentity } from "./strict-file-identity.js";
+import { resolveReadOpenFlags } from "./read-open-flags.js";
+import { tempFile } from "./temp-target.js";
+async function closeFileHandle(handle) {
+    if (handle)
+        await handle.close().catch(() => undefined);
+}
+export async function writeFileHandleFully(params) {
+    let offset = 0;
+    while (offset < params.bytes) {
+        params.deadline.check();
+        const { bytesWritten } = await params.handle.write(params.buffer, offset, params.bytes - offset);
+        if (bytesWritten <= 0) {
+            throw new Error("archive staging write made no progress");
+        }
+        offset += bytesWritten;
+    }
+}
+export async function stageArchiveFileForExtraction(params) {
+    params.deadline.check();
+    const sourcePath = path.resolve(params.archivePath);
+    const initialStat = await inspectFileIdentity(async () => {
+        const stat = await fs.lstat(sourcePath, { bigint: true });
+        if (stat.isSymbolicLink() || !stat.isFile()) {
+            throw new Error(`archive is not a regular file: ${params.archivePath}`);
+        }
+        return stat;
+    });
+    if (initialStat.size > params.limits.maxArchiveBytes) {
+        throw new ArchiveLimitError(ARCHIVE_LIMIT_ERROR_CODE.ARCHIVE_SIZE_EXCEEDS_LIMIT);
+    }
+    const handle = await fs.open(sourcePath, resolveReadOpenFlags());
+    let staged;
+    let output;
+    try {
+        staged = await tempFile({
+            prefix: "fs-safe-archive-input",
+            fileName: path.basename(sourcePath),
+        });
+        const opened = await inspectFileIdentity(async () => {
+            const stat = await handle.stat({ bigint: true });
+            if (!stat.isFile())
+                throw new Error("archive changed during validation");
+            return stat;
+        }, initialStat);
+        await inspectFileIdentity(async () => {
+            const stat = await fs.lstat(sourcePath, { bigint: true });
+            if (stat.isSymbolicLink() || !stat.isFile())
+                throw new Error("archive changed during validation");
+            return stat;
+        }, opened);
+        const flags = fsConstants.O_WRONLY |
+            fsConstants.O_CREAT |
+            fsConstants.O_EXCL |
+            (process.platform !== "win32" && "O_NOFOLLOW" in fsConstants
+                ? fsConstants.O_NOFOLLOW
+                : 0);
+        output = await fs.open(staged.path, flags, 0o600);
+        const buffer = Buffer.allocUnsafe(64 * 1024);
+        let written = 0;
+        while (true) {
+            params.deadline.check();
+            const { bytesRead } = await handle.read(buffer, 0, buffer.length, null);
+            if (bytesRead === 0)
+                break;
+            written += bytesRead;
+            if (written > params.limits.maxArchiveBytes) {
+                throw new ArchiveLimitError(ARCHIVE_LIMIT_ERROR_CODE.ARCHIVE_SIZE_EXCEEDS_LIMIT);
+            }
+            await writeFileHandleFully({ handle: output, buffer, bytes: bytesRead, deadline: params.deadline });
+        }
+        await output.close();
+        output = undefined;
+        return staged;
+    }
+    catch (error) {
+        await closeFileHandle(output);
+        await staged?.cleanup().catch(() => undefined);
+        if (error instanceof FsSafeError && error.code === "path-mismatch") {
+            throw new FsSafeError("path-mismatch", "archive changed during validation", { cause: error });
+        }
+        throw error;
+    }
+    finally {
+        await closeFileHandle(handle);
+    }
+}

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

@@ -0,0 +1,9 @@
+export type ArchiveKind = "tar" | "tar-bzip2" | "tar-zstd" | "zip";
+export declare function resolveArchiveKind(filePath: string): ArchiveKind | null;
+type ResolvePackedRootDirOptions = {
+    rootMarkers?: string[];
+};
+export declare function resolvePackedRootDir(extractDir: string, options?: ResolvePackedRootDirOptions): Promise<string>;
+export declare function assertPortableArchiveKind(kind: ArchiveKind): void;
+export {};
+//# sourceMappingURL=archive-kind.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"archive-kind.d.ts","sourceRoot":"","sources":["../src/archive-kind.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,WAAW,GAAG,UAAU,GAAG,KAAK,CAAC;AAmBnE,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAcvE;AAED,KAAK,2BAA2B,GAAG;IACjC,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAkBF,wBAAsB,oBAAoB,CACxC,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,2BAA2B,GACpC,OAAO,CAAC,MAAM,CAAC,CA4BjB;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAQjE"}

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

@@ -0,0 +1,82 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { FsSafeError } from "./errors.js";
+import { getNativeBinding } from "./native.js";
+import { normalizeLowercaseStringOrEmpty } from "./string-coerce.js";
+const TAR_SUFFIXES = [".tgz", ".tar.gz", ".tar"];
+const NATIVE_TAR_SUFFIXES = [
+    { suffixes: [".tbz2", ".tbz", ".tar.bz2"], kind: "tar-bzip2" },
+    { suffixes: [".tzst", ".tar.zst", ".tar.zstd"], kind: "tar-zstd" },
+];
+function requireNativeArchiveKind(kind) {
+    if (!getNativeBinding()) {
+        throw new FsSafeError("helper-unavailable", `${kind} archives require the matching optional native platform package; ` +
+            "install @openclaw/fs-safe with optional dependencies enabled on a supported platform and use FS_SAFE_NATIVE_MODE=auto or require");
+    }
+    return kind;
+}
+export function resolveArchiveKind(filePath) {
+    const lower = normalizeLowercaseStringOrEmpty(filePath);
+    if (lower.endsWith(".zip")) {
+        return "zip";
+    }
+    for (const { suffixes, kind } of NATIVE_TAR_SUFFIXES) {
+        if (suffixes.some((suffix) => lower.endsWith(suffix))) {
+            return requireNativeArchiveKind(kind);
+        }
+    }
+    if (TAR_SUFFIXES.some((suffix) => lower.endsWith(suffix))) {
+        return "tar";
+    }
+    return null;
+}
+async function hasPackedRootMarker(extractDir, rootMarkers) {
+    for (const marker of rootMarkers) {
+        const trimmed = marker.trim();
+        if (!trimmed) {
+            continue;
+        }
+        try {
+            await fs.stat(path.join(extractDir, trimmed));
+            return true;
+        }
+        catch {
+            // ignore
+        }
+    }
+    return false;
+}
+export async function resolvePackedRootDir(extractDir, options) {
+    const direct = path.join(extractDir, "package");
+    try {
+        const stat = await fs.stat(direct);
+        if (stat.isDirectory()) {
+            return direct;
+        }
+    }
+    catch {
+        // ignore
+    }
+    if ((options?.rootMarkers?.length ?? 0) > 0) {
+        const hasMarker = await hasPackedRootMarker(extractDir, options?.rootMarkers ?? []);
+        if (hasMarker) {
+            return extractDir;
+        }
+    }
+    const entries = await fs.readdir(extractDir, { withFileTypes: true });
+    const dirs = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    if (dirs.length !== 1) {
+        throw new Error(`unexpected archive layout (dirs: ${dirs.join(", ")})`);
+    }
+    const onlyDir = dirs[0];
+    if (!onlyDir) {
+        throw new Error("unexpected archive layout (no package dir found)");
+    }
+    return path.join(extractDir, onlyDir);
+}
+export function assertPortableArchiveKind(kind) {
+    if (kind === "tar-zstd" || kind === "tar-bzip2") {
+        throw new FsSafeError("helper-unavailable", `${kind} archives require the matching optional native platform package; ` +
+            "install @openclaw/fs-safe with optional dependencies enabled on a supported platform and use FS_SAFE_NATIVE_MODE=auto or require");
+    }
+}

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

@@ -0,0 +1,57 @@
+import { Transform } from "node:stream";
+export type ArchiveExtractLimits = {
+    /**
+     * Max archive file bytes (compressed).
+     */
+    maxArchiveBytes?: number;
+    /** Max logical archive entries, including skipped/stripped members. */
+    maxEntries?: number;
+    /** Max extracted bytes across entries accepted after strip/filter policy. */
+    maxExtractedBytes?: number;
+    /** Max bytes in an entry accepted after strip/filter policy. */
+    maxEntryBytes?: number;
+    /** Max bytes in one PAX, GNU long-name, or related TAR metadata entry. */
+    maxMetaEntryBytes?: number;
+    /** Max path components in one extracted entry after stripComponents. */
+    maxEntryPathComponents?: number;
+};
+export declare const DEFAULT_MAX_ARCHIVE_BYTES_ZIP: number;
+export declare const DEFAULT_MAX_ENTRIES = 50000;
+export declare const DEFAULT_MAX_EXTRACTED_BYTES: number;
+export declare const DEFAULT_MAX_ENTRY_BYTES: number;
+export declare const DEFAULT_MAX_META_ENTRY_BYTES: number;
+export declare const DEFAULT_MAX_ENTRY_PATH_COMPONENTS = 256;
+export declare const ARCHIVE_LIMIT_ERROR_CODE: {
+    readonly ARCHIVE_SIZE_EXCEEDS_LIMIT: "archive-size-exceeds-limit";
+    readonly ENTRY_COUNT_EXCEEDS_LIMIT: "archive-entry-count-exceeds-limit";
+    readonly ENTRY_EXTRACTED_SIZE_EXCEEDS_LIMIT: "archive-entry-extracted-size-exceeds-limit";
+    readonly EXTRACTED_SIZE_EXCEEDS_LIMIT: "archive-extracted-size-exceeds-limit";
+    readonly DECODED_SIZE_EXCEEDS_LIMIT: "archive-decoded-size-exceeds-limit";
+    readonly META_ENTRY_SIZE_EXCEEDS_LIMIT: "archive-meta-entry-size-exceeds-limit";
+    readonly MANIFEST_SIZE_EXCEEDS_LIMIT: "archive-manifest-size-exceeds-limit";
+    readonly ENTRY_PATH_COMPONENTS_EXCEEDS_LIMIT: "archive-entry-path-components-exceeds-limit";
+};
+export type ArchiveLimitErrorCode = (typeof ARCHIVE_LIMIT_ERROR_CODE)[keyof typeof ARCHIVE_LIMIT_ERROR_CODE];
+export declare class ArchiveLimitError extends Error {
+    readonly code: ArchiveLimitErrorCode;
+    constructor(code: ArchiveLimitErrorCode);
+}
+export type ResolvedArchiveExtractLimits = Required<ArchiveExtractLimits>;
+export type TarMeterLimits = Pick<ResolvedArchiveExtractLimits, "maxEntries" | "maxMetaEntryBytes"> & {
+    maxDecodedBytes: number;
+    maxManifestBytes: number;
+};
+export declare const MAX_TAR_MANIFEST_BYTES: number;
+export declare function resolveTarMeterLimits(options?: ArchiveExtractLimits): TarMeterLimits;
+export declare function resolveExtractLimits(limits?: ArchiveExtractLimits): ResolvedArchiveExtractLimits;
+export declare function assertArchiveEntryPathComponentsWithinLimit(entryPath: string, limits: ResolvedArchiveExtractLimits): void;
+export declare function assertArchiveEntryCountWithinLimit(entryCount: number, limits: ResolvedArchiveExtractLimits): void;
+export declare function createByteBudgetTracker(limits: ResolvedArchiveExtractLimits): {
+    startEntry: () => void;
+    addBytes: (bytes: number) => void;
+    addEntrySize: (size: number) => void;
+};
+export declare function createExtractBudgetTransform(params: {
+    onChunkBytes: (bytes: number) => void;
+}): Transform;
+//# sourceMappingURL=archive-limits.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"archive-limits.d.ts","sourceRoot":"","sources":["../src/archive-limits.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,MAAM,MAAM,oBAAoB,GAAG;IACjC;;OAEG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,uEAAuE;IACvE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,6EAA6E;IAC7E,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,gEAAgE;IAChE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,0EAA0E;IAC1E,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,wEAAwE;IACxE,sBAAsB,CAAC,EAAE,MAAM,CAAC;CACjC,CAAC;AAEF,eAAO,MAAM,6BAA6B,QAAoB,CAAC;AAC/D,eAAO,MAAM,mBAAmB,QAAS,CAAC;AAC1C,eAAO,MAAM,2BAA2B,QAAoB,CAAC;AAC7D,eAAO,MAAM,uBAAuB,QAAoB,CAAC;AACzD,eAAO,MAAM,4BAA4B,QAAc,CAAC;AACxD,eAAO,MAAM,iCAAiC,MAAM,CAAC;AAErD,eAAO,MAAM,wBAAwB;aACnC,0BAA0B,EAAE,4BAA4B;aACxD,yBAAyB,EAAE,mCAAmC;aAC9D,kCAAkC,EAAE,4CAA4C;aAChF,4BAA4B,EAAE,sCAAsC;aACpE,0BAA0B,EAAE,oCAAoC;aAChE,6BAA6B,EAAE,uCAAuC;aACtE,2BAA2B,EAAE,qCAAqC;aAClE,mCAAmC,EAAE,6CAA6C;CAC1E,CAAC;AAEX,MAAM,MAAM,qBAAqB,GAC/B,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,OAAO,wBAAwB,CAAC,CAAC;AAiB3E,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,QAAQ,CAAC,IAAI,EAAE,qBAAqB,CAAC;IAErC,YAAY,IAAI,EAAE,qBAAqB,EAItC;CACF;AAED,MAAM,MAAM,4BAA4B,GAAG,QAAQ,CAAC,oBAAoB,CAAC,CAAC;AAE1E,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,4BAA4B,EAC5D,YAAY,GAAG,mBAAmB,CAAC,GAAG;IAAE,eAAe,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9F,eAAO,MAAM,sBAAsB,QAAmB,CAAC;AAEvD,wBAAgB,qBAAqB,CAAC,OAAO,CAAC,EAAE,oBAAoB,GAAG,cAAc,CAkBpF;AAUD,wBAAgB,oBAAoB,CAClC,MAAM,CAAC,EAAE,oBAAoB,GAC5B,4BAA4B,CAY9B;AAED,wBAAgB,2CAA2C,CACzD,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,4BAA4B,GACnC,IAAI,CASN;AAED,wBAAgB,kCAAkC,CAChD,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,4BAA4B,QAKrC;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,4BAA4B,GAAG;IAC7E,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACtC,CAiCA;AAED,wBAAgB,4BAA4B,CAAC,MAAM,EAAE;IACnD,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACvC,GAAG,SAAS,CAYZ"}

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

@@ -0,0 +1,131 @@
+import { Transform } from "node:stream";
+export const DEFAULT_MAX_ARCHIVE_BYTES_ZIP = 256 * 1024 * 1024;
+export const DEFAULT_MAX_ENTRIES = 50_000;
+export const DEFAULT_MAX_EXTRACTED_BYTES = 512 * 1024 * 1024;
+export const DEFAULT_MAX_ENTRY_BYTES = 256 * 1024 * 1024;
+export const DEFAULT_MAX_META_ENTRY_BYTES = 1024 * 1024;
+export const DEFAULT_MAX_ENTRY_PATH_COMPONENTS = 256;
+export const ARCHIVE_LIMIT_ERROR_CODE = {
+    ARCHIVE_SIZE_EXCEEDS_LIMIT: "archive-size-exceeds-limit",
+    ENTRY_COUNT_EXCEEDS_LIMIT: "archive-entry-count-exceeds-limit",
+    ENTRY_EXTRACTED_SIZE_EXCEEDS_LIMIT: "archive-entry-extracted-size-exceeds-limit",
+    EXTRACTED_SIZE_EXCEEDS_LIMIT: "archive-extracted-size-exceeds-limit",
+    DECODED_SIZE_EXCEEDS_LIMIT: "archive-decoded-size-exceeds-limit",
+    META_ENTRY_SIZE_EXCEEDS_LIMIT: "archive-meta-entry-size-exceeds-limit",
+    MANIFEST_SIZE_EXCEEDS_LIMIT: "archive-manifest-size-exceeds-limit",
+    ENTRY_PATH_COMPONENTS_EXCEEDS_LIMIT: "archive-entry-path-components-exceeds-limit",
+};
+const ARCHIVE_LIMIT_ERROR_MESSAGE = {
+    [ARCHIVE_LIMIT_ERROR_CODE.ARCHIVE_SIZE_EXCEEDS_LIMIT]: "archive size exceeds limit",
+    [ARCHIVE_LIMIT_ERROR_CODE.ENTRY_COUNT_EXCEEDS_LIMIT]: "archive entry count exceeds limit",
+    [ARCHIVE_LIMIT_ERROR_CODE.ENTRY_EXTRACTED_SIZE_EXCEEDS_LIMIT]: "archive entry extracted size exceeds limit",
+    [ARCHIVE_LIMIT_ERROR_CODE.EXTRACTED_SIZE_EXCEEDS_LIMIT]: "archive extracted size exceeds limit",
+    [ARCHIVE_LIMIT_ERROR_CODE.DECODED_SIZE_EXCEEDS_LIMIT]: "archive decoded size exceeds limit",
+    [ARCHIVE_LIMIT_ERROR_CODE.META_ENTRY_SIZE_EXCEEDS_LIMIT]: "archive metadata entry size exceeds limit",
+    [ARCHIVE_LIMIT_ERROR_CODE.MANIFEST_SIZE_EXCEEDS_LIMIT]: "archive manifest size exceeds limit",
+    [ARCHIVE_LIMIT_ERROR_CODE.ENTRY_PATH_COMPONENTS_EXCEEDS_LIMIT]: "archive entry path components exceed limit",
+};
+export class ArchiveLimitError extends Error {
+    code;
+    constructor(code) {
+        super(ARCHIVE_LIMIT_ERROR_MESSAGE[code]);
+        this.name = "ArchiveLimitError";
+        this.code = code;
+    }
+}
+export const MAX_TAR_MANIFEST_BYTES = 64 * 1024 * 1024;
+export function resolveTarMeterLimits(options) {
+    const limits = resolveExtractLimits(options);
+    const payload = Math.min(limits.maxExtractedBytes, Number.MAX_SAFE_INTEGER);
+    const overhead = Math.min(limits.maxArchiveBytes, Number.MAX_SAFE_INTEGER);
+    // Saturate before multiplying, including when public limits approach MAX_VALUE.
+    const pathBytes = Math.max(256, Math.min(limits.maxMetaEntryBytes, Math.min(Math.max(1, limits.maxEntryPathComponents), MAX_TAR_MANIFEST_BYTES / 256) * 256));
+    const perEntry = 64 + 2 * pathBytes;
+    const maxManifestBytes = limits.maxEntries > Math.floor(MAX_TAR_MANIFEST_BYTES / perEntry)
+        ? MAX_TAR_MANIFEST_BYTES : limits.maxEntries * perEntry;
+    // TAR sizes are safe integers; native logical entry counts use u32.
+    return {
+        maxEntries: Math.min(limits.maxEntries, 0xffff_ffff),
+        maxMetaEntryBytes: Math.min(limits.maxMetaEntryBytes, Number.MAX_SAFE_INTEGER),
+        maxManifestBytes,
+        maxDecodedBytes: payload > Number.MAX_SAFE_INTEGER - overhead
+            ? Number.MAX_SAFE_INTEGER : payload + overhead,
+    };
+}
+function clampLimit(value) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return undefined;
+    }
+    const v = Math.floor(value);
+    return v >= 0 ? v : undefined;
+}
+export function resolveExtractLimits(limits) {
+    // Defaults: defensive, but should not break normal installs.
+    return {
+        maxArchiveBytes: clampLimit(limits?.maxArchiveBytes) ?? DEFAULT_MAX_ARCHIVE_BYTES_ZIP,
+        maxEntries: clampLimit(limits?.maxEntries) ?? DEFAULT_MAX_ENTRIES,
+        maxExtractedBytes: clampLimit(limits?.maxExtractedBytes) ?? DEFAULT_MAX_EXTRACTED_BYTES,
+        maxEntryBytes: clampLimit(limits?.maxEntryBytes) ?? DEFAULT_MAX_ENTRY_BYTES,
+        maxMetaEntryBytes: clampLimit(limits?.maxMetaEntryBytes) ?? DEFAULT_MAX_META_ENTRY_BYTES,
+        maxEntryPathComponents: clampLimit(limits?.maxEntryPathComponents) ?? DEFAULT_MAX_ENTRY_PATH_COMPONENTS,
+    };
+}
+export function assertArchiveEntryPathComponentsWithinLimit(entryPath, limits) {
+    const components = entryPath
+        .split(/[\\/]+/u)
+        .filter((component) => component.length > 0 && component !== ".").length;
+    if (components > limits.maxEntryPathComponents) {
+        throw new ArchiveLimitError(ARCHIVE_LIMIT_ERROR_CODE.ENTRY_PATH_COMPONENTS_EXCEEDS_LIMIT);
+    }
+}
+export function assertArchiveEntryCountWithinLimit(entryCount, limits) {
+    if (entryCount > limits.maxEntries) {
+        throw new ArchiveLimitError(ARCHIVE_LIMIT_ERROR_CODE.ENTRY_COUNT_EXCEEDS_LIMIT);
+    }
+}
+export function createByteBudgetTracker(limits) {
+    let entryBytes = 0;
+    let extractedBytes = 0;
+    const addBytes = (bytes) => {
+        const b = Math.max(0, Math.floor(bytes));
+        if (b === 0) {
+            return;
+        }
+        entryBytes += b;
+        if (entryBytes > limits.maxEntryBytes) {
+            throw new ArchiveLimitError(ARCHIVE_LIMIT_ERROR_CODE.ENTRY_EXTRACTED_SIZE_EXCEEDS_LIMIT);
+        }
+        extractedBytes += b;
+        if (extractedBytes > limits.maxExtractedBytes) {
+            throw new ArchiveLimitError(ARCHIVE_LIMIT_ERROR_CODE.EXTRACTED_SIZE_EXCEEDS_LIMIT);
+        }
+    };
+    return {
+        startEntry() {
+            entryBytes = 0;
+        },
+        addBytes,
+        addEntrySize(size) {
+            const s = Math.max(0, Math.floor(size));
+            if (s > limits.maxEntryBytes) {
+                throw new ArchiveLimitError(ARCHIVE_LIMIT_ERROR_CODE.ENTRY_EXTRACTED_SIZE_EXCEEDS_LIMIT);
+            }
+            // Tar budgets are based on the header-declared size.
+            addBytes(s);
+        },
+    };
+}
+export function createExtractBudgetTransform(params) {
+    return new Transform({
+        transform(chunk, _encoding, callback) {
+            try {
+                const buf = chunk instanceof Buffer ? chunk : Buffer.from(chunk);
+                params.onChunkBytes(buf.byteLength);
+                callback(null, buf);
+            }
+            catch (err) {
+                callback(err instanceof Error ? err : new Error(String(err)));
+            }
+        },
+    });
+}

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

@@ -0,0 +1,18 @@
+import { type ExtractionDeadline } from "./archive-deadline.js";
+export type ArchivePublicationEntry = {
+    path: string;
+    kind: "file" | "directory";
+    mode: number;
+};
+type MergeParams = {
+    sourceDir: string;
+    destinationDir: string;
+    destinationRealDir: string;
+    deadline?: ExtractionDeadline;
+};
+export declare function mergePlannedArchiveIntoDestination(params: MergeParams & {
+    entries: readonly ArchivePublicationEntry[];
+}): Promise<void>;
+export declare function mergeExtractedTreeIntoDestination(params: MergeParams): Promise<void>;
+export {};
+//# sourceMappingURL=archive-merge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"archive-merge.d.ts","sourceRoot":"","sources":["../src/archive-merge.ts"],"names":[],"mappings":"AAEA,OAAO,EAAoC,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAelG,MAAM,MAAM,uBAAuB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AACjG,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,EAAE,kBAAkB,CAAC;CAC/B,CAAC;AAEF,wBAAsB,kCAAkC,CACtD,MAAM,EAAE,WAAW,GAAG;IAAE,OAAO,EAAE,SAAS,uBAAuB,EAAE,CAAA;CAAE,GACpE,OAAO,CAAC,IAAI,CAAC,CAEf;AAED,wBAAsB,iCAAiC,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAE1F"}