@openclaw/openshell-sandbox 2026.9.1 → 2026.9.3

package/node_modules/@openclaw/fs-safe/dist/directory-mode-node.js

@@ -0,0 +1,93 @@
+import { constants } from "node:fs";
+import fs from "node:fs/promises";
+import { FsSafeError } from "./errors.js";
+import { inspectDirectoryIdentity } from "./directory-guard.js";
+import { inspectFileIdentity } from "./strict-file-identity.js";
+import { assertOwnedDirectory, ownDirectoryMode } from "./directory-mode-owner.js";
+function searchOnlyFlags() {
+    if (process.arch !== "x64" && process.arch !== "arm64")
+        return undefined;
+    // Darwin SDK O_SEARCH = O_EXEC (0x40000000) | O_DIRECTORY, on x64/arm64.
+    if (process.platform === "darwin")
+        return { flags: 0x40000000, proc: false };
+    // Linux x86-64/aarch64 UAPI O_PATH = 010000000. Not a usable fchmod fd.
+    if (process.platform === "linux")
+        return { flags: 0x200000, proc: true };
+    return undefined;
+}
+/** Real Node only: injected filesystem adapters must retain descriptor-chmod semantics. */
+export async function pinNodeDirectoryForMode(dirPath, options = {}) {
+    const { ownerUid } = options;
+    const assertOwner = (stat) => {
+        if (ownerUid !== undefined && stat.uid !== BigInt(ownerUid)) {
+            throw new FsSafeError("not-owned", "directory mode target must retain its expected owner");
+        }
+    };
+    const expected = await inspectDirectoryIdentity(dirPath, options.expectedIdentity);
+    assertOwner(expected);
+    if (process.platform === "win32") {
+        // POSIX mode enforcement is unsupported; retain strict path identity checks.
+        return ownDirectoryMode({
+            inspect: async () => { assertOwner(await inspectDirectoryIdentity(dirPath, expected)); return 0; },
+            chmod: async () => undefined, close: async () => undefined, ignoreChmodError: true,
+        });
+    }
+    if ([constants.O_DIRECTORY, constants.O_NOFOLLOW, constants.O_NONBLOCK, constants.O_RDONLY]
+        .some((flag) => typeof flag !== "number")) {
+        throw new FsSafeError("helper-unavailable", "no-follow directory mode descriptors are unavailable");
+    }
+    const flags = constants.O_DIRECTORY | constants.O_NOFOLLOW | constants.O_NONBLOCK;
+    let proc = false;
+    const handle = await fs.open(dirPath, constants.O_RDONLY | flags).catch(async (error) => {
+        if (error.code !== "EACCES")
+            throw error;
+        const route = searchOnlyFlags();
+        if (!route)
+            throw error;
+        proc = route.proc;
+        return await fs.open(dirPath, route.flags | flags);
+    });
+    try {
+        const inspect = async () => {
+            const opened = await inspectFileIdentity(() => handle.stat({ bigint: true }), expected);
+            assertOwnedDirectory(expected, opened);
+            assertOwner(opened);
+            await inspectDirectoryIdentity(dirPath, expected);
+            return Number(opened.mode & 4095n);
+        };
+        const procPath = `/proc/self/fd/${handle.fd}`;
+        const assertProcAuthority = async () => {
+            // Authenticate the fd namespace, not the followed target's filesystem.
+            // This trusts host mount-namespace integrity, not privileged mount replacement.
+            const namespace = await fs.statfs("/proc/self/fd", { bigint: true });
+            if (namespace.type !== 0x9fa0n) {
+                throw new FsSafeError("path-mismatch", "directory mode requires a trusted procfs fd namespace");
+            }
+            const opened = await inspectFileIdentity(() => handle.stat({ bigint: true }), expected);
+            const followed = await inspectFileIdentity(() => fs.stat(procPath, { bigint: true }), expected);
+            assertOwnedDirectory(opened, followed);
+            assertOwner(opened);
+            assertOwner(followed);
+        };
+        const owner = ownDirectoryMode({
+            inspect,
+            prepareChmod: proc ? assertProcAuthority : undefined,
+            verifyChmod: proc ? assertProcAuthority : undefined,
+            async chmod(mode) {
+                if (proc) {
+                    await fs.chmod(procPath, mode);
+                }
+                else {
+                    await handle.chmod(mode);
+                }
+            },
+            close: () => handle.close(),
+        });
+        await owner.verify();
+        return owner;
+    }
+    catch (error) {
+        await handle.close();
+        throw error;
+    }
+}

package/node_modules/@openclaw/fs-safe/dist/directory-mode-owner.d.ts

@@ -0,0 +1,21 @@
+import type { BigIntStats, Stats } from "node:fs";
+export type DirectoryModeChecks = {
+    check?: () => void;
+    beforeChmod?: () => Promise<void>;
+};
+export type DirectoryModeOwner = {
+    verify(check?: () => void): Promise<void>;
+    apply(mode: number, checks?: DirectoryModeChecks): Promise<void>;
+    close(): Promise<void>;
+};
+export declare function assertOwnedDirectory(expected: Stats | BigIntStats, actual: Stats | BigIntStats): void;
+/** Serializes use and close: even a queued path-based fd operation retains its descriptor. */
+export declare function ownDirectoryMode(params: {
+    inspect: () => Promise<number>;
+    chmod: (mode: number) => Promise<void>;
+    prepareChmod?: () => Promise<void>;
+    verifyChmod?: () => Promise<void>;
+    close: () => Promise<void>;
+    ignoreChmodError?: boolean;
+}): DirectoryModeOwner;
+//# sourceMappingURL=directory-mode-owner.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/directory-mode-owner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directory-mode-owner.d.ts","sourceRoot":"","sources":["../src/directory-mode-owner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAIlD,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,CAAC,EAAE,MAAM,IAAI,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACnC,CAAC;AACF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,CAAC,KAAK,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB,CAAC;AAEF,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,KAAK,GAAG,WAAW,EAAE,MAAM,EAAE,KAAK,GAAG,WAAW,GAAG,IAAI,CAOrG;AAED,8FAA8F;AAC9F,wBAAgB,gBAAgB,CAAC,MAAM,EAAE;IACvC,OAAO,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IAC/B,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACvC,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,WAAW,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAClC,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,GAAG,kBAAkB,CAwDrB"}

package/node_modules/@openclaw/fs-safe/dist/directory-mode-owner.js

@@ -0,0 +1,78 @@
+import { FsSafeError } from "./errors.js";
+import { sameFileIdentityForCleanup } from "./file-identity.js";
+export function assertOwnedDirectory(expected, actual) {
+    if (actual.isSymbolicLink() || !actual.isDirectory()) {
+        throw new FsSafeError("not-file", "directory mode target must be a real directory");
+    }
+    if (!sameFileIdentityForCleanup(expected, actual)) {
+        throw new FsSafeError("path-mismatch", "directory changed before its mode could be applied");
+    }
+}
+/** Serializes use and close: even a queued path-based fd operation retains its descriptor. */
+export function ownDirectoryMode(params) {
+    let pending = Promise.resolve();
+    let closing;
+    const enqueue = (run) => {
+        if (closing)
+            return Promise.reject(new FsSafeError("path-mismatch", "directory mode owner is closed"));
+        const operation = pending.then(run);
+        pending = operation.catch(() => undefined);
+        return operation;
+    };
+    return {
+        verify: (check) => enqueue(async () => {
+            check?.();
+            await params.inspect();
+            check?.();
+        }),
+        apply: (mode, checks = {}) => enqueue(async () => {
+            // inspect() reports permission bits only; chmod ignores file-type bits,
+            // so tolerate raw stat modes (e.g. S_IFDIR | 0o755) by masking up front.
+            mode &= 0o7777;
+            checks.check?.();
+            const currentMode = await params.inspect();
+            checks.check?.();
+            if (currentMode === mode && !checks.beforeChmod && !checks.check)
+                return;
+            if (currentMode !== mode) {
+                await params.prepareChmod?.();
+                checks.check?.();
+            }
+            await checks.beforeChmod?.();
+            checks.check?.();
+            // Hooks/ancestor checks can yield; recheck the original named association.
+            await params.inspect();
+            checks.check?.();
+            let dispatchDeadlineError;
+            if (currentMode !== mode) {
+                try {
+                    checks.check?.();
+                    await params.chmod(mode);
+                }
+                catch (error) {
+                    if (!params.ignoreChmodError)
+                        throw error;
+                }
+                // Expiry cannot release the fd while post-dispatch verification is pending.
+                try {
+                    checks.check?.();
+                }
+                catch (error) {
+                    dispatchDeadlineError = error;
+                }
+                await params.verifyChmod?.();
+            }
+            const finalMode = await params.inspect();
+            if (dispatchDeadlineError)
+                throw dispatchDeadlineError;
+            checks.check?.();
+            if (!params.ignoreChmodError && finalMode !== mode) {
+                throw new FsSafeError("path-mismatch", "directory final mode could not be verified");
+            }
+        }),
+        close() {
+            closing ??= pending.then(params.close);
+            return closing;
+        },
+    };
+}

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

@@ -0,0 +1,4 @@
+export { ensureDurableDirectory, pinDirectory, syncDirectory, syncDirectoryBestEffort, syncDirectoryBestEffortSync, syncDirectorySync, type DirectoryReceipt, type DirectorySyncOutcome, type DurableDirectoryReceipt, type EnsureDurableDirectoryOptions, type PinnedDirectory, } from "./directory-durability.js";
+export { isHardlinkFallbackError, publishFileExclusive, type PublishFileExclusiveResult, type PublishFileExclusiveStrategy, type PublishFileExclusiveCleanup, type PublishFileExclusiveDirectorySyncFailure, type PublishFileExclusiveFailureDetails, type PublishFileExclusiveFailurePhase, type PublishFileExclusiveSyncFailurePolicy, } from "./publish-file.js";
+export { sha256File, type Sha256FileInput, type Sha256FileResult, } from "./file-hash.js";
+//# sourceMappingURL=durability.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"durability.d.ts","sourceRoot":"","sources":["../src/durability.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,YAAY,EACZ,aAAa,EACb,uBAAuB,EACvB,2BAA2B,EAC3B,iBAAiB,EACjB,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,KAAK,uBAAuB,EAC5B,KAAK,6BAA6B,EAClC,KAAK,eAAe,GACrB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,KAAK,0BAA0B,EAC/B,KAAK,4BAA4B,EACjC,KAAK,2BAA2B,EAChC,KAAK,wCAAwC,EAC7C,KAAK,kCAAkC,EACvC,KAAK,gCAAgC,EACrC,KAAK,qCAAqC,GAC3C,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,UAAU,EACV,KAAK,eAAe,EACpB,KAAK,gBAAgB,GACtB,MAAM,gBAAgB,CAAC"}

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

@@ -0,0 +1,3 @@
+export { ensureDurableDirectory, pinDirectory, syncDirectory, syncDirectoryBestEffort, syncDirectoryBestEffortSync, syncDirectorySync, } from "./directory-durability.js";
+export { isHardlinkFallbackError, publishFileExclusive, } from "./publish-file.js";
+export { sha256File, } from "./file-hash.js";

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

@@ -0,0 +1,3 @@
+export declare function formatErrorDetail(value: string): string;
+export declare function shortPath(value: string): string;
+//# sourceMappingURL=error-detail.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"error-detail.d.ts","sourceRoot":"","sources":["../src/error-detail.ts"],"names":[],"mappings":"AAKA,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAIvD;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAI/C"}

package/node_modules/@openclaw/fs-safe/dist/error-detail.js

@@ -0,0 +1,10 @@
+import os from "node:os";
+const UNSAFE_ERROR_DETAIL_CHARACTERS = /[\u0000-\u001f\u007f-\u009f\u2028\u2029]/gu;
+export function formatErrorDetail(value) {
+    return value.replace(UNSAFE_ERROR_DETAIL_CHARACTERS, (character) => `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`);
+}
+export function shortPath(value) {
+    const home = os.homedir();
+    const shortened = value.startsWith(home) ? `~${value.slice(home.length)}` : value;
+    return formatErrorDetail(shortened);
+}

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

@@ -0,0 +1,14 @@
+export type FsSafeErrorCode = "already-exists" | "denied-path" | "device-path" | "hardlink" | "helper-failed" | "helper-unavailable" | "invalid-path" | "insecure-permissions" | "not-empty" | "not-file" | "not-found" | "not-owned" | "not-removable" | "outside-workspace" | "path-alias" | "path-mismatch" | "permission-unverified" | "read-failed" | "secret-exists" | "store-reentrant-update" | "symlink" | "timeout" | "too-large" | "unsupported-platform";
+export type FsSafeErrorCategory = "policy" | "operational";
+export type FsSafeErrorDetails = Readonly<Record<string, unknown>>;
+export declare function categorizeFsSafeError(code: FsSafeErrorCode): FsSafeErrorCategory;
+export declare class FsSafeError extends Error {
+    readonly code: FsSafeErrorCode;
+    readonly category: FsSafeErrorCategory;
+    readonly details?: FsSafeErrorDetails;
+    constructor(code: FsSafeErrorCode, message: string, options?: {
+        cause?: unknown;
+        details?: FsSafeErrorDetails;
+    });
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GACvB,gBAAgB,GAChB,aAAa,GACb,aAAa,GACb,UAAU,GACV,eAAe,GACf,oBAAoB,GACpB,cAAc,GACd,sBAAsB,GACtB,WAAW,GACX,UAAU,GACV,WAAW,GACX,WAAW,GACX,eAAe,GACf,mBAAmB,GACnB,YAAY,GACZ,eAAe,GACf,uBAAuB,GACvB,aAAa,GACb,eAAe,GACf,wBAAwB,GACxB,SAAS,GACT,SAAS,GACT,WAAW,GACX,sBAAsB,CAAC;AAE3B,MAAM,MAAM,mBAAmB,GAAG,QAAQ,GAAG,aAAa,CAAC;AAC3D,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAcnE,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,eAAe,GAAG,mBAAmB,CAEhF;AAED,qBAAa,WAAY,SAAQ,KAAK;IACpC,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAC;IACvC,QAAQ,CAAC,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAEtC,YACE,IAAI,EAAE,eAAe,EACrB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,kBAAkB,CAAA;KAAO,EAOhE;CACF"}

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

@@ -0,0 +1,26 @@
+const OPERATIONAL_CODES = new Set([
+    "helper-failed",
+    "helper-unavailable",
+    "not-empty",
+    "not-found",
+    "not-removable",
+    "permission-unverified",
+    "read-failed",
+    "timeout",
+    "unsupported-platform",
+]);
+export function categorizeFsSafeError(code) {
+    return OPERATIONAL_CODES.has(code) ? "operational" : "policy";
+}
+export class FsSafeError extends Error {
+    code;
+    category;
+    details;
+    constructor(code, message, options = {}) {
+        super(message, options);
+        this.name = "FsSafeError";
+        this.code = code;
+        this.category = categorizeFsSafeError(code);
+        this.details = options.details;
+    }
+}

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

@@ -0,0 +1,10 @@
+import type { FileHandle } from "node:fs/promises";
+import { type NativeBinding } from "./native.js";
+export type Sha256FileInput = string | FileHandle;
+export type Sha256FileResult = {
+    bytes: number;
+    digest: string;
+};
+export declare function hashFileHandle(handle: FileHandle, native?: NativeBinding | undefined): Promise<Sha256FileResult>;
+export declare function sha256File(input: Sha256FileInput): Promise<Sha256FileResult>;
+//# sourceMappingURL=file-hash.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"file-hash.d.ts","sourceRoot":"","sources":["../src/file-hash.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAGnD,OAAO,EAAoB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAInE,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,UAAU,CAAC;AAElD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAsB,cAAc,CAClC,MAAM,EAAE,UAAU,EAClB,MAAM,GAAE,aAAa,GAAG,SAA8B,GACrD,OAAO,CAAC,gBAAgB,CAAC,CAoB3B;AA+CD,wBAAsB,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAElF"}

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

@@ -0,0 +1,73 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs/promises";
+import { FsSafeError } from "./errors.js";
+import { getNativeBinding } from "./native.js";
+import { resolveReadOpenFlags } from "./read-open-flags.js";
+import { inspectFileIdentity } from "./strict-file-identity.js";
+export async function hashFileHandle(handle, native = getNativeBinding()) {
+    const stat = await handle.stat();
+    if (!stat.isFile()) {
+        throw new FsSafeError("not-file", "SHA-256 input is not a regular file");
+    }
+    if (native) {
+        return await native.sha256File(handle.fd);
+    }
+    const hash = createHash("sha256");
+    const buffer = Buffer.allocUnsafe(64 * 1024);
+    let position = 0;
+    while (true) {
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, position);
+        if (bytesRead === 0) {
+            return { bytes: position, digest: hash.digest("hex") };
+        }
+        hash.update(buffer.subarray(0, bytesRead));
+        position += bytesRead;
+    }
+}
+async function hashPath(filePath) {
+    const before = await inspectFileIdentity(async () => {
+        const stat = await fs.lstat(filePath, { bigint: true });
+        if (stat.isSymbolicLink()) {
+            throw new FsSafeError("symlink", "SHA-256 path must not be a symbolic link");
+        }
+        if (!stat.isFile()) {
+            throw new FsSafeError("not-file", "SHA-256 path is not a regular file");
+        }
+        return stat;
+    });
+    let handle;
+    try {
+        handle = await fs.open(filePath, resolveReadOpenFlags());
+    }
+    catch (error) {
+        if (error?.code === "ELOOP") {
+            throw new FsSafeError("symlink", "SHA-256 path must not be a symbolic link", {
+                cause: error,
+            });
+        }
+        throw error;
+    }
+    try {
+        const opened = await inspectFileIdentity(async () => {
+            const stat = await handle.stat({ bigint: true });
+            if (!stat.isFile()) {
+                throw new FsSafeError("not-file", "SHA-256 path is not a regular file");
+            }
+            return stat;
+        }, before);
+        await inspectFileIdentity(async () => {
+            const stat = await fs.lstat(filePath, { bigint: true });
+            if (stat.isSymbolicLink() || !stat.isFile()) {
+                throw new FsSafeError("path-mismatch", "SHA-256 path changed while opening");
+            }
+            return stat;
+        }, opened);
+        return await hashFileHandle(handle);
+    }
+    finally {
+        await handle.close().catch(() => undefined);
+    }
+}
+export async function sha256File(input) {
+    return typeof input === "string" ? await hashPath(input) : await hashFileHandle(input);
+}

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

@@ -0,0 +1,8 @@
+export type FileIdentityStat = {
+    dev: number | bigint;
+    ino: number | bigint;
+};
+export declare function sha256Hex(data: string | Buffer, encoding?: BufferEncoding): string;
+export declare function sameFileIdentity(left: FileIdentityStat, right: FileIdentityStat, platform?: NodeJS.Platform): boolean;
+export declare function sameFileIdentityForCleanup(left: FileIdentityStat, right: FileIdentityStat, platform?: NodeJS.Platform): boolean;
+//# sourceMappingURL=file-identity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"file-identity.d.ts","sourceRoot":"","sources":["../src/file-identity.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,gBAAgB,GAAG;IAC7B,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;IACrB,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CACtB,CAAC;AAsBF,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,QAAQ,CAAC,EAAE,cAAc,GAAG,MAAM,CAGlF;AAED,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,gBAAgB,EACtB,KAAK,EAAE,gBAAgB,EACvB,QAAQ,GAAE,MAAM,CAAC,QAA2B,GAC3C,OAAO,CAQT;AAED,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,gBAAgB,EACtB,KAAK,EAAE,gBAAgB,EACvB,QAAQ,GAAE,MAAM,CAAC,QAA2B,GAC3C,OAAO,CAWT"}

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

@@ -0,0 +1,34 @@
+import { createHash } from "node:crypto";
+function isZero(value) {
+    return value === 0 || value === 0n;
+}
+function sameStatValue(left, right) {
+    return typeof left === typeof right ? left === right : BigInt(left) === BigInt(right);
+}
+function isStatValueProvablyDifferent(left, right, platform) {
+    if (sameStatValue(left, right)) {
+        return false;
+    }
+    return platform !== "win32" || (!isZero(left) && !isZero(right));
+}
+export function sha256Hex(data, encoding) {
+    const buffer = typeof data === "string" ? Buffer.from(data, encoding ?? "utf8") : data;
+    return createHash("sha256").update(buffer).digest("hex");
+}
+export function sameFileIdentity(left, right, platform = process.platform) {
+    // When Windows cannot open a path for stat, libuv's FindFirstFile fallback reports dev=0 and
+    // ino=0. Treating either unknown value as a mismatch caused nondeterministic path-mismatch
+    // failures on legitimate reads under antivirus or indexer contention.
+    return (!isStatValueProvablyDifferent(left.dev, right.dev, platform) &&
+        !isStatValueProvablyDifferent(left.ino, right.ino, platform));
+}
+export function sameFileIdentityForCleanup(left, right, platform = process.platform) {
+    // A zero Windows device or inode is unknown, not proof that a pathname still
+    // names the object we created. Cleanup must fail closed rather than delete a
+    // replacement that happens to share the known half of the identity.
+    if (platform === "win32" &&
+        (isZero(left.dev) || isZero(left.ino) || isZero(right.dev) || isZero(right.ino))) {
+        return false;
+    }
+    return sameStatValue(left.dev, right.dev) && sameStatValue(left.ino, right.ino);
+}

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

@@ -0,0 +1,35 @@
+import type { Root } from "./root-impl.js";
+import { type SidecarLockStaleSnapshot } from "./sidecar-lock-reclaim.js";
+import type { SidecarLockCompromisedInfo, SidecarLockRetryOptions, SidecarLockStaleRecovery } from "./sidecar-lock-types.js";
+export type FileLockSyncAcquireOptions<TPayload extends Record<string, unknown>> = {
+    lockPath?: string;
+    staleMs?: number;
+    timeoutMs?: number;
+    retry?: SidecarLockRetryOptions;
+    staleRecovery?: SidecarLockStaleRecovery;
+    reentrantOwner?: string;
+    payload: () => TPayload;
+    shouldReclaim?: (params: {
+        lockPath: string;
+        normalizedTargetPath: string;
+        payload: unknown;
+        staleMs: number;
+        nowMs: number;
+        heldByThisProcess: false;
+    }) => boolean;
+    shouldRemoveStaleLock?: (snapshot: SidecarLockStaleSnapshot) => boolean;
+    parsePayload?: (raw: string) => unknown;
+    lockRoot?: Root;
+    onCompromised?: (info: SidecarLockCompromisedInfo) => void;
+    compromiseCheckIntervalMs?: number;
+};
+export type FileLockSyncHandle = {
+    lockPath: string;
+    normalizedTargetPath: string;
+    verifyStillHeld(): boolean;
+    release(): void;
+    [Symbol.dispose](): void;
+};
+export declare function acquireFileLockSync<TPayload extends Record<string, unknown>>(targetPath: string, options: FileLockSyncAcquireOptions<TPayload>): FileLockSyncHandle;
+export declare function withFileLockSync<T, TPayload extends Record<string, unknown>>(targetPath: string, options: FileLockSyncAcquireOptions<TPayload>, fn: () => T): T;
+//# sourceMappingURL=file-lock-sync.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"file-lock-sync.d.ts","sourceRoot":"","sources":["../src/file-lock-sync.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EASL,KAAK,wBAAwB,EAC9B,MAAM,2BAA2B,CAAC;AASnC,OAAO,KAAK,EACV,0BAA0B,EAC1B,uBAAuB,EACvB,wBAAwB,EACzB,MAAM,yBAAyB,CAAC;AAIjC,MAAM,MAAM,0BAA0B,CAAC,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI;IACjF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,uBAAuB,CAAC;IAChC,aAAa,CAAC,EAAE,wBAAwB,CAAC;IACzC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,QAAQ,CAAC;IACxB,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE;QACvB,QAAQ,EAAE,MAAM,CAAC;QACjB,oBAAoB,EAAE,MAAM,CAAC;QAC7B,OAAO,EAAE,OAAO,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,iBAAiB,EAAE,KAAK,CAAC;KAC1B,KAAK,OAAO,CAAC;IACd,qBAAqB,CAAC,EAAE,CAAC,QAAQ,EAAE,wBAAwB,KAAK,OAAO,CAAC;IACxE,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;IACxC,QAAQ,CAAC,EAAE,IAAI,CAAC;IAChB,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,0BAA0B,KAAK,IAAI,CAAC;IAC3D,yBAAyB,CAAC,EAAE,MAAM,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,eAAe,IAAI,OAAO,CAAC;IAC3B,OAAO,IAAI,IAAI,CAAC;IAChB,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC;CAC1B,CAAC;AAoJF,wBAAgB,mBAAmB,CAAC,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1E,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,0BAA0B,CAAC,QAAQ,CAAC,GAC5C,kBAAkB,CAwMpB;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1E,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,0BAA0B,CAAC,QAAQ,CAAC,EAC7C,EAAE,EAAE,MAAM,CAAC,GACV,CAAC,CAOH"}