@openclaw/openshell-sandbox 2026.9.2 → 2026.9.4

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

@@ -0,0 +1,71 @@
+let overrideConfig = {};
+let legacyWarningEmitted = false;
+const legacyModeEnvKeys = ["FS_SAFE_PYTHON_MODE", "OPENCLAW_FS_SAFE_PYTHON_MODE"];
+const legacyPathEnvKeys = [
+    "FS_SAFE_PYTHON",
+    "OPENCLAW_FS_SAFE_PYTHON",
+    "OPENCLAW_PINNED_PYTHON",
+    "OPENCLAW_PINNED_WRITE_PYTHON",
+];
+function parseMode(value) {
+    if (!value) {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "0" || normalized === "false" || normalized === "off" || normalized === "never") {
+        return "off";
+    }
+    if (normalized === "1" || normalized === "true" || normalized === "on" || normalized === "auto") {
+        return "auto";
+    }
+    if (normalized === "required" || normalized === "require") {
+        return "require";
+    }
+    return undefined;
+}
+export function configureFsSafeNative(config) {
+    overrideConfig = { ...overrideConfig, ...config };
+}
+function warnLegacyPythonConfiguration(source, mappedMode) {
+    if (legacyWarningEmitted) {
+        return;
+    }
+    legacyWarningEmitted = true;
+    process.emitWarning(`${source} is a deprecated 0.4 compatibility bridge; mapped to native mode ` +
+        `"${mappedMode}". Use configureFsSafeNative({ mode: "${mappedMode}" }) or ` +
+        `FS_SAFE_NATIVE_MODE=${mappedMode}. Python interpreter paths are no longer used.`, { code: "FS_SAFE_PYTHON_DEPRECATED", type: "DeprecationWarning" });
+}
+function readLegacyPythonMode() {
+    const configuredKeys = [...legacyModeEnvKeys, ...legacyPathEnvKeys].filter((key) => process.env[key] !== undefined);
+    if (configuredKeys.length === 0) {
+        return undefined;
+    }
+    const rawMode = legacyModeEnvKeys.map((key) => process.env[key]).find((value) => value !== undefined);
+    const mappedMode = parseMode(rawMode) ?? "auto";
+    warnLegacyPythonConfiguration(`Legacy ${configuredKeys.join(", ")}`, mappedMode);
+    return mappedMode;
+}
+/**
+ * @deprecated Compatibility bridge for 0.4 upgrades. Use configureFsSafeNative.
+ */
+export function configureFsSafePython(config) {
+    const mappedMode = config.mode ?? "auto";
+    warnLegacyPythonConfiguration("configureFsSafePython()", mappedMode);
+    if (config.mode !== undefined) {
+        configureFsSafeNative({ mode: config.mode });
+    }
+}
+export function getFsSafeNativeConfig() {
+    const legacyMode = readLegacyPythonMode();
+    return {
+        mode: overrideConfig.mode ??
+            parseMode(process.env.FS_SAFE_NATIVE_MODE) ??
+            parseMode(process.env.OPENCLAW_FS_SAFE_NATIVE_MODE) ??
+            legacyMode ??
+            "auto",
+    };
+}
+export function __resetFsSafeNativeConfigForTest() {
+    overrideConfig = {};
+    legacyWarningEmitted = false;
+}

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

@@ -0,0 +1,21 @@
+import { type BigIntStats, type Stats } from "node:fs";
+import type { ContainmentGuarantee } from "./containment.js";
+import type { PinnedWriteInput } from "./pinned-write.js";
+export type NativeFileHandle = {
+    readonly fd: number;
+    readonly containment: ContainmentGuarantee;
+    close(): Promise<void>;
+    stat(): Promise<Stats>;
+    writeFile(data: string | Buffer, encoding?: BufferEncoding): Promise<void>;
+};
+export declare function nativeOpenFlags(flags: number): number;
+export declare function writeNativeFd(fd: number, data: Buffer): void;
+export declare function writeNativeInput(fd: number, input: PinnedWriteInput, maxBytes?: number): Promise<void>;
+export declare function removeNativeCreatedFileIfStillPinned(params: {
+    parentPath: string;
+    parentFd: number;
+    basename: string;
+    created?: BigIntStats;
+}): void;
+export declare function createNativeExclusiveFile(targetPath: string, mode: number): Promise<NativeFileHandle | undefined>;
+//# sourceMappingURL=native-operations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"native-operations.d.ts","sourceRoot":"","sources":["../src/native-operations.ts"],"names":[],"mappings":"AAAA,OAAe,EAAE,KAAK,WAAW,EAAE,KAAK,KAAK,EAAE,MAAM,SAAS,CAAC;AAG/D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAI7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1D,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,WAAW,EAAE,oBAAoB,CAAC;IAC3C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC;IACvB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,QAAQ,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5E,CAAC;AAEF,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAOrD;AAED,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAS5D;AAED,wBAAsB,gBAAgB,CACpC,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,gBAAgB,EACvB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CAgBf;AAsBD,wBAAgB,oCAAoC,CAAC,MAAM,EAAE;IAC3D,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,WAAW,CAAC;CACvB,GAAG,IAAI,CAqBP;AAED,wBAAsB,yBAAyB,CAC7C,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAwDvC"}

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

@@ -0,0 +1,132 @@
+import fsSync, {} from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { FsSafeError } from "./errors.js";
+import { sameFileIdentityForCleanup } from "./file-identity.js";
+import { getNativeBinding } from "./native.js";
+export function nativeOpenFlags(flags) {
+    const closeOnExec = fsSync.constants.O_CLOEXEC;
+    return (flags |
+        (closeOnExec ?? 0) |
+        (typeof fsSync.constants.O_NOFOLLOW === "number" ? fsSync.constants.O_NOFOLLOW : 0));
+}
+export function writeNativeFd(fd, data) {
+    let offset = 0;
+    while (offset < data.byteLength) {
+        const written = fsSync.writeSync(fd, data, offset, data.byteLength - offset);
+        if (written <= 0) {
+            throw Object.assign(new Error("native file write made no progress"), { code: "EIO" });
+        }
+        offset += written;
+    }
+}
+export async function writeNativeInput(fd, input, maxBytes) {
+    let bytes = 0;
+    const write = (data) => {
+        bytes += data.byteLength;
+        if (maxBytes !== undefined && bytes > maxBytes) {
+            throw new FsSafeError("too-large", `file exceeds limit of ${maxBytes} bytes (got at least ${bytes})`);
+        }
+        writeNativeFd(fd, data);
+    };
+    if (input.kind === "buffer") {
+        write(typeof input.data === "string" ? Buffer.from(input.data, input.encoding ?? "utf8") : input.data);
+    }
+    else {
+        for await (const chunk of input.stream) {
+            write(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        }
+    }
+}
+function wrapNativeFd(fd, containment) {
+    let open = true;
+    return {
+        fd,
+        containment,
+        async close() {
+            if (open) {
+                open = false;
+                fsSync.closeSync(fd);
+            }
+        },
+        async stat() {
+            return fsSync.fstatSync(fd);
+        },
+        async writeFile(data, encoding) {
+            writeNativeFd(fd, Buffer.isBuffer(data) ? data : Buffer.from(data, encoding ?? "utf8"));
+        },
+    };
+}
+export function removeNativeCreatedFileIfStillPinned(params) {
+    if (!params.created) {
+        return;
+    }
+    try {
+        const parentPathStat = fsSync.lstatSync(params.parentPath, { bigint: true });
+        const parentFdStat = fsSync.fstatSync(params.parentFd, { bigint: true });
+        const targetPath = path.join(params.parentPath, params.basename);
+        const target = fsSync.lstatSync(targetPath, { bigint: true });
+        if (!parentPathStat.isSymbolicLink() && parentPathStat.isDirectory() &&
+            sameFileIdentityForCleanup(parentPathStat, parentFdStat) &&
+            !target.isSymbolicLink() && target.isFile() &&
+            sameFileIdentityForCleanup(target, params.created)) {
+            fsSync.rmSync(targetPath);
+        }
+    }
+    catch {
+        // Failed cleanup leaves a fail-closed artifact instead of deleting an
+        // unverified pathname.
+    }
+}
+export async function createNativeExclusiveFile(targetPath, mode) {
+    const binding = getNativeBinding();
+    if (!binding) {
+        return undefined;
+    }
+    const parentPath = path.dirname(targetPath);
+    const basename = path.basename(targetPath);
+    const parent = await fs.open(parentPath, fsSync.constants.O_RDONLY |
+        (typeof fsSync.constants.O_DIRECTORY === "number" ? fsSync.constants.O_DIRECTORY : 0));
+    let fd;
+    let created;
+    try {
+        let opened;
+        try {
+            opened = binding.openBeneath(parent.fd, basename, nativeOpenFlags(fsSync.constants.O_WRONLY | fsSync.constants.O_CREAT | fsSync.constants.O_EXCL));
+        }
+        catch (error) {
+            // The parent open above and every post-create operation remain untagged.
+            // Only this exclusive-open failure has enough provenance for a caller to
+            // classify a Windows lock-file denial without swallowing setup failures.
+            const openError = error;
+            if (process.platform === "win32" && openError.code === "EPERM") {
+                openError.path = targetPath;
+            }
+            throw error;
+        }
+        fd = opened.fd;
+        fsSync.fchmodSync(fd, mode);
+        created = fsSync.fstatSync(fd, { bigint: true });
+        return wrapNativeFd(fd, opened.containment);
+    }
+    catch (error) {
+        if (fd !== undefined) {
+            try {
+                fsSync.closeSync(fd);
+            }
+            catch {
+                // Preserve the original error.
+            }
+            removeNativeCreatedFileIfStillPinned({
+                parentPath,
+                parentFd: parent.fd,
+                basename,
+                created,
+            });
+        }
+        throw error;
+    }
+    finally {
+        await parent.close().catch(() => undefined);
+    }
+}

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

@@ -0,0 +1,8 @@
+import type { FileHandle } from "node:fs/promises";
+import type { AnyAsyncDirectoryGuard } from "./directory-guard.js";
+import type { FileIdentityStat } from "./file-identity.js";
+import type { NativeBinding } from "./native.js";
+import type { PinnedWriteParams } from "./pinned-write.js";
+export declare function sameNativeIdentity(left: Pick<FileIdentityStat, "dev" | "ino">, right: Pick<FileIdentityStat, "dev" | "ino">): boolean;
+export declare function runPinnedWriteWindows(binding: NativeBinding, params: PinnedWriteParams, root: FileHandle, parentFd: number, parentGuard: AnyAsyncDirectoryGuard): Promise<FileIdentityStat>;
+//# sourceMappingURL=native-pinned-write-windows.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"native-pinned-write-windows.d.ts","sourceRoot":"","sources":["../src/native-pinned-write-windows.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAEnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAM3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAG3D,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,IAAI,CAAC,gBAAgB,EAAE,KAAK,GAAG,KAAK,CAAC,EAC3C,KAAK,EAAE,IAAI,CAAC,gBAAgB,EAAE,KAAK,GAAG,KAAK,CAAC,GAC3C,OAAO,CAET;AAWD,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,iBAAiB,EACzB,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,sBAAsB,GAClC,OAAO,CAAC,gBAAgB,CAAC,CAiF3B"}

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

@@ -0,0 +1,96 @@
+import { syncFileBestEffortSync } from "./file-sync.js";
+import { randomUUID } from "node:crypto";
+import fsSync, {} from "node:fs";
+import { FsSafeError } from "./errors.js";
+import { nativeOpenFlags, removeNativeCreatedFileIfStillPinned, writeNativeInput, } from "./native-operations.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
+export function sameNativeIdentity(left, right) {
+    return left.dev === right.dev && left.ino === right.ino;
+}
+function closeWriteFd(fd) {
+    if (fd === undefined)
+        return;
+    try {
+        fsSync.closeSync(fd);
+    }
+    catch (error) {
+        return error;
+    }
+}
+export async function runPinnedWriteWindows(binding, params, root, parentFd, parentGuard) {
+    const parentPath = parentGuard.realPath;
+    let tempFd;
+    let targetFd;
+    let tempIdentity;
+    let tempName = "";
+    let renamed = false;
+    let completed = false;
+    try {
+        tempName = `.fs-safe-${randomUUID()}.tmp`;
+        tempFd = binding.openBeneath(parentFd, tempName, nativeOpenFlags(fsSync.constants.O_WRONLY | fsSync.constants.O_CREAT | fsSync.constants.O_EXCL)).fd;
+        const verificationIdentity = inspectFileIdentitySync(() => fsSync.fstatSync(tempFd, { bigint: true }));
+        tempIdentity = verificationIdentity;
+        // Creation is requested at 0600 in the binding, but a restrictive umask
+        // can remove owner access. Keep the unpublished inode private and
+        // reopenable until the published name has been identity-fenced.
+        fsSync.fchmodSync(tempFd, 0o600);
+        await writeNativeInput(tempFd, params.input, params.maxBytes);
+        if (params.sync !== false)
+            syncFileBestEffortSync(tempFd);
+        if (params.overwrite === false) {
+            binding.renameNoReplace(parentFd, tempName, parentFd, params.basename);
+        }
+        else {
+            binding.renameReplace(parentFd, tempName, parentFd, params.basename);
+        }
+        renamed = true;
+        targetFd = binding.openBeneath(parentFd, params.basename, nativeOpenFlags(fsSync.constants.O_RDONLY)).fd;
+        const targetStat = inspectFileIdentitySync(() => fsSync.fstatSync(targetFd, { bigint: true }), verificationIdentity);
+        const targetIdentity = binding.fstatIdentity(targetFd);
+        if (!targetStat.isFile()) {
+            throw new FsSafeError("path-mismatch", "native write target changed after rename");
+        }
+        // Native exclusive creation starts at 0600. Apply the requested mode only
+        // after reopening and fencing the published name, both so mode 000 stays
+        // verifiable and so broader modes are never exposed before that fence.
+        try {
+            fsSync.fchmodSync(targetFd, params.mode);
+            if (params.sync !== false)
+                syncFileBestEffortSync(targetFd);
+        }
+        catch (error) {
+            closeWriteFd(targetFd);
+            targetFd = undefined;
+            removeNativeCreatedFileIfStillPinned({
+                parentPath,
+                parentFd,
+                basename: params.basename,
+                created: tempIdentity,
+            });
+            throw error;
+        }
+        if (params.sync !== false)
+            syncFileBestEffortSync(parentFd);
+        // Verification follows publication and final chmod, outside rollback handling.
+        await params.verifyPublished?.(targetFd, verificationIdentity, parentGuard);
+        completed = true;
+        return { dev: targetIdentity.dev, ino: targetIdentity.ino };
+    }
+    finally {
+        const targetCloseError = closeWriteFd(targetFd);
+        const tempCloseError = closeWriteFd(tempFd);
+        if (!renamed) {
+            removeNativeCreatedFileIfStillPinned({
+                parentPath,
+                parentFd,
+                basename: tempName,
+                created: tempIdentity,
+            });
+        }
+        const parentCloseError = closeWriteFd(parentFd);
+        await root.close().catch(() => undefined);
+        const closeError = targetCloseError ?? tempCloseError ?? parentCloseError;
+        if (completed && closeError !== undefined)
+            throw closeError;
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { FileIdentityStat } from "./file-identity.js";
+import type { NativeBinding } from "./native.js";
+import type { PinnedWriteParams } from "./pinned-write.js";
+export declare function runPinnedWriteNative(binding: NativeBinding, params: PinnedWriteParams): Promise<FileIdentityStat>;
+//# sourceMappingURL=native-pinned-write.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"native-pinned-write.d.ts","sourceRoot":"","sources":["../src/native-pinned-write.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAG3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAI3D,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA0FvH"}

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

@@ -0,0 +1,161 @@
+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 fsSync from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { inspectDirectoryIdentity } from "./directory-guard.js";
+import { FsSafeError } from "./errors.js";
+import { runPinnedWriteWindows, sameNativeIdentity } from "./native-pinned-write-windows.js";
+import { assertNativeStaging, writeNativeStage } from "./native-staged-file.js";
+import { describeStagedDirectory, exactIdentityMatches } from "./staged-directory.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
+export async function runPinnedWriteNative(binding, params) {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const windows = process.platform === "win32";
+        if (!windows) {
+            assertNativeStaging(binding);
+        }
+        const directoryFlags = fsSync.constants.O_RDONLY | (fsSync.constants.O_DIRECTORY ?? 0);
+        const root = await fs.open(params.rootPath, directoryFlags);
+        const posixRoot = __addDisposableResource(env_1, windows ? undefined : root, true);
+        let parentFd;
+        let windowsOwnsDirectories = false;
+        // Until stage construction takes ownership, even admission failures must close
+        // the raw POSIX parent. Disposal preserves both admission and close failures.
+        const parentGuard = __addDisposableResource(env_1, {
+            [Symbol.dispose]() {
+                if (!windows && parentFd !== undefined) {
+                    fsSync.closeSync(parentFd);
+                }
+            },
+        }, false);
+        try {
+            const exactRoot = typeof params.rootIdentity?.dev === "bigint" && typeof params.rootIdentity.ino === "bigint"
+                ? { dev: params.rootIdentity.dev, ino: params.rootIdentity.ino } : undefined;
+            let rootMatches;
+            if (exactRoot) {
+                inspectFileIdentitySync(() => fsSync.fstatSync(root.fd, { bigint: true }), exactRoot);
+                rootMatches = true;
+            }
+            else if (windows) {
+                const identity = binding.fstatIdentity(root.fd);
+                rootMatches = !params.rootIdentity || sameNativeIdentity(params.rootIdentity, identity);
+            }
+            else {
+                const identity = fsSync.fstatSync(root.fd, { bigint: true });
+                rootMatches = !params.rootIdentity || exactIdentityMatches(params.rootIdentity, identity);
+            }
+            if (!rootMatches) {
+                throw new FsSafeError("path-mismatch", "root path changed during native write");
+            }
+            if (params.mkdir) {
+                binding.mkdirBeneath(root.fd, params.relativeParentPath, 0o777);
+            }
+            parentFd = binding.openBeneath(root.fd, params.relativeParentPath, directoryFlags).fd;
+            const parentPath = fsSync.realpathSync.native(params.relativeParentPath
+                ? path.join(params.rootPath, ...params.relativeParentPath.split("/"))
+                : params.rootPath);
+            const directory = windows ? undefined : describeStagedDirectory(parentFd, parentPath);
+            const parentPathStat = exactRoot
+                ? await inspectDirectoryIdentity(parentPath, inspectFileIdentitySync(() => fsSync.fstatSync(parentFd, { bigint: true })))
+                : fsSync.lstatSync(parentPath);
+            if (windows && !exactRoot) {
+                const parentIdentity = binding.fstatIdentity(parentFd);
+                if (parentPathStat.isSymbolicLink() || !sameNativeIdentity(parentPathStat, parentIdentity)) {
+                    throw new FsSafeError("path-mismatch", "native write parent changed during resolution");
+                }
+            }
+            else if (!windows && (parentPathStat.isSymbolicLink() || !exactIdentityMatches(parentPathStat, directory.identity))) {
+                throw new FsSafeError("path-mismatch", "native write parent changed during resolution");
+            }
+            const verificationGuard = { dir: parentPath, realPath: parentPath, stat: parentPathStat };
+            if (params.overwrite === false) {
+                try {
+                    fsSync.lstatSync(path.join(parentPath, params.basename));
+                    throw Object.assign(new Error("destination already exists"), { code: "EEXIST" });
+                }
+                catch (error) {
+                    if (error.code !== "ENOENT") {
+                        throw error;
+                    }
+                }
+            }
+            if (windows) {
+                // The Windows leaf owns both directories after admission.
+                windowsOwnsDirectories = true;
+                return await runPinnedWriteWindows(binding, params, root, parentFd, verificationGuard);
+            }
+            const ownedParent = parentFd;
+            parentFd = undefined;
+            return await writeNativeStage(binding, ownedParent, directory, params, verificationGuard);
+        }
+        finally {
+            if (windows && !windowsOwnsDirectories) {
+                if (parentFd !== undefined) {
+                    fsSync.closeSync(parentFd);
+                }
+                await root.close().catch(() => undefined);
+            }
+        }
+    }
+    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;
+    }
+}

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

@@ -0,0 +1,31 @@
+import type { DirectoryReceipt } from "./directory-durability.js";
+import type { AnyAsyncDirectoryGuard } from "./directory-guard.js";
+import type { FileIdentityStat } from "./file-identity.js";
+import type { NativeBinding } from "./native-binding.js";
+import type { PinnedWriteInput, PinnedWriteParams } from "./pinned-write.js";
+import type { PublishedFileReceipt, StagedFile, StagedFileCleanupReceipt, StagedFileReceipt } from "./staged-file-types.js";
+export type NativeStagingBinding = NativeBinding & Required<Pick<NativeBinding, "createStagedFile" | "stagedFileMatches" | "removeStagedFile">>;
+export declare function assertNativeStaging(binding: NativeBinding): asserts binding is NativeStagingBinding;
+declare class NativeStagedFile implements StagedFile {
+    #private;
+    constructor(binding: NativeStagingBinding, parentFd: number, directory: StagedFileReceipt["directory"], portableNames: boolean, publishedMode: number, sync: boolean);
+    static create(binding: NativeStagingBinding, parentFd: number, directory: StagedFileReceipt["directory"], input: PinnedWriteInput, mode: number, maxBytes?: number, portableNames?: boolean, sync?: boolean): Promise<NativeStagedFile>;
+    static write(binding: NativeStagingBinding, parentFd: number, directory: StagedFileReceipt["directory"], params: PinnedWriteParams, parentGuard: AnyAsyncDirectoryGuard): Promise<FileIdentityStat>;
+    get receipt(): StagedFileReceipt;
+    assertCurrent(): Promise<void>;
+    publish(basename: string, options: {
+        overwrite: boolean;
+    }): Promise<PublishedFileReceipt>;
+    cleanup(): Promise<StagedFileCleanupReceipt>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+export declare const createNativeStage: (...args: Parameters<typeof NativeStagedFile.create>) => Promise<StagedFile>;
+export declare const writeNativeStage: typeof NativeStagedFile.write;
+export type { PublishedFileReceipt, StagedFile, StagedFileCleanupReceipt, StagedFileFailureDetails, StagedFilePublication, StagedFileReceipt, } from "./staged-file-types.js";
+export declare function stageFileInDirectory(options: {
+    directory: string | DirectoryReceipt;
+    content: string | Uint8Array;
+    /** Published mode; the unpublished stage stays at 0600. Defaults to 0600. */
+    mode?: number;
+}): Promise<StagedFile>;
+//# sourceMappingURL=native-staged-file.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"native-staged-file.d.ts","sourceRoot":"","sources":["../src/native-staged-file.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAKlE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAEnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE7E,OAAO,KAAK,EACV,oBAAoB,EACpB,UAAU,EACV,wBAAwB,EAGxB,iBAAiB,EAClB,MAAM,wBAAwB,CAAC;AAEhC,MAAM,MAAM,oBAAoB,GAAG,aAAa,GAAG,QAAQ,CAAC,IAAI,CAC9D,aAAa,EACb,kBAAkB,GAAG,mBAAmB,GAAG,kBAAkB,CAC9D,CAAC,CAAC;AAEH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,IAAI,oBAAoB,CAUnG;AA6BD,cAAM,gBAAiB,YAAW,UAAU;;IAW1C,YACE,OAAO,EAAE,oBAAoB,EAC7B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,iBAAiB,CAAC,WAAW,CAAC,EACzC,aAAa,EAAE,OAAO,EACtB,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,OAAO,EAQd;IAGD,OAAa,MAAM,CACjB,OAAO,EAAE,oBAAoB,EAC7B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,iBAAiB,CAAC,WAAW,CAAC,EACzC,KAAK,EAAE,gBAAgB,EACvB,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,MAAM,EAEjB,aAAa,UAAO,EACpB,IAAI,UAAO,GACV,OAAO,CAAC,gBAAgB,CAAC,CAc3B;IAED,OAAa,KAAK,CAChB,OAAO,EAAE,oBAAoB,EAC7B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,iBAAiB,CAAC,WAAW,CAAC,EACzC,MAAM,EAAE,iBAAiB,EACzB,WAAW,EAAE,sBAAsB,GAClC,OAAO,CAAC,gBAAgB,CAAC,CAU3B;IAED,IAAI,OAAO,IAAI,iBAAiB,CAK/B;IAoFK,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAEnC;IAEK,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAqD9F;IA6CK,OAAO,IAAI,OAAO,CAAC,wBAAwB,CAAC,CAMjD;IAEK,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAO3C;CACF;AAED,eAAO,MAAM,iBAAiB,EAAE,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,MAAM,CAAC,KAAK,OAAO,CAAC,UAAU,CAClF,CAAC;AAC1B,eAAO,MAAM,gBAAgB,+BAAyB,CAAC;AAEvD,YAAY,EACV,oBAAoB,EAAE,UAAU,EAAE,wBAAwB,EAAE,wBAAwB,EACpF,qBAAqB,EAAE,iBAAiB,GACzC,MAAM,wBAAwB,CAAC;AAEhC,wBAAsB,oBAAoB,CAAC,OAAO,EAAE;IAClD,SAAS,EAAE,MAAM,GAAG,gBAAgB,CAAC;IACrC,OAAO,EAAE,MAAM,GAAG,UAAU,CAAC;IAC7B,6EAA6E;IAC7E,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,GAAG,OAAO,CAAC,UAAU,CAAC,CAUtB"}