@openclaw/openshell-sandbox 2026.9.3 → 2026.9.5

package/node_modules/@openclaw/fs-safe/dist/secure-temp-repair.js

@@ -0,0 +1,106 @@
+import fs, {} from "node:fs";
+export function captureSecureTempRepairAdapter(supplied, hasLegacyFsHooks) {
+    if (supplied === undefined && hasLegacyFsHooks)
+        return undefined;
+    if (supplied !== undefined && (supplied === null || (typeof supplied !== "object" && typeof supplied !== "function")))
+        return undefined;
+    const source = supplied === undefined ? fs : supplied;
+    const { lstatSync, fstatSync, openSync, fchmodSync, closeSync, constants } = source;
+    const { O_RDONLY, O_DIRECTORY, O_NOFOLLOW, O_NONBLOCK } = constants ?? {};
+    if ([lstatSync, fstatSync, openSync, fchmodSync, closeSync].some((fn) => typeof fn !== "function") ||
+        O_RDONLY !== 0 || [O_DIRECTORY, O_NOFOLLOW, O_NONBLOCK].some((flag) => !Number.isSafeInteger(flag) || flag <= 0 || flag > 0x7fff_ffff) ||
+        (O_DIRECTORY & O_NOFOLLOW) !== 0 || (O_DIRECTORY & O_NONBLOCK) !== 0 || (O_NOFOLLOW & O_NONBLOCK) !== 0) {
+        return undefined;
+    }
+    return { lstatSync, fstatSync, openSync, fchmodSync, closeSync, flags: O_RDONLY | O_DIRECTORY | O_NOFOLLOW | O_NONBLOCK };
+}
+export function secureTempDirectoryReceipt(stat, uid) {
+    const { dev, ino, uid: owner, mode } = stat;
+    if (typeof dev !== "bigint" || dev < 0n || typeof ino !== "bigint" || ino <= 0n ||
+        typeof owner !== "bigint" || owner !== BigInt(uid) || typeof mode !== "bigint" ||
+        mode < 0n || mode > 0xffffffffn || (mode & 61440n) !== 16384n ||
+        stat.isDirectory() !== true || stat.isSymbolicLink() !== false) {
+        throw new Error("Secure temp directory identity, owner, or type could not be verified.");
+    }
+    return { dev, ino, uid: owner, mode };
+}
+function assertSameDirectory(stat, expected, uid) {
+    const observed = secureTempDirectoryReceipt(stat, uid);
+    if (observed.dev !== expected.dev || observed.ino !== expected.ino || observed.uid !== expected.uid) {
+        throw new Error("Secure temp directory changed during repair.");
+    }
+    return observed;
+}
+function mayHaveConcurrentRepair(error) {
+    if (typeof error !== "object" || error === null || !("code" in error))
+        return false;
+    const code = error.code;
+    return code === "EPERM" || code === "EACCES" || code === "ENOENT";
+}
+/** No pathname chmod, search-only descriptors, procfs, or reopening fallback. */
+export function repairSecureTempDirectory(candidate, expected, uid, adapter, access, repaired, finalize = false) {
+    assertSameDirectory(adapter.lstatSync(candidate, { bigint: true }), expected, uid);
+    const fd = adapter.openSync(candidate, adapter.flags);
+    if (!Number.isSafeInteger(fd) || fd < 0)
+        throw new Error("Secure temp directory descriptor is invalid.");
+    const errors = [];
+    try {
+        const inspect = () => {
+            const opened = assertSameDirectory(adapter.fstatSync(fd, { bigint: true }), expected, uid);
+            const named = assertSameDirectory(adapter.lstatSync(candidate, { bigint: true }), expected, uid);
+            return { opened, named };
+        };
+        const verify = (requireExactMode) => {
+            const check = () => {
+                const { opened, named } = inspect();
+                for (const stat of [opened, named]) {
+                    if ((stat.mode & 18n) !== 0n || (requireExactMode && (stat.mode & 4095n) !== 448n)) {
+                        throw new Error("Secure temp directory permissions remain unsafe.");
+                    }
+                }
+            };
+            check();
+            access();
+            check();
+        };
+        const { opened } = inspect();
+        const needsChmod = finalize ? (opened.mode & 4095n) !== 448n :
+            (opened.mode & 18n) !== 0n || (opened.mode & 448n) !== 448n;
+        let chmodError;
+        let chmodFailed = false;
+        if (needsChmod) {
+            try {
+                adapter.fchmodSync(fd, 0o700);
+            }
+            catch (error) {
+                if (!mayHaveConcurrentRepair(error))
+                    throw error;
+                chmodFailed = true;
+                chmodError = error;
+            }
+            if (!chmodFailed)
+                repaired();
+        }
+        try {
+            verify(finalize || (needsChmod && !chmodFailed));
+        }
+        catch (error) {
+            if (chmodFailed)
+                throw new AggregateError([chmodError, error], "Secure temp directory chmod and verification failed.");
+            throw error;
+        }
+    }
+    catch (error) {
+        errors.push(error);
+    }
+    try {
+        adapter.closeSync(fd);
+    }
+    catch (error) {
+        errors.push(error);
+    }
+    if (errors.length > 1)
+        throw new AggregateError(errors, "Secure temp directory repair and close failed.");
+    if (errors.length === 1)
+        throw errors[0];
+}

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

@@ -1,6 +1,9 @@
+export declare function resolveCallbackTempPath(workspaceDir: string, component: string): string;
 export declare function writeCallbackSibling<T>(params: {
-    tempPath: string;
+    tempDir: string;
+    tempName: string;
     write: (tempPath: string) => Promise<T>;
+    producerIsolation?: "private-directory";
     resolveFinalPath: (result: T) => string;
     mode?: number;
     /** Preserve the caller's historical best-effort mode behavior. */

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

@@ -1 +1 @@
-{"version":3,"file":"sibling-staged-file.d.ts","sourceRoot":"","sources":["../src/sibling-staged-file.ts"],"names":[],"mappings":"AAmCA,wBAAsB,oBAAoB,CAAC,CAAC,EAAE,MAAM,EAAE;IACpD,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;IACxC,gBAAgB,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,MAAM,CAAC;IACxC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kEAAkE;IAClE,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;IACtB,aAAa,EAAE,OAAO,CAAC;CACxB,GAAG,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,CAAC,CAAA;CAAE,CAAC,CAyG3C"}
+{"version":3,"file":"sibling-staged-file.d.ts","sourceRoot":"","sources":["../src/sibling-staged-file.ts"],"names":[],"mappings":"AAsCA,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAoBvF;AAsHD,wBAAsB,oBAAoB,CAAC,CAAC,EAAE,MAAM,EAAE;IACpD,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;IACxC,iBAAiB,CAAC,EAAE,mBAAmB,CAAC;IACxC,gBAAgB,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,MAAM,CAAC;IACxC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kEAAkE;IAClE,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;IACtB,aAAa,EAAE,OAAO,CAAC;CACxB,GAAG,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,CAAC,CAAA;CAAE,CAAC,CAsK3C"}

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

@@ -2,13 +2,45 @@ import { syncFileBestEffort } from "./file-sync.js";
 import fsSync, {} from "node:fs";
 import fs, {} from "node:fs/promises";
 import path from "node:path";
-import { assertAsyncDirectoryGuard, createAsyncDirectoryGuard } from "./directory-guard.js";
+import { assertAsyncDirectoryGuard, assertDirectoryIdentitySync, createAsyncDirectoryGuard, } from "./directory-guard.js";
 import { syncDirectoryBestEffort } from "./directory-durability.js";
+import { isWindowsReservedDeviceName } from "./device-path.js";
 import { FsSafeError } from "./errors.js";
+import { getNativeBinding } from "./native.js";
+import { handoffPrivateProducerFile, } from "./private-producer-handoff.js";
 import { resolveReadOpenFlags } from "./read-open-flags.js";
+import { rootFromDirectoryGuard } from "./root-impl.js";
 import { inspectFileIdentity } from "./strict-file-identity.js";
 import { registerTempPathForExit } from "./temp-cleanup.js";
+import { createOwnedTempFile } from "./temp-target.js";
 import { serializePathWrite } from "./write-queue.js";
+import { assertNoWindowsPathAlias, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
+const INVALID_CALLBACK_COMPONENT_CHARACTERS = /[\u0000-\u001f\u007f-\u009f<>:"/\\|?*]/u;
+function resolveCallbackTempDirectory(workspaceDir) {
+    assertNoWindowsPathAlias(workspaceDir, "filesystem", "sibling temp parent uses a Windows filesystem namespace alias");
+    const dir = resolvePathPreservingWindowsRoot(workspaceDir);
+    assertNoWindowsPathAlias(dir, "filesystem", "sibling temp parent uses a Windows filesystem namespace alias");
+    return dir;
+}
+export function resolveCallbackTempPath(workspaceDir, component) {
+    const dir = resolveCallbackTempDirectory(workspaceDir);
+    if (typeof component !== "string" ||
+        component === "" ||
+        component === "." ||
+        component === ".." ||
+        INVALID_CALLBACK_COMPONENT_CHARACTERS.test(component) ||
+        component.endsWith(".") ||
+        component.endsWith(" ") ||
+        isWindowsReservedDeviceName(component)) {
+        throw new FsSafeError("invalid-path", "callback temp name must be one path component");
+    }
+    const joined = path.join(dir, component);
+    assertNoWindowsPathAlias(joined, "filesystem", "sibling temp path uses a Windows filesystem namespace alias");
+    if (path.dirname(joined) !== dir) {
+        throw new FsSafeError("invalid-path", "callback temp path must be a direct workspace child");
+    }
+    return joined;
+}
 function assertRegularFile(stat) {
     if (stat.isSymbolicLink()) {
         throw new FsSafeError("symlink", "symlink sibling temp not allowed");
@@ -22,86 +54,206 @@ function assertRegularFile(stat) {
 }
 async function inspectStage(inspect, expected) {
     return await inspectFileIdentity(async () => {
-        const stat = await inspect();
+        const stat = inspect();
         assertRegularFile(stat);
         return stat;
     }, expected);
 }
+function aggregateErrors(errors, message) {
+    if (errors.length === 1)
+        return errors[0];
+    return new AggregateError(errors, message);
+}
+// Own the workspace before the producer can leave partial output. The finished
+// file still enters the ordinary sibling admission and publication lifecycle.
+async function writeIsolatedProducer(params) {
+    const tempPath = params.tempPath;
+    const write = params.write;
+    const writeReceiver = params.writeReceiver;
+    const parentGuard = params.parentGuard;
+    const assertParent = params.assertParent;
+    const syncTempFile = params.syncTempFile;
+    assertParent();
+    const targetRoot = rootFromDirectoryGuard(parentGuard);
+    // Select the handoff before invoking the producer. Missing required native
+    // support must not leave producer output behind as a discovery side effect.
+    const native = getNativeBinding();
+    const cleanupErrors = [];
+    const { target, identity } = await createOwnedTempFile({
+        rootDir: targetRoot.rootReal,
+        prefix: "fs-safe-output",
+        fileName: path.basename(tempPath),
+        onCleanupError: (error) => cleanupErrors.push(error),
+    });
+    let cleanupStarted = false;
+    const cleanupWorkspace = async () => {
+        if (cleanupStarted)
+            return;
+        cleanupStarted = true;
+        try {
+            await target.cleanup();
+        }
+        catch (error) {
+            cleanupErrors.push(error);
+        }
+        if (cleanupErrors.length > 0) {
+            throw aggregateErrors(cleanupErrors, "isolated producer workspace cleanup failed");
+        }
+    };
+    const assertWorkspace = () => {
+        assertDirectoryIdentitySync(target.dir, { ...identity, realPath: target.dir });
+    };
+    const assertCurrent = () => {
+        assertParent();
+        assertWorkspace();
+    };
+    try {
+        const producerPath = resolveCallbackTempPath(target.dir, path.basename(target.path));
+        assertCurrent();
+        const result = await Reflect.apply(write, writeReceiver, [producerPath]);
+        assertCurrent();
+        if (native) {
+            await targetRoot.move(path.relative(targetRoot.rootReal, producerPath), path.basename(tempPath), { assertBeforeMutation: assertCurrent });
+            return { cleanupWorkspace, result };
+        }
+        const handoff = await handoffPrivateProducerFile({
+            sourcePath: producerPath,
+            targetPath: tempPath,
+            assertSourceParent: assertWorkspace,
+            assertTargetParent: assertParent,
+            readWrite: syncTempFile,
+        });
+        return { cleanupWorkspace, handoff, result };
+    }
+    catch (error) {
+        try {
+            await cleanupWorkspace();
+        }
+        catch (cleanupError) {
+            throw new AggregateError([error, cleanupError], "isolated producer operation and workspace cleanup failed");
+        }
+        throw error;
+    }
+}
 // Callback paths are not owned until all three admission observations agree.
 // Keep one descriptor and one exact identity through mode, sync, rename and cleanup.
 // Read/write access is needed only when the caller requests file synchronization.
 export async function writeCallbackSibling(params) {
-    const parent = path.dirname(params.tempPath);
-    const guard = await createAsyncDirectoryGuard(parent);
-    const parentIdentity = await inspectFileIdentity(() => fs.lstat(parent, { bigint: true }));
-    const assertParent = async () => {
-        await assertAsyncDirectoryGuard(guard);
-        await inspectFileIdentity(() => fs.lstat(parent, { bigint: true }), parentIdentity);
-    };
+    const parent = resolveCallbackTempDirectory(params.tempDir);
+    const tempPath = resolveCallbackTempPath(parent, params.tempName);
+    const write = params.write;
+    const producerIsolation = params.producerIsolation;
+    const resolveFinalPath = params.resolveFinalPath;
+    const mode = params.mode;
+    const ignoreModeError = params.ignoreModeError;
+    const maxBytes = params.maxBytes;
+    const syncTempFile = params.syncTempFile;
+    const syncParentDir = params.syncParentDir;
+    const guard = await createAsyncDirectoryGuard(parent, { bigint: true });
+    const assertParent = () => assertAsyncDirectoryGuard(guard);
     let handle;
     let identity;
     let unregister;
+    let cleanupWorkspace;
     let renamed = false;
     let failure;
-    const inspectPath = (pathname, expected) => inspectStage(() => fs.lstat(pathname, { bigint: true }), expected);
+    const inspectPath = (pathname, expected) => inspectStage(() => fsSync.lstatSync(pathname, { bigint: true }), expected);
     const assertCurrent = async (pathname) => {
         await assertParent();
-        const opened = await inspectStage(() => handle.stat({ bigint: true }), identity);
+        const opened = await inspectStage(() => fsSync.fstatSync(handle.fd, { bigint: true }), identity);
         const current = await inspectPath(pathname, opened);
-        if (params.maxBytes !== undefined &&
-            (opened.size > params.maxBytes || current.size > params.maxBytes)) {
-            throw new FsSafeError("too-large", `sibling temp exceeds maxBytes (${params.maxBytes})`);
+        if (maxBytes !== undefined &&
+            (opened.size > maxBytes || current.size > maxBytes)) {
+            throw new FsSafeError("too-large", `sibling temp exceeds maxBytes (${maxBytes})`);
         }
     };
     try {
-        const result = await params.write(params.tempPath);
+        let result;
+        if (producerIsolation === "private-directory") {
+            const isolated = await writeIsolatedProducer({
+                tempPath: tempPath,
+                write,
+                writeReceiver: params,
+                parentGuard: guard,
+                syncTempFile: syncTempFile,
+                assertParent: () => assertDirectoryIdentitySync(parent, {
+                    dev: guard.stat.dev,
+                    ino: guard.stat.ino,
+                    realPath: guard.realPath,
+                }),
+            });
+            result = isolated.result;
+            cleanupWorkspace = isolated.cleanupWorkspace;
+            if (isolated.handoff) {
+                handle = isolated.handoff.handle;
+                identity = isolated.handoff.identity;
+                unregister = isolated.handoff.unregister;
+            }
+        }
+        else {
+            result = await Reflect.apply(write, params, [tempPath]);
+        }
         await assertParent();
-        const before = await inspectPath(params.tempPath);
-        try {
-            // No create/truncate flags; O_NONBLOCK also bounds a FIFO swap during open.
-            const access = params.syncTempFile ? fsSync.constants.O_RDWR : fsSync.constants.O_RDONLY;
-            handle = await fs.open(params.tempPath, access | resolveReadOpenFlags());
+        if (handle) {
+            const opened = await inspectStage(() => fsSync.fstatSync(handle.fd, { bigint: true }), identity);
+            await inspectPath(tempPath, opened);
         }
-        catch (error) {
-            if (error?.code === "ELOOP") {
-                throw new FsSafeError("symlink", "symlink sibling temp not allowed", { cause: error });
+        else {
+            const before = await inspectPath(tempPath);
+            try {
+                // No create/truncate flags; O_NONBLOCK also bounds a FIFO swap during open.
+                const access = syncTempFile ? fsSync.constants.O_RDWR : fsSync.constants.O_RDONLY;
+                handle = await fs.open(tempPath, access | resolveReadOpenFlags());
+            }
+            catch (error) {
+                if (error?.code === "ELOOP") {
+                    throw new FsSafeError("symlink", "symlink sibling temp not allowed", { cause: error });
+                }
+                throw error;
             }
-            throw error;
+            const opened = await inspectStage(() => fsSync.fstatSync(handle.fd, { bigint: true }), before);
+            await inspectPath(tempPath, opened);
+            identity = opened;
+            unregister = registerTempPathForExit(tempPath, { identity, singleLinkFile: true });
         }
-        const opened = await inspectStage(() => handle.stat({ bigint: true }), before);
-        await inspectPath(params.tempPath, opened);
         await assertParent();
-        identity = opened;
-        unregister = registerTempPathForExit(params.tempPath, { identity, singleLinkFile: true });
-        const filePath = path.resolve(params.resolveFinalPath(result));
+        if (cleanupWorkspace) {
+            const cleanup = cleanupWorkspace;
+            cleanupWorkspace = undefined;
+            await cleanup();
+        }
+        const rawFilePath = Reflect.apply(resolveFinalPath, params, [result]);
+        assertNoWindowsPathAlias(rawFilePath, "filesystem", "final path uses a Windows filesystem namespace alias");
+        const filePath = path.resolve(rawFilePath);
+        assertNoWindowsPathAlias(filePath, "filesystem", "final path uses a Windows filesystem namespace alias");
         if (path.dirname(filePath) !== parent) {
             throw new Error("Final path must be in the sibling temp directory.");
         }
-        if (filePath === params.tempPath) {
+        if (filePath === tempPath) {
             throw new FsSafeError("invalid-path", "final path must differ from the sibling temp path");
         }
         await serializePathWrite(filePath, async () => {
-            await assertCurrent(params.tempPath);
-            if (params.mode !== undefined) {
+            await assertCurrent(tempPath);
+            if (mode !== undefined) {
                 try {
-                    await handle.chmod(params.mode);
+                    await handle.chmod(mode);
                 }
                 catch (error) {
-                    if (!params.ignoreModeError)
+                    if (!ignoreModeError)
                         throw error;
                 }
             }
-            if (params.syncTempFile) {
-                await assertCurrent(params.tempPath);
+            if (syncTempFile) {
+                await assertCurrent(tempPath);
                 await syncFileBestEffort(handle);
             }
-            await assertCurrent(params.tempPath);
-            await fs.rename(params.tempPath, filePath);
+            await assertCurrent(tempPath);
+            await fs.rename(tempPath, filePath);
             // A later verification failure never authorizes rollback of the final name.
             renamed = true;
             unregister();
             await assertCurrent(filePath);
-            if (params.syncParentDir)
+            if (syncParentDir)
                 await syncDirectoryBestEffort(parent);
             await assertCurrent(filePath);
         });
@@ -112,13 +264,22 @@ export async function writeCallbackSibling(params) {
         throw error;
     }
     finally {
+        const settlementErrors = [];
+        if (cleanupWorkspace) {
+            try {
+                await cleanupWorkspace();
+            }
+            catch (error) {
+                settlementErrors.push(error);
+            }
+        }
         try {
             if (!renamed && identity) {
                 try {
                     await assertParent();
-                    await inspectStage(() => handle.stat({ bigint: true }), identity);
-                    await inspectPath(params.tempPath, identity);
-                    await fs.unlink(params.tempPath);
+                    await inspectStage(() => fsSync.fstatSync(handle.fd, { bigint: true }), identity);
+                    await inspectPath(tempPath, identity);
+                    await fs.unlink(tempPath);
                     unregister?.();
                 }
                 catch (error) {
@@ -134,9 +295,13 @@ export async function writeCallbackSibling(params) {
                 await handle?.close();
             }
             catch (error) {
-                if (failure)
-                    throw new AggregateError([failure.error, error], "sibling publication and close failed");
-                throw error;
+                settlementErrors.push(error);
+            }
+            if (settlementErrors.length > 0) {
+                if (failure) {
+                    throw new AggregateError([failure.error, ...settlementErrors], "sibling publication and settlement failed");
+                }
+                throw aggregateErrors(settlementErrors, "sibling publication settlement failed");
             }
         }
     }

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

@@ -1,6 +1,8 @@
 export type WriteSiblingTempFileOptions<T> = {
     dir: string;
     writeTemp: (tempPath: string) => Promise<T>;
+    /** Own a private sibling workspace before invoking the producer. */
+    producerIsolation?: "private-directory";
     resolveFinalPath: (result: T) => string;
     tempPrefix?: string;
     dirMode?: number;

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

@@ -1 +1 @@
-{"version":3,"file":"sibling-temp.d.ts","sourceRoot":"","sources":["../src/sibling-temp.ts"],"names":[],"mappings":"AAaA,MAAM,MAAM,2BAA2B,CAAC,CAAC,IAAI;IAC3C,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;IAC5C,gBAAgB,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,MAAM,CAAC;IACxC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,uGAAuG;IACvG,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,mEAAmE;IACnE,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,yEAAyE;IACzE,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,0BAA0B,CAAC,CAAC,IAAI;IAC1C,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,CAAC,CAAC;CACX,CAAC;AASF,wBAAsB,oBAAoB,CAAC,CAAC,EAC1C,OAAO,EAAE,2BAA2B,CAAC,CAAC,CAAC,GACtC,OAAO,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC,CAoBxC;AAwBD,wBAAsB,uBAAuB,CAAC,MAAM,EAAE;IACpD,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GAAG,OAAO,CAAC,IAAI,CAAC,CA0ChB"}
+{"version":3,"file":"sibling-temp.d.ts","sourceRoot":"","sources":["../src/sibling-temp.ts"],"names":[],"mappings":"AAmBA,MAAM,MAAM,2BAA2B,CAAC,CAAC,IAAI;IAC3C,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;IAC5C,oEAAoE;IACpE,iBAAiB,CAAC,EAAE,mBAAmB,CAAC;IACxC,gBAAgB,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,MAAM,CAAC;IACxC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,uGAAuG;IACvG,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,mEAAmE;IACnE,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,yEAAyE;IACzE,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,0BAA0B,CAAC,CAAC,IAAI;IAC1C,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,CAAC,CAAC;CACX,CAAC;AASF,wBAAsB,oBAAoB,CAAC,CAAC,EAC1C,OAAO,EAAE,2BAA2B,CAAC,CAAC,CAAC,GACtC,OAAO,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC,CA0BxC;AAwBD,wBAAsB,uBAAuB,CAAC,MAAM,EAAE;IACpD,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GAAG,OAAO,CAAC,IAAI,CAAC,CAsDhB"}

package/node_modules/@openclaw/fs-safe/dist/sibling-temp.js

@@ -4,21 +4,28 @@ import path from "node:path";
 import { assertAsyncDirectoryGuard, createAsyncDirectoryGuard } from "./directory-guard.js";
 import { fitFileNameToPortableComponent, sanitizeUntrustedFileName } from "./filename.js";
 import { applyDirectoryMode } from "./replace-file-descriptor.js";
+import { realpathSync } from "./realpath.js";
+import { recursiveMkdirPath } from "./recursive-mkdir-path.js";
 import { root } from "./root.js";
 import { assertSafePathPrefix } from "./safe-path-segment.js";
 import { resolveSecureTempRoot } from "./secure-temp-dir.js";
-import { writeCallbackSibling } from "./sibling-staged-file.js";
+import { resolveCallbackTempPath, writeCallbackSibling } from "./sibling-staged-file.js";
 import { tempFile } from "./temp-target.js";
 import { getFsSafeTestHooks } from "./test-hooks.js";
-function buildTempPath(dir, tempPrefix) {
+import { assertNoWindowsPathAlias, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
+function buildTempName(tempPrefix) {
     const safePrefix = assertSafePathPrefix(tempPrefix ?? ".fs-safe-stream", {
         label: "sibling temp prefix",
     });
-    return path.join(dir, `${safePrefix}.${process.pid}.${randomUUID()}.tmp`);
+    return `${safePrefix}.${process.pid}.${randomUUID()}.tmp`;
 }
 export async function writeSiblingTempFile(options) {
-    const dir = path.resolve(options.dir);
-    await fs.mkdir(dir, { recursive: true, mode: options.dirMode ?? 0o700 });
+    const dirInput = options.dir;
+    assertNoWindowsPathAlias(dirInput, "filesystem", "sibling temp directory uses a Windows filesystem namespace alias");
+    const dir = resolvePathPreservingWindowsRoot(dirInput);
+    assertNoWindowsPathAlias(dir, "filesystem", "sibling temp directory uses a Windows filesystem namespace alias");
+    const producerIsolation = options.producerIsolation;
+    await fs.mkdir(recursiveMkdirPath(dir), { recursive: true, mode: options.dirMode ?? 0o700 });
     if (options.chmodDir !== false) {
         await applyDirectoryMode({
             fsModule: fs,
@@ -28,8 +35,10 @@ export async function writeSiblingTempFile(options) {
         });
     }
     return await writeCallbackSibling({
-        tempPath: buildTempPath(dir, options.tempPrefix),
+        tempDir: dir,
+        tempName: buildTempName(options.tempPrefix),
         write: options.writeTemp,
+        producerIsolation,
         resolveFinalPath: options.resolveFinalPath,
         mode: options.mode,
         ignoreModeError: true,
@@ -37,7 +46,7 @@ export async function writeSiblingTempFile(options) {
         syncParentDir: options.syncParentDir === true,
     });
 }
-function buildSiblingTempPath(params) {
+function buildSiblingTempName(params) {
     const id = crypto.randomUUID();
     const safePrefix = assertSafePathPrefix(params.tempPrefix, {
         label: "sibling temp prefix",
@@ -49,17 +58,32 @@ function buildSiblingTempPath(params) {
         fileName: sanitizeUntrustedFileName(path.basename(params.targetPath), params.fallbackFileName),
         suffix,
     });
-    return path.join(path.dirname(params.targetPath), `${prefix}${safeTail}${suffix}`);
+    return `${prefix}${safeTail}${suffix}`;
 }
 export async function writeViaSiblingTempPath(params) {
-    const rootDir = await fs
-        .realpath(path.resolve(params.rootDir))
-        .catch(() => path.resolve(params.rootDir));
-    const requestedTargetPath = path.resolve(params.targetPath);
-    const targetPath = await fs
-        .realpath(path.dirname(requestedTargetPath))
-        .then((realDir) => path.join(realDir, path.basename(requestedTargetPath)))
-        .catch(() => requestedTargetPath);
+    const rootDirInput = params.rootDir;
+    const targetPathInput = params.targetPath;
+    assertNoWindowsPathAlias(rootDirInput, "filesystem", "sibling temp root uses a Windows filesystem namespace alias");
+    assertNoWindowsPathAlias(targetPathInput, "filesystem", "sibling temp target uses a Windows filesystem namespace alias");
+    let rootDir;
+    try {
+        rootDir = realpathSync.native(resolvePathPreservingWindowsRoot(rootDirInput));
+    }
+    catch {
+        rootDir = resolvePathPreservingWindowsRoot(rootDirInput);
+    }
+    assertNoWindowsPathAlias(rootDir, "filesystem", "sibling temp root uses a Windows filesystem namespace alias");
+    const requestedTargetPath = path.resolve(targetPathInput);
+    assertNoWindowsPathAlias(requestedTargetPath, "filesystem", "sibling temp target uses a Windows filesystem namespace alias");
+    let targetPath;
+    try {
+        const realDir = realpathSync.native(path.dirname(requestedTargetPath));
+        targetPath = path.join(realDir, path.basename(requestedTargetPath));
+    }
+    catch {
+        targetPath = requestedTargetPath;
+    }
+    assertNoWindowsPathAlias(targetPath, "filesystem", "sibling temp target uses a Windows filesystem namespace alias");
     const relativeTargetPath = path.relative(rootDir, targetPath);
     if (!relativeTargetPath ||
         relativeTargetPath === ".." ||
@@ -76,12 +100,14 @@ export async function writeViaSiblingTempPath(params) {
         }),
         prefix: "fs-safe-output",
     });
+    assertNoWindowsPathAlias(workspace.dir, "filesystem", "sibling temp workspace uses a Windows filesystem namespace alias");
     try {
-        const tempPath = buildSiblingTempPath({
+        const tempName = buildSiblingTempName({
             targetPath: path.join(workspace.dir, path.basename(targetPath)),
             fallbackFileName: params.fallbackFileName ?? "output.bin",
             tempPrefix: params.tempPrefix ?? ".fs-safe-output-",
         });
+        const tempPath = resolveCallbackTempPath(workspace.dir, tempName);
         await getFsSafeTestHooks()?.beforeSiblingTempWrite?.(tempPath);
         await params.writeTemp(tempPath);
         await assertAsyncDirectoryGuard(rootGuard);

package/node_modules/@openclaw/fs-safe/dist/sidecar-lock-acquire.d.ts

@@ -2,7 +2,7 @@ import { type NativeFileHandle } from "./native-operations.js";
 import type { Root } from "./root-impl.js";
 import { type SidecarLockSnapshot } from "./sidecar-lock-reclaim.js";
 import type { SidecarLockAcquireOptions, SidecarLockHandle } from "./sidecar-lock-types.js";
-type SidecarFileHandle = Pick<NativeFileHandle, "close" | "stat" | "writeFile">;
+type SidecarFileHandle = Pick<NativeFileHandle, "fd" | "close" | "stat" | "writeFile">;
 export type HeldSidecarLock = {
     refCount: number;
     reentrantOwner?: string;

package/node_modules/@openclaw/fs-safe/dist/sidecar-lock-acquire.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sidecar-lock-acquire.d.ts","sourceRoot":"","sources":["../src/sidecar-lock-acquire.ts"],"names":[],"mappings":"AAOA,OAAO,EAA6B,KAAK,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1F,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAS3C,OAAO,EAWL,KAAK,mBAAmB,EACzB,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,yBAAyB,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAG5F,KAAK,iBAAiB,GAAG,IAAI,CAAC,gBAAgB,EAAE,OAAO,GAAG,MAAM,GAAG,WAAW,CAAC,CAAC;AAEhF,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,cAAc,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,QAAQ,CAAC,EAAE,IAAI,CAAC;IAChB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;IACxC,eAAe,CAAC,EAAE,MAAM,CAAC,OAAO,CAAC;CAClC,CAAC;AAEF,KAAK,6BAA6B,GAAG;IACnC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACnC,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC3B,2BAA2B,IAAI,IAAI,CAAC;IACpC,iBAAiB,CAAC,oBAAoB,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,GAAG,iBAAiB,CAAC;IAC1F,eAAe,CACb,oBAAoB,EAAE,MAAM,EAC5B,IAAI,EAAE,eAAe,EACrB,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,GAC5B,OAAO,CAAC,OAAO,CAAC,CAAC;CACrB,CAAC;AAqBF,wBAAsB,kBAAkB,CAAC,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/E,OAAO,EAAE,yBAAyB,CAAC,QAAQ,CAAC,EAC5C,OAAO,EAAE,6BAA6B,GACrC,OAAO,CAAC,iBAAiB,CAAC,CAqT5B"}
+{"version":3,"file":"sidecar-lock-acquire.d.ts","sourceRoot":"","sources":["../src/sidecar-lock-acquire.ts"],"names":[],"mappings":"AAUA,OAAO,EAA6B,KAAK,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1F,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAW3C,OAAO,EAWL,KAAK,mBAAmB,EACzB,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,yBAAyB,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAK5F,KAAK,iBAAiB,GAAG,IAAI,CAAC,gBAAgB,EAAE,IAAI,GAAG,OAAO,GAAG,MAAM,GAAG,WAAW,CAAC,CAAC;AAEvF,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,cAAc,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,QAAQ,CAAC,EAAE,IAAI,CAAC;IAChB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;IACxC,eAAe,CAAC,EAAE,MAAM,CAAC,OAAO,CAAC;CAClC,CAAC;AAEF,KAAK,6BAA6B,GAAG;IACnC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACnC,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC3B,2BAA2B,IAAI,IAAI,CAAC;IACpC,iBAAiB,CAAC,oBAAoB,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,GAAG,iBAAiB,CAAC;IAC1F,eAAe,CACb,oBAAoB,EAAE,MAAM,EAC5B,IAAI,EAAE,eAAe,EACrB,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,GAC5B,OAAO,CAAC,OAAO,CAAC,CAAC;CACrB,CAAC;AAoCF,wBAAsB,kBAAkB,CAAC,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/E,OAAO,EAAE,yBAAyB,CAAC,QAAQ,CAAC,EAC5C,OAAO,EAAE,6BAA6B,GACrC,OAAO,CAAC,iBAAiB,CAAC,CA2U5B"}