@openclaw/openshell-sandbox 2026.9.1 → 2026.9.3

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

@@ -0,0 +1,362 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { requireNativeBinding } from "./native.js";
+import { syncFileBestEffortSync } from "./file-sync.js";
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import { FsSafeError } from "./errors.js";
+import { writeNativeInput } from "./native-operations.js";
+import { assertStagedDirectoryCurrent, openStagedDirectory } from "./staged-directory.js";
+export function assertNativeStaging(binding) {
+    if ([
+        binding.createStagedFile,
+        binding.stagedFileMatches,
+        binding.removeStagedFile,
+        binding.renameReplace,
+        binding.renameNoReplace,
+    ].some((fn) => typeof fn !== "function")) {
+        throw new FsSafeError("helper-unavailable", "native retained-directory staging is unavailable");
+    }
+}
+function assertBasename(name, portable) {
+    if (!name || name === "." || name === ".." || name.includes("/") || name.includes("\0") ||
+        (portable && /[\\:\u0000-\u001f\u007f-\u009f\u2028\u2029]/u.test(name))) {
+        throw new FsSafeError("invalid-path", "publication requires one direct-child basename");
+    }
+}
+const NOT_PUBLISHED = Object.freeze({ status: "not-published" });
+const UNCOMMITTED_RENAME_ERRORS = new Set([
+    "EACCES", "EBADF", "EBUSY", "EEXIST", "EINVAL", "EISDIR", "ELOOP", "EMLINK",
+    "ENAMETOOLONG", "ENOENT", "ENOSPC", "ENOSYS", "ENOTDIR", "ENOTEMPTY", "ENOTSUP",
+    "EPERM", "EROFS", "ETXTBSY", "EXDEV",
+]);
+function failure(error, details) {
+    const code = error instanceof FsSafeError
+        ? error.code
+        : error?.code === "EEXIST" ? "already-exists" : "helper-failed";
+    return new FsSafeError(code, `staged file ${details.phase} failed`, { cause: error, details });
+}
+class NativeStagedFile {
+    #binding;
+    #parentFd;
+    #directory;
+    #portableNames;
+    #publishedMode;
+    #sync;
+    #name = `.fs-safe-${randomUUID()}.tmp`;
+    #state = { status: "open", publication: NOT_PUBLISHED };
+    #receipt;
+    constructor(binding, parentFd, directory, portableNames, publishedMode, sync) {
+        this.#binding = binding;
+        this.#parentFd = parentFd;
+        this.#directory = directory;
+        this.#portableNames = portableNames;
+        this.#publishedMode = publishedMode;
+        this.#sync = sync;
+    }
+    // Takes ownership of parentFd, including all construction and preparation failures.
+    static async create(binding, parentFd, directory, input, mode, maxBytes, 
+    // Public staging uses portable names; existing POSIX writes accept literal names.
+    portableNames = true, sync = true) {
+        let staged;
+        try {
+            staged = new NativeStagedFile(binding, parentFd, directory, portableNames, mode, sync);
+        }
+        catch (error) {
+            try {
+                fs.closeSync(parentFd);
+            }
+            catch (closeError) {
+                throw new AggregateError([error, closeError], "staged owner construction and close failed");
+            }
+            throw error;
+        }
+        await staged.#prepare(input, maxBytes);
+        return staged;
+    }
+    static async write(binding, parentFd, directory, params, parentGuard) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            // This owner never escapes. Only the internal verifier borrows its fd;
+            // public descriptor methods remain await-free and cannot race disposal.
+            const staged = __addDisposableResource(env_1, await NativeStagedFile.create(binding, parentFd, directory, params.input, params.mode, params.maxBytes, false, params.sync), true);
+            const published = await staged.publish(params.basename, { overwrite: params.overwrite !== false });
+            const identity = published.staged.identity;
+            await params.verifyPublished?.(staged.#file(), identity, parentGuard);
+            return { dev: identity.dev, ino: identity.ino };
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            const result_1 = __disposeResources(env_1);
+            if (result_1)
+                await result_1;
+        }
+    }
+    get receipt() {
+        if (!this.#receipt) {
+            throw new FsSafeError("helper-failed", "staged file preparation is incomplete");
+        }
+        return this.#receipt;
+    }
+    #open() {
+        if (this.#state.status === "closed") {
+            throw new FsSafeError("helper-failed", "staged file is closed");
+        }
+        return this.#state;
+    }
+    #file() {
+        const state = this.#open();
+        if (state.fileFd === undefined) {
+            throw new FsSafeError("helper-failed", "staged file has not been created");
+        }
+        return state.fileFd;
+    }
+    #assertNamed(name) {
+        const fd = this.#file();
+        const stat = this.#binding.stagedFileMatches(this.#parentFd, name, fd)
+            ? fs.fstatSync(fd, { bigint: true }) : undefined;
+        if (!stat || stat.nlink !== 1n) {
+            throw new FsSafeError("path-mismatch", "staged entry no longer names the exclusive created file");
+        }
+        return Number(stat.mode & 4095n);
+    }
+    #assertCurrent() {
+        if (this.#open().publication.status !== "not-published") {
+            throw new FsSafeError("helper-failed", "staged file publication has already been attempted");
+        }
+        assertStagedDirectoryCurrent(this.#directory);
+        this.#assertNamed(this.#name);
+    }
+    async #prepare(input, maxBytes) {
+        try {
+            const mode = this.#publishedMode;
+            if (!Number.isInteger(mode) || mode < 0 || mode > 0o7777) {
+                throw new FsSafeError("invalid-path", "invalid staged file mode");
+            }
+            assertStagedDirectoryCurrent(this.#directory);
+            // The exclusive open performs no fallible post-open checks. Store its fd
+            // before every subsequent operation, including the first metadata read.
+            const state = this.#open();
+            state.fileFd = this.#binding.createStagedFile(this.#parentFd, this.#name);
+            const fd = state.fileFd;
+            fs.fchmodSync(fd, 0o600);
+            await writeNativeInput(fd, input, maxBytes);
+            if (this.#sync)
+                syncFileBestEffortSync(fd);
+            const stat = fs.fstatSync(fd, { bigint: true });
+            this.#receipt = Object.freeze({
+                directory: this.#directory,
+                temporaryBasename: this.#name,
+                identity: Object.freeze({
+                    dev: stat.dev,
+                    ino: stat.ino,
+                    mode: Number(stat.mode & 4095n),
+                    nlink: stat.nlink,
+                    size: stat.size,
+                    uid: Number(stat.uid),
+                    gid: Number(stat.gid),
+                    mtimeNs: stat.mtimeNs,
+                    ctimeNs: stat.ctimeNs,
+                }),
+            });
+            this.#assertCurrent();
+        }
+        catch (error) {
+            const { receipt: cleanup, error: cleanupError } = this.#finalize();
+            if (cleanupError) {
+                throw failure(new AggregateError([error, cleanupError], "preparation and cleanup failed"), { phase: "prepare", publication: cleanup.publication, cleanup });
+            }
+            if (cleanup.status === "preserved") {
+                throw failure(error, { phase: "prepare", publication: cleanup.publication, cleanup });
+            }
+            throw error;
+        }
+    }
+    // Keep public descriptor work await-free: each call completes its mutations
+    // before the next invocation, including closure and cached cleanup failures.
+    async assertCurrent() {
+        this.#assertCurrent();
+    }
+    async publish(basename, options) {
+        const overwrite = options?.overwrite;
+        try {
+            const state = this.#open();
+            assertBasename(basename, this.#portableNames);
+            if (basename === this.#name || typeof overwrite !== "boolean") {
+                throw new FsSafeError("invalid-path", "publication needs a distinct basename and explicit overwrite policy");
+            }
+            this.#assertCurrent();
+            try {
+                if (overwrite) {
+                    this.#binding.renameReplace(this.#parentFd, this.#name, this.#parentFd, basename);
+                }
+                else {
+                    this.#binding.renameNoReplace(this.#parentFd, this.#name, this.#parentFd, basename);
+                }
+            }
+            catch (error) {
+                // Unknown rename errors can be indeterminate on remote filesystems.
+                if (!UNCOMMITTED_RENAME_ERRORS.has(error?.code ?? "")) {
+                    state.publication = Object.freeze({ status: "indeterminate", basename, overwrite });
+                }
+                throw error;
+            }
+            // Commit is recorded synchronously before any post-rename operation.
+            const receipt = Object.freeze({
+                status: "published",
+                staged: this.receipt,
+                basename,
+                overwrite,
+            });
+            state.publication = receipt;
+            const stagedMode = this.#assertNamed(basename);
+            assertStagedDirectoryCurrent(this.#directory);
+            // Keep contents private until the published name passes its identity
+            // fence. Mode changes use the owned fd, including for final mode 000.
+            const fd = this.#file();
+            if (this.#publishedMode !== 0o600 || stagedMode !== 0o600)
+                fs.fchmodSync(fd, this.#publishedMode);
+            // With sync enabled, content was synced before rename. A lost chmod leaves staged 0600,
+            // no wider than modes retaining owner rw. Restrictive modes and observed
+            // widening of the stage still need the permission correction made durable.
+            if (this.#sync && ((this.#publishedMode & 0o600) !== 0o600 || (stagedMode & ~this.#publishedMode) !== 0)) {
+                syncFileBestEffortSync(fd);
+            }
+            if (this.#sync)
+                syncFileBestEffortSync(this.#parentFd);
+            this.#assertNamed(basename);
+            assertStagedDirectoryCurrent(this.#directory);
+            return receipt;
+        }
+        catch (error) {
+            // Closure rejects further use, not the recorded outcome of an earlier publication.
+            const publication = this.#state.status === "closed"
+                ? this.#state.receipt.publication
+                : this.#state.publication;
+            throw failure(error, { phase: "publish", publication });
+        }
+    }
+    #finalize() {
+        if (this.#state.status === "closed") {
+            return this.#state;
+        }
+        const state = this.#state;
+        let outcome = "not-needed";
+        const errors = [];
+        if (state.publication.status === "indeterminate") {
+            outcome = "preserved";
+        }
+        else if (state.publication.status === "not-published" && state.fileFd !== undefined) {
+            try {
+                outcome = this.#binding.removeStagedFile(this.#parentFd, this.#name, state.fileFd);
+            }
+            catch (error) {
+                outcome = "failed";
+                errors.push(error);
+            }
+        }
+        let resources = "closed";
+        for (const fd of [state.fileFd, this.#parentFd]) {
+            if (fd === undefined) {
+                continue;
+            }
+            try {
+                fs.closeSync(fd);
+            }
+            catch (error) {
+                resources = "close-failed";
+                errors.push(error);
+            }
+        }
+        const receipt = Object.freeze({
+            temporaryBasename: this.#name,
+            publication: state.publication,
+            status: outcome,
+            resources,
+        });
+        const error = errors.length ? failure(errors.length === 1 ? errors[0] : new AggregateError(errors, "staged cleanup failed"), { phase: "cleanup", publication: state.publication, cleanup: receipt }) : undefined;
+        this.#state = { status: "closed", receipt, error };
+        return this.#state;
+    }
+    async cleanup() {
+        const closed = this.#finalize();
+        if (closed.error) {
+            throw closed.error;
+        }
+        return closed.receipt;
+    }
+    async [Symbol.asyncDispose]() {
+        const cleanup = await this.cleanup();
+        if (cleanup.status === "preserved") {
+            throw new FsSafeError("not-removable", "staged cleanup preserved an unverified entry", {
+                details: { phase: "cleanup", publication: cleanup.publication, cleanup },
+            });
+        }
+    }
+}
+export const createNativeStage = NativeStagedFile.create;
+export const writeNativeStage = NativeStagedFile.write;
+export async function stageFileInDirectory(options) {
+    if (process.platform !== "linux" && process.platform !== "darwin") {
+        throw new FsSafeError("unsupported-platform", "retained-directory staging requires Linux or macOS");
+    }
+    const binding = requireNativeBinding();
+    assertNativeStaging(binding);
+    const input = { kind: "buffer", data: Buffer.from(options.content) };
+    const mode = options.mode ?? 0o600;
+    const parent = openStagedDirectory(options.directory);
+    return await createNativeStage(binding, parent.fd, parent.receipt, input, mode);
+}

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

@@ -0,0 +1,14 @@
+import type { NativeBinding } from "./native-binding.js";
+export type { NativeBinding } from "./native-binding.js";
+export declare function __loadBundledNativeForTest(): NativeBinding;
+export declare function __nativeLoaderDetectorsForTest(): {
+    report: boolean | undefined;
+    filesystem: boolean | undefined;
+    elfInterpreter: boolean | undefined;
+};
+export declare function __nativeTargetForTest(platform: NodeJS.Platform, arch: string, musl?: boolean): string | undefined;
+export declare function getNativeBinding(): NativeBinding | undefined;
+export declare function requireNativeBinding(): NativeBinding;
+export declare function __setNativeLoaderForTest(loader: () => NativeBinding): void;
+export declare function __resetNativeLoaderForTest(): void;
+//# sourceMappingURL=native.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"native.d.ts","sourceRoot":"","sources":["../src/native.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGzD,YAAY,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAsKzD,wBAAgB,0BAA0B,IAAI,aAAa,CAE1D;AAED,wBAAgB,8BAA8B,IAAI;IAChD,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC;IAC5B,UAAU,EAAE,OAAO,GAAG,SAAS,CAAC;IAChC,cAAc,EAAE,OAAO,GAAG,SAAS,CAAC;CACrC,CAMA;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,CAAC,QAAQ,EACzB,IAAI,EAAE,MAAM,EACZ,IAAI,UAAQ,GACX,MAAM,GAAG,SAAS,CAEpB;AAED,wBAAgB,gBAAgB,IAAI,aAAa,GAAG,SAAS,CAkB5D;AAED,wBAAgB,oBAAoB,IAAI,aAAa,CAQpD;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,aAAa,GAAG,IAAI,CAK1E;AAED,wBAAgB,0BAA0B,IAAI,IAAI,CAKjD"}

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

@@ -0,0 +1,204 @@
+import { closeSync, openSync, readSync, readdirSync, } from "node:fs";
+import { createRequire } from "node:module";
+import { FsSafeError } from "./errors.js";
+import { getFsSafeNativeConfig } from "./native-config.js";
+const require = createRequire(import.meta.url);
+let binding;
+let loadError;
+let attempted = false;
+let loadBinding = loadBundledBinding;
+function isMuslFilename(file) {
+    return file.includes("libc.musl-") || file.includes("ld-musl-");
+}
+function isMuslFromReport() {
+    try {
+        if (!process.report || typeof process.report.getReport !== "function")
+            return undefined;
+        const report = process.report.getReport();
+        if (report.header?.glibcVersionRuntime)
+            return false;
+        if (report.sharedObjects?.some(isMuslFilename))
+            return true;
+    }
+    catch {
+        // Continue with filesystem and ELF inspection.
+    }
+    return undefined;
+}
+function isMuslFromFilesystem() {
+    for (const directory of ["/lib", "/usr/lib"]) {
+        try {
+            if (readdirSync(directory).some(isMuslFilename))
+                return true;
+        }
+        catch {
+            // A missing or unreadable conventional library directory is inconclusive.
+        }
+    }
+    return undefined;
+}
+function readUInt(buffer, offset, bytes, littleEndian) {
+    if (offset < 0 || offset + bytes > buffer.length)
+        return undefined;
+    if (bytes === 2)
+        return littleEndian ? buffer.readUInt16LE(offset) : buffer.readUInt16BE(offset);
+    if (bytes === 4)
+        return littleEndian ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset);
+    const value = littleEndian ? buffer.readBigUInt64LE(offset) : buffer.readBigUInt64BE(offset);
+    return value <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(value) : undefined;
+}
+function isMuslFromElfInterpreter() {
+    let fd;
+    try {
+        fd = openSync(process.execPath, "r");
+        const header = Buffer.alloc(64);
+        if (readSync(fd, header, 0, header.length, 0) < 52)
+            return undefined;
+        if (!header.subarray(0, 4).equals(Buffer.from([0x7f, 0x45, 0x4c, 0x46])))
+            return undefined;
+        const elfClass = header[4];
+        const dataEncoding = header[5];
+        if ((elfClass !== 1 && elfClass !== 2) || (dataEncoding !== 1 && dataEncoding !== 2)) {
+            return undefined;
+        }
+        const littleEndian = dataEncoding === 1;
+        const is64Bit = elfClass === 2;
+        const tableOffset = readUInt(header, is64Bit ? 32 : 28, is64Bit ? 8 : 4, littleEndian);
+        const entrySize = readUInt(header, is64Bit ? 54 : 42, 2, littleEndian);
+        const entryCount = readUInt(header, is64Bit ? 56 : 44, 2, littleEndian);
+        if (tableOffset === undefined ||
+            entrySize === undefined ||
+            entryCount === undefined ||
+            entrySize < (is64Bit ? 56 : 32) ||
+            entryCount > 1024) {
+            return undefined;
+        }
+        const programHeader = Buffer.alloc(entrySize);
+        for (let index = 0; index < entryCount; index += 1) {
+            const offset = tableOffset + index * entrySize;
+            if (readSync(fd, programHeader, 0, entrySize, offset) !== entrySize)
+                return undefined;
+            if (readUInt(programHeader, 0, 4, littleEndian) !== 3)
+                continue;
+            const interpreterOffset = readUInt(programHeader, is64Bit ? 8 : 4, is64Bit ? 8 : 4, littleEndian);
+            const interpreterSize = readUInt(programHeader, is64Bit ? 32 : 16, is64Bit ? 8 : 4, littleEndian);
+            if (interpreterOffset === undefined ||
+                interpreterSize === undefined ||
+                interpreterSize < 1 ||
+                interpreterSize > 4096) {
+                return undefined;
+            }
+            const interpreter = Buffer.alloc(interpreterSize);
+            if (readSync(fd, interpreter, 0, interpreterSize, interpreterOffset) !== interpreterSize) {
+                return undefined;
+            }
+            return isMuslFilename(interpreter.toString("utf8"));
+        }
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        if (fd !== undefined) {
+            try {
+                closeSync(fd);
+            }
+            catch {
+                // Best-effort detection must never turn close failure into import failure.
+            }
+        }
+    }
+    return undefined;
+}
+function isMusl() {
+    if (process.platform !== "linux")
+        return false;
+    for (const detector of [isMuslFromReport, isMuslFromFilesystem, isMuslFromElfInterpreter]) {
+        const result = detector();
+        if (result !== undefined)
+            return result;
+    }
+    // Unknown Linux libc: try the glibc binary and let its require fail normally.
+    return false;
+}
+function targetFor(platform, arch, musl) {
+    if (platform === "win32" && arch === "x64")
+        return "win32-x64-msvc";
+    if (platform === "darwin" && arch === "x64")
+        return "darwin-x64";
+    if (platform === "darwin" && arch === "arm64")
+        return "darwin-arm64";
+    if (platform === "linux" && (arch === "x64" || arch === "arm64")) {
+        return `linux-${arch}-${musl ? "musl" : "gnu"}`;
+    }
+    return undefined;
+}
+function bundledTarget() {
+    return targetFor(process.platform, process.arch, isMusl());
+}
+function nativePackageForTarget(target) {
+    return `@openclaw/fs-safe-${target}`;
+}
+function loadBundledBinding() {
+    const target = bundledTarget();
+    if (!target) {
+        throw new Error(`Unsupported OS or architecture: ${process.platform}-${process.arch}`);
+    }
+    return require(nativePackageForTarget(target));
+}
+export function __loadBundledNativeForTest() {
+    return loadBundledBinding();
+}
+export function __nativeLoaderDetectorsForTest() {
+    return {
+        report: isMuslFromReport(),
+        filesystem: isMuslFromFilesystem(),
+        elfInterpreter: isMuslFromElfInterpreter(),
+    };
+}
+export function __nativeTargetForTest(platform, arch, musl = false) {
+    return targetFor(platform, arch, musl);
+}
+export function getNativeBinding() {
+    const { mode } = getFsSafeNativeConfig();
+    if (mode === "off")
+        return undefined;
+    if (!attempted) {
+        attempted = true;
+        try {
+            binding = loadBinding();
+        }
+        catch (error) {
+            loadError = error;
+        }
+    }
+    if (binding)
+        return binding;
+    if (mode === "require") {
+        throw new FsSafeError("helper-unavailable", "native fs-safe helper is unavailable", {
+            cause: loadError,
+        });
+    }
+    return undefined;
+}
+export function requireNativeBinding() {
+    const native = getNativeBinding();
+    if (!native) {
+        throw new FsSafeError("helper-unavailable", "native fs-safe helper is unavailable", {
+            cause: loadError,
+        });
+    }
+    return native;
+}
+export function __setNativeLoaderForTest(loader) {
+    binding = undefined;
+    loadError = undefined;
+    attempted = false;
+    loadBinding = loader;
+}
+export function __resetNativeLoaderForTest() {
+    binding = undefined;
+    loadError = undefined;
+    attempted = false;
+    loadBinding = loadBundledBinding;
+}

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

@@ -0,0 +1,8 @@
+import type { BigIntStats } from "node:fs";
+import type { FileHandle } from "node:fs/promises";
+export declare function recordFileOpenFailure(error: unknown, filePath: string): never;
+export declare function recordExclusiveCreateFailure(error: unknown, filePath: string): never;
+export declare function openedPathResolutionError(error?: Error): Error;
+export declare function recordPreOpenFileChange(error: unknown, handle: FileHandle, filePath: string, before: BigIntStats | undefined, opened: BigIntStats | undefined): Promise<void>;
+export declare function recordOpenedFileFailure(error: unknown, handle: FileHandle, filePath: string, identity: BigIntStats): Promise<void>;
+//# sourceMappingURL=opened-file-failure.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"opened-file-failure.d.ts","sourceRoot":"","sources":["../src/opened-file-failure.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAKnD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,KAAK,CAG7E;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,KAAK,CAGpF;AAED,wBAAgB,yBAAyB,CACvC,KAAK,GAAE,KAA8E,GACpF,KAAK,CAGP;AAED,wBAAsB,uBAAuB,CAC3C,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,OAAO,CAAC,IAAI,CAAC,CAcf;AAED,wBAAsB,uBAAuB,CAC3C,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,WAAW,GACpB,OAAO,CAAC,IAAI,CAAC,CASf"}

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

@@ -0,0 +1,45 @@
+import { FsSafeError } from "./errors.js";
+import { inspectFileIdentity } from "./strict-file-identity.js";
+import { isFileObservationFailure, recordFileObservationFailure } from "./file-observation.js";
+export function recordFileOpenFailure(error, filePath) {
+    recordFileObservationFailure(error, `open:${filePath}`);
+    throw error;
+}
+export function recordExclusiveCreateFailure(error, filePath) {
+    recordFileObservationFailure(error, `exclusive-create:${filePath}`);
+    throw error;
+}
+export function openedPathResolutionError(error = new FsSafeError("path-mismatch", "unable to resolve opened file path")) {
+    recordFileObservationFailure(error, "resolution");
+    return error;
+}
+export async function recordPreOpenFileChange(error, handle, filePath, before, opened) {
+    if (!isFileObservationFailure(error, "identity") || !before?.isFile() || !opened?.isFile() ||
+        ![0n, 1n].includes(before.nlink) || ![0n, 1n].includes(opened.nlink))
+        return;
+    try {
+        await inspectFileIdentity(async () => before);
+        const current = await inspectFileIdentity(() => handle.stat({ bigint: true }), opened);
+        if (current.isFile() && [0n, 1n].includes(current.nlink) &&
+            (before.dev !== current.dev || before.ino !== current.ino)) {
+            // A stale pathname sample is not proof that its former inode was unlinked.
+            recordFileObservationFailure(error, `changed:${filePath}`);
+        }
+    }
+    catch {
+        // Unknown, changed, or closed descriptor evidence never permits a discard.
+    }
+}
+export async function recordOpenedFileFailure(error, handle, filePath, identity) {
+    if ((!isFileObservationFailure(error, "resolution") && !isFileObservationFailure(error, "identity")) ||
+        !identity.isFile() || identity.nlink > 1n)
+        return;
+    try {
+        const current = await inspectFileIdentity(() => handle.stat({ bigint: true }), identity);
+        if (current.isFile() && current.nlink === 0n)
+            recordFileObservationFailure(error, `unlinked:${filePath}`);
+    }
+    catch {
+        // A closed, changed, or unknown descriptor provides no retry evidence.
+    }
+}

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

@@ -0,0 +1,16 @@
+import type { BigIntStats, Stats } from "node:fs";
+import type { FileHandle } from "node:fs/promises";
+import { type FileIdentityStat } from "./file-identity.js";
+export declare function resolveOpenedFileRealPathForHandle(handle: FileHandle, ioPath: string): Promise<string>;
+export declare function resolveOpenedFileRealPathForFd(fd: number, handleStat: {
+    dev: bigint;
+    ino: bigint;
+}, ioPath: string): Promise<{
+    realPath: string;
+    stat: BigIntStats;
+}>;
+export declare function resolveOpenedFileRealPathForFd(fd: number, handleStat: FileIdentityStat, ioPath: string): Promise<{
+    realPath: string;
+    stat: Stats | BigIntStats;
+}>;
+//# sourceMappingURL=opened-realpath.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"opened-realpath.d.ts","sourceRoot":"","sources":["../src/opened-realpath.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAGnD,OAAO,EAAoB,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAG7E,wBAAsB,kCAAkC,CACtD,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,CAAC,CAGjB;AAED,wBAAgB,8BAA8B,CAC5C,EAAE,EAAE,MAAM,EACV,UAAU,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EACxC,MAAM,EAAE,MAAM,GACb,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,WAAW,CAAA;CAAE,CAAC,CAAC;AACpD,wBAAgB,8BAA8B,CAC5C,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,gBAAgB,EAC5B,MAAM,EAAE,MAAM,GACb,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,KAAK,GAAG,WAAW,CAAA;CAAE,CAAC,CAAC"}