@openclaw/openshell-sandbox 2026.9.4 → 2026.9.6

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

@@ -1,37 +1,27 @@
 import { createHash } from "node:crypto";
 import fsSync, {} from "node:fs";
-import fs from "node:fs/promises";
+import fs, {} from "node:fs/promises";
 import path from "node:path";
 import { pinDirectory, } from "./directory-durability.js";
 import { FsSafeError } from "./errors.js";
+import { ownDirectoryReceipt } from "./directory-receipt.js";
 import { hashFileHandle } from "./file-hash.js";
 import { sameFileIdentity, sameFileIdentityForCleanup, } from "./file-identity.js";
 import { syncFileBestEffortSync } from "./file-sync.js";
 import { getNativeBinding, requireNativeBinding } from "./native.js";
+import { captureNativeFdClose } from "./native-binding.js";
 import { resolveReadOpenFlags } from "./read-open-flags.js";
 import { directorySyncFailure, publicationFailure, rememberCreatedTarget, } from "./publish-file-failure.js";
+import { admitStandalonePublicationPath, assertNoWindowsPathAlias } from "./windows-path-alias.js";
 import { getFsSafeTestHooks } from "./test-hooks.js";
-const HARDLINK_FALLBACK_CODES = new Set([
-    "EPERM",
-    "EXDEV",
-    "ENOTSUP",
-    "EOPNOTSUPP",
-    "ENOSYS",
-]);
-const NATIVE_COPY_FALLBACK_CODES = new Set([
-    "EINVAL",
-    "ENOSYS",
-    "ENOTSUP",
-    "EOPNOTSUPP",
-    "EPERM",
-    "EXDEV",
-]);
+import { hasErrorCode } from "./file-cleanup.js";
+import { writeAllToFile } from "./write-file-handle.js";
+const HARDLINK_FALLBACK_CODES = new Set(["EPERM", "EXDEV", "ENOTSUP", "EOPNOTSUPP", "ENOSYS"]);
+const NATIVE_COPY_FALLBACK_CODES = new Set(["EINVAL", "ENOSYS", "ENOTSUP", "EOPNOTSUPP", "EPERM", "EXDEV"]);
 export function isHardlinkFallbackError(error) {
     return HARDLINK_FALLBACK_CODES.has(error?.code ?? "");
 }
-function sourceOpenFlags() {
-    return resolveReadOpenFlags();
-}
+function sourceOpenFlags() { return resolveReadOpenFlags(); }
 function directoryOpenFlags() {
     return (fsSync.constants.O_RDONLY |
         (typeof fsSync.constants.O_DIRECTORY === "number" ? fsSync.constants.O_DIRECTORY : 0));
@@ -40,8 +30,8 @@ async function openNativeParent(filePath) {
     const parentPath = path.dirname(filePath);
     const handle = await fs.open(parentPath, directoryOpenFlags());
     try {
-        const pathname = await fs.lstat(parentPath, { bigint: true });
-        const opened = await handle.stat({ bigint: true });
+        const pathname = fsSync.lstatSync(parentPath, { bigint: true });
+        const opened = fsSync.fstatSync(handle.fd, { bigint: true });
         if (pathname.isSymbolicLink() || !sameFileIdentity(pathname, opened)) {
             throw new FsSafeError("path-mismatch", "publication parent changed while opening");
         }
@@ -52,11 +42,11 @@ async function openNativeParent(filePath) {
         throw error;
     }
 }
-async function assertPinnedSourceCurrent(params) {
+function assertPinnedSourceCurrent(params) {
     // Windows file indexes can exceed Number.MAX_SAFE_INTEGER, so publication
     // fences must compare bigint stats instead of rounded numeric identities.
-    const opened = await params.handle.stat({ bigint: true });
-    const current = await fs.lstat(params.sourcePath, { bigint: true });
+    const opened = fsSync.fstatSync(params.handle.fd, { bigint: true });
+    const current = fsSync.lstatSync(params.sourcePath, { bigint: true });
     if (!opened.isFile() ||
         current.isSymbolicLink() ||
         !current.isFile() ||
@@ -65,8 +55,26 @@ async function assertPinnedSourceCurrent(params) {
         throw new FsSafeError("path-mismatch", "publication source changed during operation");
     }
 }
+function assertPublishedTargetCurrent(targetPath, identity, message) {
+    const current = fsSync.lstatSync(targetPath, { bigint: true });
+    if (current.isSymbolicLink() || !current.isFile() || !sameFileIdentity(current, identity)) {
+        throw new FsSafeError("path-mismatch", message);
+    }
+}
+function assertRenamedSourceAbsent(sourcePath) {
+    try {
+        fsSync.lstatSync(sourcePath);
+    }
+    catch (error) {
+        if (hasErrorCode(error, "ENOENT"))
+            return;
+        throw error;
+    }
+    throw new FsSafeError("path-mismatch", "no-replace publication source still exists");
+}
 async function copyPinnedSource(params) {
     if (params.native && params.targetNativeParent) {
+        const closeFd = captureNativeFdClose(params.native);
         for (const method of ["clone", "copy-file-range"]) {
             let nativeFd;
             try {
@@ -90,15 +98,15 @@ async function copyPinnedSource(params) {
                 throw error;
             }
             let target;
-            let createdIdentity = fsSync.fstatSync(nativeFd, { bigint: true });
-            rememberCreatedTarget(params.failure, createdIdentity, "copy-verify");
             try {
+                let createdIdentity = fsSync.fstatSync(nativeFd, { bigint: true });
+                rememberCreatedTarget(params.failure, createdIdentity, "copy-verify");
                 fsSync.fchmodSync(nativeFd, 0o600);
                 createdIdentity = fsSync.fstatSync(nativeFd, { bigint: true });
                 await getFsSafeTestHooks()?.afterPublishTargetCreated?.("exclusive-copy", params.targetPath, createdIdentity);
-                const identity = await fs.lstat(params.targetPath, { bigint: true });
+                const identity = fsSync.lstatSync(params.targetPath, { bigint: true });
                 target = await fs.open(params.targetPath, sourceOpenFlags());
-                const opened = await target.stat({ bigint: true });
+                const opened = fsSync.fstatSync(target.fd, { bigint: true });
                 if (identity.isSymbolicLink() ||
                     !identity.isFile() ||
                     !sameFileIdentity(createdIdentity, identity) ||
@@ -106,8 +114,9 @@ async function copyPinnedSource(params) {
                     throw new FsSafeError("path-mismatch", "native publication target changed after copy");
                 }
                 const hashed = await hashFileHandle(target, params.native);
-                fsSync.closeSync(nativeFd);
+                const completedFd = nativeFd;
                 nativeFd = undefined;
+                closeFd(completedFd);
                 return {
                     handle: target,
                     exactIdentity: opened,
@@ -121,16 +130,16 @@ async function copyPinnedSource(params) {
             }
             finally {
                 if (nativeFd !== undefined)
-                    fsSync.closeSync(nativeFd);
+                    closeFd(nativeFd);
             }
         }
     }
     const target = await fs.open(params.targetPath, "wx+", 0o600);
-    const createdIdentity = await target.stat({ bigint: true });
-    rememberCreatedTarget(params.failure, createdIdentity, "copy-verify");
     try {
+        const createdIdentity = fsSync.fstatSync(target.fd, { bigint: true });
+        rememberCreatedTarget(params.failure, createdIdentity, "copy-verify");
         await target.chmod(0o600);
-        const exactIdentity = await target.stat({ bigint: true });
+        const exactIdentity = fsSync.fstatSync(target.fd, { bigint: true });
         await getFsSafeTestHooks()?.afterPublishTargetCreated?.("exclusive-copy", params.targetPath, exactIdentity);
         const hash = createHash("sha256");
         const buffer = Buffer.allocUnsafe(64 * 1024);
@@ -140,15 +149,9 @@ async function copyPinnedSource(params) {
             if (bytesRead === 0) {
                 break;
             }
-            hash.update(buffer.subarray(0, bytesRead));
-            let written = 0;
-            while (written < bytesRead) {
-                const result = await target.write(buffer, written, bytesRead - written, position + written);
-                if (result.bytesWritten <= 0) {
-                    throw new FsSafeError("helper-failed", "exclusive publication copy made no progress");
-                }
-                written += result.bytesWritten;
-            }
+            const chunk = buffer.subarray(0, bytesRead);
+            hash.update(chunk);
+            await writeAllToFile(target, chunk, { position });
             position += bytesRead;
         }
         await target.sync();
@@ -164,7 +167,7 @@ async function removeCreatedTargetIfUnchanged(targetPath, identity) {
         return "unknown";
     }
     try {
-        const current = await fs.lstat(targetPath, { bigint: true });
+        const current = fsSync.lstatSync(targetPath, { bigint: true });
         if (!current.isSymbolicLink() && sameFileIdentityForCleanup(current, identity)) {
             await fs.rm(targetPath);
             return "removed";
@@ -189,13 +192,27 @@ async function syncPublishedParent(params) {
     }
 }
 export async function publishFileExclusive(params) {
-    const sourcePath = path.resolve(params.sourcePath);
-    const targetPath = path.resolve(params.targetPath);
+    const sourcePathInput = admitStandalonePublicationPath(params.sourcePath, "publication source uses a Windows filesystem namespace alias");
+    const targetPathInput = admitStandalonePublicationPath(params.targetPath, "publication target uses a Windows filesystem namespace alias");
+    const parentReceiptInput = params.parentReceipt;
+    const parentReceipt = parentReceiptInput
+        ? ownDirectoryReceipt(parentReceiptInput)
+        : undefined;
+    if (parentReceipt) {
+        assertNoWindowsPathAlias(parentReceipt.path, "filesystem", "publication parent uses a Windows filesystem namespace alias");
+    }
+    const sourcePath = path.resolve(sourcePathInput);
+    const targetPath = path.resolve(targetPathInput);
+    assertNoWindowsPathAlias(sourcePath, "filesystem", "publication source uses a Windows filesystem namespace alias");
+    assertNoWindowsPathAlias(targetPath, "filesystem", "publication target uses a Windows filesystem namespace alias");
     const parentPath = path.dirname(targetPath);
-    if (params.parentReceipt && path.resolve(params.parentReceipt.path) !== parentPath) {
+    if (parentReceipt && path.resolve(parentReceipt.path) !== parentPath) {
         throw new FsSafeError("path-mismatch", "publication parent receipt does not match target parent");
     }
-    const sourcePathStat = await fs.lstat(sourcePath);
+    if (parentReceipt) {
+        assertNoWindowsPathAlias(parentReceipt.realPath, "filesystem", "publication parent uses a Windows filesystem namespace alias");
+    }
+    const sourcePathStat = fsSync.lstatSync(sourcePath);
     if (sourcePathStat.isSymbolicLink() || !sourcePathStat.isFile()) {
         throw new FsSafeError("not-file", "publication source must be a regular file");
     }
@@ -203,71 +220,63 @@ export async function publishFileExclusive(params) {
     let parent;
     let sourceNativeParent;
     let targetNativeParent;
+    let copiedTarget;
+    const strategy = params.strategy;
     const failure = {
-        phase: params.strategy === "rename-noreplace" ? "rename-create" : "hardlink-create",
+        phase: strategy === "rename-noreplace" ? "rename-create" : "hardlink-create",
         targetCreated: false,
         preserveTarget: false,
     };
     try {
-        parent = await pinDirectory(params.parentReceipt ?? parentPath, {
+        parent = await pinDirectory(parentReceipt ?? parentPath, {
             label: "publication parent",
         });
-        const sourceIdentity = await source.stat();
-        const sourceExactIdentity = await source.stat({ bigint: true });
-        const sourcePathExactIdentity = await fs.lstat(sourcePath, { bigint: true });
+        const sourceIdentity = fsSync.fstatSync(source.fd);
+        const sourceExactIdentity = fsSync.fstatSync(source.fd, { bigint: true });
+        const sourcePathExactIdentity = fsSync.lstatSync(sourcePath, { bigint: true });
+        const expectedSourceIdentity = params.expectedSourceIdentity;
         if (sourcePathExactIdentity.isSymbolicLink() ||
             !sourcePathExactIdentity.isFile() ||
             !sameFileIdentity(sourcePathExactIdentity, sourceExactIdentity) ||
-            (params.expectedSourceIdentity &&
-                !sameFileIdentity(params.expectedSourceIdentity, typeof params.expectedSourceIdentity.dev === "bigint" ||
-                    typeof params.expectedSourceIdentity.ino === "bigint"
+            (expectedSourceIdentity &&
+                !sameFileIdentity(expectedSourceIdentity, typeof expectedSourceIdentity.dev === "bigint" ||
+                    typeof expectedSourceIdentity.ino === "bigint"
                     ? sourceExactIdentity
                     : sourceIdentity))) {
             throw new FsSafeError("path-mismatch", "publication source identity did not match");
         }
+        const assertSourceCurrent = () => assertPinnedSourceCurrent({ sourcePath, handle: source, identity: sourceExactIdentity });
+        const finishPublication = async (method, handle, identity) => {
+            const verifyPhase = failure.phase;
+            const directorySync = await syncPublishedParent({ parent: parent, failure, method, targetPath });
+            failure.phase = verifyPhase;
+            if (method === "rename-noreplace")
+                assertRenamedSourceAbsent(sourcePath);
+            else
+                assertSourceCurrent();
+            assertPublishedTargetCurrent(targetPath, identity, "publication target changed during directory sync");
+            return { method, identity: fsSync.fstatSync(handle.fd), directorySync };
+        };
         await parent.assertCurrent();
-        await assertPinnedSourceCurrent({ sourcePath, handle: source, identity: sourceExactIdentity });
-        const native = params.strategy === "rename-noreplace"
+        assertSourceCurrent();
+        const native = strategy === "rename-noreplace"
             ? requireNativeBinding()
             : getNativeBinding();
         if (native) {
             sourceNativeParent = await openNativeParent(sourcePath);
             targetNativeParent = await openNativeParent(targetPath);
         }
-        if (params.strategy === "rename-noreplace") {
+        if (strategy === "rename-noreplace") {
             const binding = requireNativeBinding();
             binding.renameNoReplace(sourceNativeParent.handle.fd, sourceNativeParent.basename, targetNativeParent.handle.fd, targetNativeParent.basename);
             rememberCreatedTarget(failure, sourceExactIdentity, "rename-verify");
             // A failed post-rename fence must not delete the only remaining name.
             failure.preserveTarget = true;
             await getFsSafeTestHooks()?.afterPublishTargetCreated?.("rename-noreplace", targetPath, sourceExactIdentity);
-            const targetExactIdentity = await fs.lstat(targetPath, { bigint: true });
-            if (targetExactIdentity.isSymbolicLink() ||
-                !targetExactIdentity.isFile() ||
-                !sameFileIdentity(targetExactIdentity, sourceExactIdentity)) {
-                throw new FsSafeError("path-mismatch", "no-replace publication target changed");
-            }
-            try {
-                await fs.lstat(sourcePath);
-                throw new FsSafeError("path-mismatch", "no-replace publication source still exists");
-            }
-            catch (error) {
-                if (error.code !== "ENOENT") {
-                    throw error;
-                }
-            }
+            assertPublishedTargetCurrent(targetPath, sourceExactIdentity, "no-replace publication target changed");
+            assertRenamedSourceAbsent(sourcePath);
             syncFileBestEffortSync(sourceNativeParent.handle.fd);
-            const targetIdentity = await fs.lstat(targetPath);
-            return {
-                method: "rename-noreplace",
-                identity: targetIdentity,
-                directorySync: await syncPublishedParent({
-                    parent,
-                    failure,
-                    method: "rename-noreplace",
-                    targetPath,
-                }),
-            };
+            return await finishPublication("rename-noreplace", source, sourceExactIdentity);
         }
         try {
             if (native) {
@@ -278,75 +287,31 @@ export async function publishFileExclusive(params) {
             }
             rememberCreatedTarget(failure, sourceExactIdentity, "hardlink-verify");
             await getFsSafeTestHooks()?.afterPublishTargetCreated?.("hardlink", targetPath, sourceExactIdentity);
-            const targetExactIdentity = await fs.lstat(targetPath, { bigint: true });
-            if (targetExactIdentity.isSymbolicLink() ||
-                !targetExactIdentity.isFile() ||
-                !sameFileIdentity(targetExactIdentity, sourceExactIdentity)) {
-                throw new FsSafeError("path-mismatch", "hardlink publication target changed");
-            }
-            await assertPinnedSourceCurrent({ sourcePath, handle: source, identity: sourceExactIdentity });
-            const targetIdentity = await fs.lstat(targetPath);
-            return {
-                method: "hardlink",
-                identity: targetIdentity,
-                directorySync: await syncPublishedParent({
-                    parent,
-                    failure,
-                    method: "hardlink",
-                    targetPath,
-                }),
-            };
+            assertPublishedTargetCurrent(targetPath, sourceExactIdentity, "hardlink publication target changed");
+            assertSourceCurrent();
+            return await finishPublication("hardlink", source, sourceExactIdentity);
         }
         catch (error) {
             if (failure.targetCreated ||
                 !isHardlinkFallbackError(error) ||
-                params.strategy === "link-required") {
+                strategy === "link-required") {
                 throw error;
             }
         }
         failure.phase = "copy-create";
-        let target;
-        let targetIdentity;
-        try {
-            const copied = await copyPinnedSource({
-                source,
-                targetPath,
-                native,
-                targetNativeParent,
-                failure,
-            });
-            target = copied.handle;
-            targetIdentity = await target.stat();
-            const targetPathStat = await fs.lstat(targetPath);
-            const targetPathExactStat = await fs.lstat(targetPath, { bigint: true });
-            const copiedBack = await hashFileHandle(target, native);
-            const sourceAfter = await hashFileHandle(source, native);
-            if (targetPathStat.isSymbolicLink() ||
-                targetPathExactStat.isSymbolicLink() ||
-                !sameFileIdentity(targetPathExactStat, copied.exactIdentity) ||
-                copiedBack.bytes !== copied.bytes ||
-                copiedBack.digest !== copied.digest ||
-                sourceAfter.bytes !== copied.bytes ||
-                sourceAfter.digest !== copied.digest) {
-                throw new FsSafeError("path-mismatch", "exclusive publication copy failed content fencing");
-            }
-            await assertPinnedSourceCurrent({ sourcePath, handle: source, identity: sourceExactIdentity });
-            const directorySync = await syncPublishedParent({
-                parent,
-                failure,
-                method: "exclusive-copy",
-                targetPath,
-            });
-            return { method: "exclusive-copy", identity: targetPathStat, directorySync };
-        }
-        catch (error) {
-            await target?.close().catch(() => undefined);
-            target = undefined;
-            throw error;
-        }
-        finally {
-            await target?.close().catch(() => undefined);
+        const copied = await copyPinnedSource({ source, targetPath, native, targetNativeParent, failure });
+        copiedTarget = copied.handle;
+        const copiedBack = await hashFileHandle(copiedTarget, native);
+        const sourceAfter = await hashFileHandle(source, native);
+        assertPublishedTargetCurrent(targetPath, copied.exactIdentity, "exclusive publication copy failed content fencing");
+        if (copiedBack.bytes !== copied.bytes ||
+            copiedBack.digest !== copied.digest ||
+            sourceAfter.bytes !== copied.bytes ||
+            sourceAfter.digest !== copied.digest) {
+            throw new FsSafeError("path-mismatch", "exclusive publication copy failed content fencing");
         }
+        assertSourceCurrent();
+        return await finishPublication("exclusive-copy", copiedTarget, copied.exactIdentity);
     }
     catch (error) {
         if (!failure.targetCreated)
@@ -358,6 +323,7 @@ export async function publishFileExclusive(params) {
         throw publicationFailure(error, failure, cleanup);
     }
     finally {
+        await copiedTarget?.close().catch(() => undefined);
         await sourceNativeParent?.handle.close().catch(() => undefined);
         await targetNativeParent?.handle.close().catch(() => undefined);
         await source.close().catch(() => undefined);

package/node_modules/@openclaw/fs-safe/dist/read-open-flags.d.ts

@@ -5,4 +5,3 @@ export declare function resolveReadOpenFlags(options?: {
     followSymlinks?: boolean;
 }): number;
 export {};
-//# sourceMappingURL=read-open-flags.d.ts.map

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

@@ -18,4 +18,3 @@ export declare function readOpenedFileSafely(params: {
     maxBytes?: number;
 }): Promise<ReadResult>;
 export {};
-//# sourceMappingURL=read-opened-file.d.ts.map

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

@@ -0,0 +1,3 @@
+export declare const realpathSync: ((input: string) => string) & {
+    native: (input: string) => string;
+};

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

@@ -0,0 +1,43 @@
+import fs from "node:fs";
+import { platform } from "node:os";
+import { getSystemErrorName } from "node:util";
+import { FsSafeError } from "./errors.js";
+import { getNativeBinding } from "./native.js";
+import { getFsSafeNativeConfig } from "./native-config.js";
+const runtimePlatform = process.versions.bun ? platform() : undefined;
+const bunPosix = runtimePlatform === "darwin" || runtimePlatform === "linux" ? runtimePlatform : undefined;
+function resolve(input, native) {
+    if (bunPosix) {
+        // Bun 1.4.2 normalizes native path components and opens the leaf for reads.
+        // The Rust OS resolver preserves permissions, locks and physical spelling.
+        // Reuse our N-API addon so this also works with JIT disabled; Bun's FFI
+        // bridge requires JIT and would duplicate native loading and memory handling.
+        // Remove this routing once the Bun baseline includes oven-sh/bun#42374.
+        if (input.includes("\0")) {
+            throw Object.assign(new TypeError("realpath input must not contain null bytes"), {
+                code: "ERR_INVALID_ARG_VALUE",
+            });
+        }
+        const binding = getNativeBinding();
+        if (binding?.canonicalizePath) {
+            // Ordinary resolution normalizes both the input and each expanded symlink.
+            const result = binding.canonicalizePath(input, !native);
+            if (result.path !== undefined)
+                return result.path;
+            const errno = -(result.errno);
+            const code = getSystemErrorName(errno);
+            throw Object.assign(new Error(`${code}: realpath '${input}'`), {
+                code, errno, syscall: "realpath", path: input,
+            });
+        }
+        if (getFsSafeNativeConfig().mode === "require") {
+            throw new FsSafeError("helper-unavailable", "native fs-safe canonicalization is unavailable");
+        }
+        // The workaround belongs to the same optional addon, so "off" disables it
+        // too. With off or a missing addon in auto, Bun's upstream limits still apply.
+    }
+    return native ? fs.realpathSync.native(input) : fs.realpathSync(input);
+}
+export const realpathSync = Object.assign((input) => resolve(input, false), {
+    native: (input) => resolve(input, true),
+});

package/node_modules/@openclaw/fs-safe/dist/recursive-mkdir-path.d.ts

@@ -0,0 +1,2 @@
+/** Bun's Windows recursive mkdir cannot inspect existing relative dot components. */
+export declare function recursiveMkdirPath(directory: string): string;

package/node_modules/@openclaw/fs-safe/dist/recursive-mkdir-path.js

@@ -0,0 +1,8 @@
+import { platform } from "node:os";
+import { absolutePathWithRawSegments } from "./root-path-existing.js";
+const needsAbsolutePath = Boolean(process.versions.bun) && platform() === "win32";
+/** Bun's Windows recursive mkdir cannot inspect existing relative dot components. */
+export function recursiveMkdirPath(directory) {
+    // Preserve junction/parent traversal; path.resolve would erase those components.
+    return needsAbsolutePath ? absolutePathWithRawSegments(directory) : directory;
+}

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

@@ -35,4 +35,3 @@ export declare function readRegularFileSync(params: {
 export declare function appendRegularFile(options: AppendRegularFileOptions): Promise<void>;
 export declare function appendRegularFileSync(options: AppendRegularFileOptions): void;
 export {};
-//# sourceMappingURL=regular-file.d.ts.map