@openclaw/openshell-sandbox 2026.9.4 → 2026.9.5

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

@@ -0,0 +1,32 @@
+import { type BigIntStats, type Stats } from "node:fs";
+import type { FileHandle } from "node:fs/promises";
+import type { FileIdentityStat } from "./file-identity.js";
+import type { NativeBinding } from "./native.js";
+import { describeStagedDirectory } from "./staged-directory.js";
+type RootIdentity = Pick<FileIdentityStat, "dev" | "ino">;
+export type NativeRootAdmission = {
+    exactRoot: boolean;
+    operation: string;
+    root: FileHandle;
+    rootPath: string;
+};
+export type NativeParentAdmission = {
+    fd: number;
+    close(): void;
+    guard: {
+        dir: string;
+        realPath: string;
+        stat: Stats | BigIntStats;
+    };
+    stagedDirectory?: ReturnType<typeof describeStagedDirectory>;
+};
+export declare function sameNativeIdentity(left: RootIdentity, right: RootIdentity): boolean;
+export declare function openNativeRootAdmission(binding: NativeBinding, params: {
+    rootPath: string;
+    rootIdentity?: RootIdentity;
+    operation?: string;
+}): Promise<NativeRootAdmission>;
+export declare function openNativeParentAdmission(binding: NativeBinding, rootAdmission: NativeRootAdmission, relativeParentPath: string): Promise<NativeParentAdmission>;
+export declare function closeNativeParentAdmission(admission: NativeParentAdmission | undefined): void;
+export {};
+//# sourceMappingURL=native-parent-admission.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"native-parent-admission.d.ts","sourceRoot":"","sources":["../src/native-parent-admission.ts"],"names":[],"mappings":"AAAA,OAAe,EAAE,KAAK,WAAW,EAAE,KAAK,KAAK,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAKnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD,OAAO,EAAE,uBAAuB,EAAwB,MAAM,uBAAuB,CAAC;AAKtF,KAAK,YAAY,GAAG,IAAI,CAAC,gBAAgB,EAAE,KAAK,GAAG,KAAK,CAAC,CAAC;AAE1D,MAAM,MAAM,mBAAmB,GAAG;IAChC,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,IAAI,IAAI,CAAC;IACd,KAAK,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,KAAK,GAAG,WAAW,CAAA;KAAE,CAAC;IACpE,eAAe,CAAC,EAAE,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAC;CAC9D,CAAC;AAEF,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,YAAY,EAClB,KAAK,EAAE,YAAY,GAClB,OAAO,CAET;AAaD,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,YAAY,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5E,OAAO,CAAC,mBAAmB,CAAC,CAgD9B;AAED,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,aAAa,EACtB,aAAa,EAAE,mBAAmB,EAClC,kBAAkB,EAAE,MAAM,GACzB,OAAO,CAAC,qBAAqB,CAAC,CA+DhC;AAED,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,qBAAqB,GAAG,SAAS,GAAG,IAAI,CAE7F"}

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

@@ -0,0 +1,127 @@
+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 { captureNativeFdClose } from "./native-binding.js";
+import { realpathSync } from "./realpath.js";
+import { describeStagedDirectory, exactIdentityMatches } from "./staged-directory.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
+import { createSuppressedError } from "./suppressed-error.js";
+import { assertNoWindowsPathAlias, pathForWindowsFilesystem } from "./windows-path-alias.js";
+export function sameNativeIdentity(left, right) {
+    return left.dev === right.dev && left.ino === right.ino;
+}
+function unavailable(message) {
+    return new FsSafeError("helper-unavailable", message);
+}
+function assertParentAdmissionAvailable(binding) {
+    if (typeof binding.openBeneath !== "function") {
+        throw unavailable("native parent directory admission is unavailable");
+    }
+    captureNativeFdClose(binding);
+}
+export async function openNativeRootAdmission(binding, params) {
+    assertParentAdmissionAvailable(binding);
+    const directoryFlags = fsSync.constants.O_RDONLY | (fsSync.constants.O_DIRECTORY ?? 0);
+    assertNoWindowsPathAlias(params.rootPath, "filesystem", "native root uses a Windows filesystem namespace alias");
+    const root = await fs.open(pathForWindowsFilesystem(params.rootPath), directoryFlags);
+    try {
+        const exactRoot = typeof params.rootIdentity?.dev === "bigint" &&
+            typeof params.rootIdentity.ino === "bigint";
+        let rootMatches;
+        if (exactRoot) {
+            inspectFileIdentitySync(() => fsSync.fstatSync(root.fd, { bigint: true }), params.rootIdentity);
+            rootMatches = true;
+        }
+        else if (process.platform === "win32") {
+            if (typeof binding.fstatIdentity !== "function") {
+                throw unavailable("native root directory identity checks are unavailable");
+            }
+            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 ${params.operation ?? "native admission"}`);
+        }
+        return {
+            exactRoot,
+            operation: params.operation ?? "native admission",
+            root,
+            rootPath: params.rootPath,
+        };
+    }
+    catch (error) {
+        try {
+            await root.close();
+        }
+        catch (closeError) {
+            // Windows admission keeps the typed boundary failure primary.
+            if (process.platform !== "win32") {
+                throw createSuppressedError(closeError, error, "native root admission and close failed");
+            }
+        }
+        throw error;
+    }
+}
+export async function openNativeParentAdmission(binding, rootAdmission, relativeParentPath) {
+    assertParentAdmissionAvailable(binding);
+    const closeFd = captureNativeFdClose(binding);
+    const directoryFlags = fsSync.constants.O_RDONLY | (fsSync.constants.O_DIRECTORY ?? 0);
+    assertNoWindowsPathAlias(relativeParentPath, "relative", "native parent uses a Windows filesystem namespace alias");
+    const opened = binding.openBeneath(rootAdmission.root.fd, relativeParentPath, directoryFlags);
+    if (!opened || !Number.isInteger(opened.fd) || opened.fd < 0) {
+        throw unavailable("native parent directory admission did not provide a descriptor");
+    }
+    const parentFd = opened.fd;
+    try {
+        const parentInput = relativeParentPath
+            ? path.join(rootAdmission.rootPath, ...relativeParentPath.split("/"))
+            : rootAdmission.rootPath;
+        const parentPath = realpathSync.native(pathForWindowsFilesystem(parentInput));
+        assertNoWindowsPathAlias(parentPath, "filesystem", "native parent uses a Windows filesystem namespace alias");
+        const stagedDirectory = process.platform === "win32"
+            ? undefined
+            : describeStagedDirectory(parentFd, parentPath);
+        const parentPathStat = rootAdmission.exactRoot
+            ? await inspectDirectoryIdentity(parentPath, inspectFileIdentitySync(() => fsSync.fstatSync(parentFd, { bigint: true })))
+            : fsSync.lstatSync(pathForWindowsFilesystem(parentPath));
+        if (process.platform === "win32" && !rootAdmission.exactRoot) {
+            if (typeof binding.fstatIdentity !== "function") {
+                throw unavailable("native parent directory identity checks are unavailable");
+            }
+            const parentIdentity = binding.fstatIdentity(parentFd);
+            if (parentPathStat.isSymbolicLink() || !sameNativeIdentity(parentPathStat, parentIdentity)) {
+                throw new FsSafeError("path-mismatch", `${rootAdmission.operation} parent changed during resolution`);
+            }
+        }
+        else if (process.platform !== "win32" &&
+            (parentPathStat.isSymbolicLink() || !exactIdentityMatches(parentPathStat, stagedDirectory.identity))) {
+            throw new FsSafeError("path-mismatch", `${rootAdmission.operation} parent changed during resolution`);
+        }
+        return {
+            fd: parentFd,
+            close: () => closeFd(parentFd),
+            guard: { dir: parentPath, realPath: parentPath, stat: parentPathStat },
+            stagedDirectory,
+        };
+    }
+    catch (error) {
+        try {
+            closeFd(parentFd);
+        }
+        catch (closeError) {
+            if (process.platform !== "win32") {
+                throw createSuppressedError(closeError, error, "native parent admission and close failed");
+            }
+        }
+        throw error;
+    }
+}
+export function closeNativeParentAdmission(admission) {
+    admission?.close();
+}

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

@@ -3,6 +3,5 @@ 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

@@ -1 +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"}
+{"version":3,"file":"native-pinned-write-windows.d.ts","sourceRoot":"","sources":["../src/native-pinned-write-windows.ts"],"names":[],"mappings":"AAIA,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;AAEjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAa3D,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,CA2F3B"}

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

@@ -1,23 +1,24 @@
 import { syncFileBestEffortSync } from "./file-sync.js";
 import { randomUUID } from "node:crypto";
 import fsSync, {} from "node:fs";
+import path from "node:path";
 import { FsSafeError } from "./errors.js";
 import { nativeOpenFlags, removeNativeCreatedFileIfStillPinned, writeNativeInput, } from "./native-operations.js";
+import { captureNativeFdClose } from "./native-binding.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) {
+import { assertFinalSymlinkRejected } from "./root-symlink-policy.js";
+function closeWriteFd(closeFd, fd) {
     if (fd === undefined)
         return;
     try {
-        fsSync.closeSync(fd);
+        closeFd(fd);
     }
     catch (error) {
         return error;
     }
 }
 export async function runPinnedWriteWindows(binding, params, root, parentFd, parentGuard) {
+    const closeFd = captureNativeFdClose(binding);
     const parentPath = parentGuard.realPath;
     let tempFd;
     let targetFd;
@@ -27,6 +28,7 @@ export async function runPinnedWriteWindows(binding, params, root, parentFd, par
     let completed = false;
     try {
         tempName = `.fs-safe-${randomUUID()}.tmp`;
+        params.assertBeforeMutation?.();
         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;
@@ -34,9 +36,13 @@ export async function runPinnedWriteWindows(binding, params, root, parentFd, par
         // 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);
+        await writeNativeInput(tempFd, params.input, params.maxBytes, params.assertBeforeMutation);
         if (params.sync !== false)
             syncFileBestEffortSync(tempFd);
+        if (params.input.kind === "file")
+            await params.input.verifySource();
+        assertFinalSymlinkRejected(path.join(parentPath, params.basename), params.rejectFinalSymlink);
+        params.assertBeforeMutation?.();
         if (params.overwrite === false) {
             binding.renameNoReplace(parentFd, tempName, parentFd, params.basename);
         }
@@ -44,6 +50,7 @@ export async function runPinnedWriteWindows(binding, params, root, parentFd, par
             binding.renameReplace(parentFd, tempName, parentFd, params.basename);
         }
         renamed = true;
+        params.onPublished?.(verificationIdentity);
         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);
@@ -59,14 +66,18 @@ export async function runPinnedWriteWindows(binding, params, root, parentFd, par
                 syncFileBestEffortSync(targetFd);
         }
         catch (error) {
-            closeWriteFd(targetFd);
+            closeWriteFd(closeFd, targetFd);
             targetFd = undefined;
-            removeNativeCreatedFileIfStillPinned({
-                parentPath,
-                parentFd,
-                basename: params.basename,
-                created: tempIdentity,
-            });
+            // Staged copies and streamed creates preserve publication for caller recovery.
+            if (params.input.kind === "buffer" ||
+                (params.input.kind === "stream" && !params.input.stageBeforePublish)) {
+                removeNativeCreatedFileIfStillPinned({
+                    parentPath,
+                    parentFd,
+                    basename: params.basename,
+                    created: tempIdentity,
+                });
+            }
             throw error;
         }
         if (params.sync !== false)
@@ -77,8 +88,8 @@ export async function runPinnedWriteWindows(binding, params, root, parentFd, par
         return { dev: targetIdentity.dev, ino: targetIdentity.ino };
     }
     finally {
-        const targetCloseError = closeWriteFd(targetFd);
-        const tempCloseError = closeWriteFd(tempFd);
+        const targetCloseError = closeWriteFd(closeFd, targetFd);
+        const tempCloseError = closeWriteFd(closeFd, tempFd);
         if (!renamed) {
             removeNativeCreatedFileIfStillPinned({
                 parentPath,
@@ -87,7 +98,7 @@ export async function runPinnedWriteWindows(binding, params, root, parentFd, par
                 created: tempIdentity,
             });
         }
-        const parentCloseError = closeWriteFd(parentFd);
+        const parentCloseError = closeWriteFd(closeFd, parentFd);
         await root.close().catch(() => undefined);
         const closeError = targetCloseError ?? tempCloseError ?? parentCloseError;
         if (completed && closeError !== undefined)

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

@@ -1 +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"}
+{"version":3,"file":"native-pinned-write.d.ts","sourceRoot":"","sources":["../src/native-pinned-write.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAI3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,OAAO,KAAK,EAIV,iBAAiB,EAClB,MAAM,mBAAmB,CAAC;AAqV3B,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAsGvH"}