@openclaw/openshell-sandbox 2026.9.4 → 2026.9.5

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

@@ -2,9 +2,13 @@ import fs from "node:fs";
 import path from "node:path";
 import { FsSafeError } from "./errors.js";
 import { readSidecarLockSnapshotSync, readSidecarLockRawSnapshotSync, parseSidecarLockSnapshot, relativeSidecarLockPath, removeSidecarLockIfUnchangedSync, serializeSidecarLockPayload, sidecarLockSnapshotMatches, } from "./sidecar-lock-reclaim.js";
-import { computeSidecarLockDelayMs, isTransientLockFileDenial, maxTransientLockDenials, sidecarLockPayloadCreatedAtMs, validateSidecarLockRetryOptions, validateSidecarLockTimeoutMs, } from "./sidecar-lock-policy.js";
+import { computeSidecarLockDelayMs, isTransientLockFileDenial, maxTransientLockDenials, sidecarLockPayloadCreatedAtMs, validateSidecarLockStaleMs, validateSidecarLockCompromiseCheckIntervalMs, validateSidecarLockRetryOptions, validateSidecarLockTimeoutMs, } from "./sidecar-lock-policy.js";
 import { getFsSafeLockConfig } from "./lock-config.js";
 import { sleepSync } from "./timing.js";
+import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
+import { realpathSync } from "./realpath.js";
+import { recursiveMkdirPath } from "./recursive-mkdir-path.js";
+import { createSuppressedError } from "./suppressed-error.js";
 const SYNC_HELD_LOCKS_KEY = Symbol.for("fsSafe.syncSidecarLocks");
 const SYNC_CLEANUP_REGISTERED_KEY = Symbol.for("fsSafe.syncSidecarLockCleanupRegistered");
 const SYNC_CLEANUP_HANDLER_KEY = Symbol.for("fsSafe.syncSidecarLockCleanupHandler");
@@ -91,30 +95,40 @@ function createSyncHeldLockHandle(held) {
 }
 function canonicalLockParentSync(parent) {
     // Match Root's async realpath, including Windows short-name expansion.
-    return process.platform === "win32" ? fs.realpathSync.native(parent) : fs.realpathSync(parent);
+    return process.platform === "win32" ? realpathSync.native(parent) : realpathSync(parent);
 }
 function normalizeTargetPath(targetPath) {
     const resolved = path.resolve(targetPath);
-    fs.mkdirSync(path.dirname(resolved), { recursive: true });
+    assertNoWindowsPathAlias(resolved);
+    fs.mkdirSync(recursiveMkdirPath(path.dirname(resolved)), { recursive: true });
+    let parent;
     try {
-        return path.join(canonicalLockParentSync(path.dirname(resolved)), path.basename(resolved));
+        parent = canonicalLockParentSync(path.dirname(resolved));
     }
     catch {
         return resolved;
     }
+    assertNoWindowsPathAlias(parent);
+    const normalized = path.join(parent, path.basename(resolved));
+    assertNoWindowsPathAlias(normalized);
+    return normalized;
 }
 function boundedLockPath(lockPath, lockRoot) {
     const resolved = path.resolve(lockPath);
+    assertNoWindowsPathAlias(resolved);
     if (!lockRoot)
         return resolved;
     relativeSidecarLockPath(lockRoot, resolved);
     const parent = path.dirname(resolved);
     const parentReal = canonicalLockParentSync(parent);
+    assertNoWindowsPathAlias(parentReal);
     const parentRelative = path.relative(lockRoot.rootReal, parentReal);
     if (parentRelative === ".." || parentRelative.startsWith(`..${path.sep}`) || path.isAbsolute(parentRelative)) {
         throw new FsSafeError("outside-workspace", "sidecar lock parent is outside lockRoot");
     }
-    return path.join(parentReal, path.basename(resolved));
+    const bounded = path.join(parentReal, path.basename(resolved));
+    assertNoWindowsPathAlias(bounded);
+    return bounded;
 }
 function defaultShouldReclaim(snapshot, staleMs, nowMs) {
     const createdAtMs = sidecarLockPayloadCreatedAtMs(snapshot.payload);
@@ -140,8 +154,15 @@ export function acquireFileLockSync(targetPath, options) {
     const timeoutMs = options.timeoutMs ?? defaults.timeoutMs;
     validateSidecarLockRetryOptions(retry);
     validateSidecarLockTimeoutMs(timeoutMs);
+    const staleMs = options.staleMs ?? defaults.staleMs ?? 30_000;
+    validateSidecarLockStaleMs(staleMs);
+    validateSidecarLockCompromiseCheckIntervalMs(options.compromiseCheckIntervalMs);
+    const explicitLockPath = options.lockPath;
+    assertNoWindowsPathAlias(targetPath);
+    if (explicitLockPath !== undefined)
+        assertNoWindowsPathAlias(explicitLockPath);
     const normalizedTargetPath = normalizeTargetPath(targetPath);
-    const lockPath = boundedLockPath(options.lockPath ?? `${normalizedTargetPath}.lock`, options.lockRoot);
+    const lockPath = boundedLockPath(explicitLockPath ?? `${normalizedTargetPath}.lock`, options.lockRoot);
     const heldLocks = getSyncHeldLocks();
     const held = heldLocks.get(normalizedTargetPath);
     if (held &&
@@ -153,7 +174,6 @@ export function acquireFileLockSync(targetPath, options) {
     }
     // Process defaults fill the same fields here as withLockDefaults() fills for
     // the asynchronous manager, so both acquirers honor configureFsSafeLocks().
-    const staleMs = options.staleMs ?? defaults.staleMs ?? 30_000;
     const staleRecovery = options.staleRecovery ?? defaults.staleRecovery;
     const startedAt = Date.now();
     let attempt = 0;
@@ -252,10 +272,24 @@ export function acquireFileLockSync(targetPath, options) {
         }
         catch (error) {
             if (fd !== undefined) {
-                const failed = { payload: null, stat: fs.fstatSync(fd) };
-                fs.closeSync(fd);
+                const failed = { payload: null };
+                try {
+                    failed.stat = fs.fstatSync(fd);
+                }
+                catch {
+                    // Missing identity leaves the sidecar in place, but must not skip close.
+                }
+                const failedFd = fd;
+                // A close error may still free the number; consume ownership before closing.
                 fd = undefined;
-                removeSidecarLockIfUnchangedSync(lockPath, failed);
+                try {
+                    fs.closeSync(failedFd);
+                    if (failed.stat)
+                        removeSidecarLockIfUnchangedSync(lockPath, failed);
+                }
+                catch (cleanupError) {
+                    throw createSuppressedError(error, cleanupError, "file lock acquisition and cleanup both failed");
+                }
             }
             if (lockFileCreateDenied && retryLockFileDenial(error))
                 continue;

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

@@ -1 +1 @@
-{"version":3,"file":"file-lock.d.ts","sourceRoot":"","sources":["../src/file-lock.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,yBAAyB,EAC9B,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EACzB,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,EAC9B,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EAChB,KAAK,0BAA0B,EAC/B,KAAK,kBAAkB,GACxB,MAAM,qBAAqB,CAAC;AAE7B,MAAM,MAAM,oBAAoB,GAAG,uBAAuB,CAAC;AAC3D,MAAM,MAAM,qBAAqB,GAAG,wBAAwB,CAAC;AAE7D,MAAM,MAAM,sBAAsB,CAAC,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,IAAI,CACjF,yBAAyB,CAAC,QAAQ,CAAC,EACnC,YAAY,GAAG,SAAS,CACzB,GAAG;IACF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,iBAAiB,CAAC;AAC/C,MAAM,MAAM,iBAAiB,GAAG,oBAAoB,CAAC;AACrD,YAAY,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AAEpE,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,CAAC,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9C,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,sBAAsB,CAAC,QAAQ,CAAC,GACxC,OAAO,CAAC,cAAc,CAAC,CAAC;IAC3B,QAAQ,CAAC,CAAC,EAAE,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClD,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,sBAAsB,CAAC,QAAQ,CAAC,EACzC,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CAAC;IACd,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,KAAK,IAAI,IAAI,CAAC;IACd,WAAW,IAAI,iBAAiB,EAAE,CAAC;CACpC,CAAC;AAmBF,wBAAsB,eAAe,CAAC,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5E,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,sBAAsB,CAAC,QAAQ,CAAC,GACxC,OAAO,CAAC,cAAc,CAAC,CAGzB;AAED,wBAAsB,YAAY,CAAC,CAAC,EAAE,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5E,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,sBAAsB,CAAC,QAAQ,CAAC,EACzC,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CAGZ;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,CAelE;AAED,wBAAsB,2BAA2B,CAC/C,UAAU,EAAE,MAAM,EAClB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAEf;AAED,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAEzF"}
+{"version":3,"file":"file-lock.d.ts","sourceRoot":"","sources":["../src/file-lock.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,yBAAyB,EAC9B,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EACzB,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,EAC9B,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EAChB,KAAK,0BAA0B,EAC/B,KAAK,kBAAkB,GACxB,MAAM,qBAAqB,CAAC;AAE7B,MAAM,MAAM,oBAAoB,GAAG,uBAAuB,CAAC;AAC3D,MAAM,MAAM,qBAAqB,GAAG,wBAAwB,CAAC;AAE7D,MAAM,MAAM,sBAAsB,CAAC,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,IAAI,CACjF,yBAAyB,CAAC,QAAQ,CAAC,EACnC,YAAY,GAAG,SAAS,CACzB,GAAG;IACF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,iBAAiB,CAAC;AAC/C,MAAM,MAAM,iBAAiB,GAAG,oBAAoB,CAAC;AACrD,YAAY,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AAEpE,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,CAAC,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9C,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,sBAAsB,CAAC,QAAQ,CAAC,GACxC,OAAO,CAAC,cAAc,CAAC,CAAC;IAC3B,QAAQ,CAAC,CAAC,EAAE,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClD,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,sBAAsB,CAAC,QAAQ,CAAC,EACzC,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CAAC;IACd,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,KAAK,IAAI,IAAI,CAAC;IACd,WAAW,IAAI,iBAAiB,EAAE,CAAC;CACpC,CAAC;AAiCF,wBAAsB,eAAe,CAAC,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5E,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,sBAAsB,CAAC,QAAQ,CAAC,GACxC,OAAO,CAAC,cAAc,CAAC,CAGzB;AAED,wBAAsB,YAAY,CAAC,CAAC,EAAE,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5E,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,sBAAsB,CAAC,QAAQ,CAAC,EACzC,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CAGZ;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,CAmBlE;AAED,wBAAsB,2BAA2B,CAC/C,UAAU,EAAE,MAAM,EAClB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAEf;AAED,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAEzF"}

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

@@ -5,13 +5,29 @@ function resolveFileLockManagerKey(targetPath, managerKey) {
     return managerKey ?? `fs-safe.file-lock:${targetPath}`;
 }
 function withLockDefaults(options) {
+    const { managerKey: _managerKey, lockPath } = options;
+    const acquireOptions = {};
+    for (const key of Reflect.ownKeys(options)) {
+        // Node 22 object-rest can read excluded accessors; exclude before copying.
+        if (key === "managerKey" || key === "lockPath")
+            continue;
+        if (!Object.getOwnPropertyDescriptor(options, key)?.enumerable)
+            continue;
+        Object.defineProperty(acquireOptions, key, {
+            value: Reflect.get(options, key),
+            enumerable: true,
+            writable: true,
+            configurable: true,
+        });
+    }
     const defaults = getFsSafeLockConfig();
     return {
-        ...options,
-        retry: options.retry ?? defaults.retry,
-        staleMs: options.staleMs ?? defaults.staleMs ?? 30_000,
-        staleRecovery: options.staleRecovery ?? defaults.staleRecovery,
-        timeoutMs: options.timeoutMs ?? defaults.timeoutMs,
+        ...acquireOptions,
+        retry: acquireOptions.retry ?? defaults.retry,
+        staleMs: acquireOptions.staleMs ?? defaults.staleMs ?? 30_000,
+        staleRecovery: acquireOptions.staleRecovery ?? defaults.staleRecovery,
+        timeoutMs: acquireOptions.timeoutMs ?? defaults.timeoutMs,
+        ...(lockPath === undefined ? {} : { lockPath }),
     };
 }
 export async function acquireFileLock(targetPath, options) {
@@ -26,12 +42,16 @@ export function createFileLockManager(key) {
     const manager = createSidecarLockManager(key);
     return {
         acquire: async (targetPath, options) => {
-            const { managerKey: _managerKey, ...acquireOptions } = options;
-            return await manager.acquire({ ...withLockDefaults(acquireOptions), targetPath });
+            return await manager.acquire({
+                ...withLockDefaults(options),
+                targetPath,
+            });
         },
         withLock: async (targetPath, options, fn) => {
-            const { managerKey: _managerKey, ...acquireOptions } = options;
-            return await manager.withLock({ ...withLockDefaults(acquireOptions), targetPath }, fn);
+            return await manager.withLock({
+                ...withLockDefaults(options),
+                targetPath,
+            }, fn);
         },
         drain: manager.drain,
         reset: manager.reset,

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

@@ -1,4 +1,4 @@
-type FailureKind = "identity" | "resolution" | `open:${string}` | `exclusive-create:${string}` | `unlinked:${string}` | `changed:${string}`;
+type FailureKind = "identity" | "resolution" | `open:${string}` | `exclusive-create:${string}` | `unlinked:${string}` | `changed:${string}` | `stat-leaf-missing:${string}`;
 export declare function recordFileObservationFailure(error: unknown, kind: FailureKind): void;
 export declare function isFileObservationFailure(error: unknown, kind: FailureKind): boolean;
 export declare function fileObservation(): {

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

@@ -1 +1 @@
-{"version":3,"file":"file-observation.d.ts","sourceRoot":"","sources":["../src/file-observation.ts"],"names":[],"mappings":"AAEA,KAAK,WAAW,GAAG,UAAU,GAAG,YAAY,GAAG,QAAQ,MAAM,EAAE,GAAG,oBAAoB,MAAM,EAAE,GAAG,YAAY,MAAM,EAAE,GAAG,WAAW,MAAM,EAAE,CAAC;AAG5I,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAMpF;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAEnF;AAGD,wBAAgB,eAAe;IAG3B,GAAG,CAAC,CAAC,aAAa,MAAM,CAAC,GAAG,CAAC;IAC7B,GAAG,QAAQ,OAAO,QAAQ,WAAW,GAAG,OAAO;EAElD"}
+{"version":3,"file":"file-observation.d.ts","sourceRoot":"","sources":["../src/file-observation.ts"],"names":[],"mappings":"AAEA,KAAK,WAAW,GAAG,UAAU,GAAG,YAAY,GAAG,QAAQ,MAAM,EAAE,GAAG,oBAAoB,MAAM,EAAE,GAAG,YAAY,MAAM,EAAE,GAAG,WAAW,MAAM,EAAE,GAAG,qBAAqB,MAAM,EAAE,CAAC;AAG5K,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAMpF;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAEnF;AAGD,wBAAgB,eAAe;IAG3B,GAAG,CAAC,CAAC,aAAa,MAAM,CAAC,GAAG,CAAC;IAC7B,GAAG,QAAQ,OAAO,QAAQ,WAAW,GAAG,OAAO;EAElD"}

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

@@ -1,8 +1,12 @@
+import { type BigIntStats } from "node:fs";
 import type { Readable } from "node:stream";
-import { type SyncDirectoryGuard } from "./directory-guard.js";
+import type { SyncDirectoryGuard } from "./directory-guard.js";
 import { type Root } from "./root.js";
 import { prepareSecretFileWrite } from "./secret-file.js";
-export type SyncParentGuard = SyncDirectoryGuard;
+export type SyncParentGuard = SyncDirectoryGuard & {
+    /** Exact authority retained separately from the legacy numeric durability receipt. */
+    readonly exactStat: BigIntStats;
+};
 export declare function ensureParentInRoot(scopedRoot: Root, relativePath: string, mode: number): Promise<void>;
 export declare function openWritableStoreRoot(params: {
     rootDir: string;

package/node_modules/@openclaw/fs-safe/dist/file-store-boundary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-store-boundary.d.ts","sourceRoot":"","sources":["../src/file-store-boundary.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAa,QAAQ,EAAE,MAAM,aAAa,CAAC;AAIvD,OAAO,EAGL,KAAK,kBAAkB,EACxB,MAAM,sBAAsB,CAAC;AAI9B,OAAO,EAA4C,KAAK,IAAI,EAAE,MAAM,WAAW,CAAC;AAGhF,OAAO,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAG1D,MAAM,MAAM,eAAe,GAAG,kBAAkB,CAAC;AAOjD,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,IAAI,EAChB,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC,CAOf;AAED,wBAAsB,qBAAqB,CAAC,MAAM,EAAE;IAClD,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,IAAI,CAAC,CAKhB;AAED,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC,CAAC,CAAC,GACnD,OAAO,CAAC,IAAI,CAAC,CASf;AAsCD,wBAAsB,uBAAuB,CAAC,MAAM,EAAE;IACpD,MAAM,EAAE,QAAQ,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,CAAC,CAwC1D;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAWrE;AAUD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,eAAe,CAOlB;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,eAAe,GAAG,OAAO,CAAC;CAC1C,GAAG,eAAe,CAyDlB"}
+{"version":3,"file":"file-store-boundary.d.ts","sourceRoot":"","sources":["../src/file-store-boundary.ts"],"names":[],"mappings":"AAAA,OAAe,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAGnD,OAAO,KAAK,EAAa,QAAQ,EAAE,MAAM,aAAa,CAAC;AAIvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAO/D,OAAO,EAA4C,KAAK,IAAI,EAAE,MAAM,WAAW,CAAC;AAGhF,OAAO,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAK1D,MAAM,MAAM,eAAe,GAAG,kBAAkB,GAAG;IACjD,sFAAsF;IACtF,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC;CACjC,CAAC;AAOF,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,IAAI,EAChB,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC,CAOf;AAED,wBAAsB,qBAAqB,CAAC,MAAM,EAAE;IAClD,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,IAAI,CAAC,CAMhB;AAED,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC,CAAC,CAAC,GACnD,OAAO,CAAC,IAAI,CAAC,CAUf;AAsCD,wBAAsB,uBAAuB,CAAC,MAAM,EAAE;IACpD,MAAM,EAAE,QAAQ,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,CAAC,CAwC1D;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAMrE;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,eAAe,CASlB;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,eAAe,GAAG,OAAO,CAAC;CAC1C,GAAG,eAAe,CAUlB"}

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

@@ -1,18 +1,19 @@
-import syncFs from "node:fs";
+import syncFs, {} from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { createByteLimitTransform } from "./bounded-read-stream.js";
 import { normalizeMaxBytes } from "./byte-budget.js";
 import { pipeline } from "node:stream/promises";
-import { assertSyncDirectoryGuard as assertDirectoryGuardSync, createSyncDirectoryGuard, } from "./directory-guard.js";
 import { FsSafeError } from "./errors.js";
-import { sameFileIdentity } from "./file-identity.js";
-import { isPathInside, isPathRelativeEscape } from "./path.js";
+import { assertSyncStoreDirectoryReceipt, ensureSyncStoreDirectory, } from "./file-store-sync-directory.js";
+import { isPathInside } from "./path.js";
 import { resolveOpenedFileRealPathForHandle, root } from "./root.js";
 import { ensureTrailingSep } from "./root-context.js";
 import { RootHandle } from "./root-impl.js";
 import { prepareSecretFileWrite } from "./secret-file.js";
 import { resolveSecureTempRoot } from "./secure-temp-dir.js";
+import { recursiveMkdirPath } from "./recursive-mkdir-path.js";
+import { assertNoWindowsPathAlias, pathForWindowsFilesystem } from "./windows-path-alias.js";
 function parentRelativePath(relativePath) {
     const parent = path.posix.dirname(relativePath);
     return parent === "." ? "" : parent;
@@ -26,8 +27,9 @@ export async function ensureParentInRoot(scopedRoot, relativePath, mode) {
     await chmodDirectoryInRootBestEffort(scopedRoot, parent, mode).catch(() => undefined);
 }
 export async function openWritableStoreRoot(params) {
+    assertNoWindowsPathAlias(params.rootDir, "filesystem", "store root uses a Windows filesystem namespace alias");
     const maxBytes = normalizeMaxBytes(params.maxBytes);
-    await fs.mkdir(params.rootDir, { recursive: true, mode: params.dirMode });
+    await fs.mkdir(recursiveMkdirPath(params.rootDir), { recursive: true, mode: params.dirMode });
     await fs.chmod(params.rootDir, params.dirMode).catch(() => undefined);
     return await root(params.rootDir, { hardlinks: "reject", maxBytes });
 }
@@ -36,6 +38,7 @@ export async function openPrivateStoreLockRoot(params) {
     // Bind to the admitted parent, never resolve a replacement into a fresh capability.
     return new RootHandle({
         rootDir: parentGuard.dir,
+        rootGuard: { dir: parentGuard.realPath, realPath: parentGuard.realPath, stat: parentGuard.stat },
         rootReal: parentGuard.realPath,
         rootWithSep: ensureTrailingSep(parentGuard.realPath),
         rootIdentity: { dev: parentGuard.stat.dev, ino: parentGuard.stat.ino },
@@ -114,27 +117,15 @@ export async function writeStreamToTempSource(params) {
     }
 }
 export function assertSyncDirectoryGuard(guard) {
-    try {
-        assertDirectoryGuardSync(guard);
-    }
-    catch (error) {
-        if (error instanceof FsSafeError && error.code === "path-mismatch") {
-            throw new FsSafeError("path-mismatch", "store directory changed during write", {
-                cause: error,
-            });
-        }
-        throw error;
-    }
-}
-function chmodDirectorySyncBestEffort(dir, mode) {
-    try {
-        syncFs.chmodSync(dir, mode);
-    }
-    catch {
-        // Best-effort on platforms that do not enforce POSIX modes.
-    }
+    assertSyncStoreDirectoryReceipt({
+        dir: guard.dir,
+        realPath: guard.realPath,
+        exactStat: guard.exactStat,
+    });
 }
 export function ensureParentSync(params) {
+    assertNoWindowsPathAlias(params.rootDir, "filesystem", "store root uses a Windows filesystem namespace alias");
+    assertNoWindowsPathAlias(params.filePath, "filesystem", "store path uses a Windows filesystem namespace alias");
     return ensureStoreDirectorySync({
         rootDir: params.rootDir,
         targetDir: path.dirname(path.resolve(params.filePath)),
@@ -143,47 +134,13 @@ export function ensureParentSync(params) {
     });
 }
 export function ensureStoreDirectorySync(params) {
-    const rootDir = path.resolve(params.rootDir);
-    const dir = path.resolve(params.targetDir);
-    const relative = path.relative(rootDir, dir);
-    if (isPathRelativeEscape(relative)) {
-        throw new FsSafeError("outside-workspace", "file path escapes store root");
-    }
-    syncFs.mkdirSync(rootDir, { recursive: true, mode: params.mode });
-    const rootStat = syncFs.lstatSync(rootDir);
-    if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) {
-        throw new FsSafeError("not-file", `${params.messagePrefix} root must be a directory: ${rootDir}`);
-    }
-    const rootReal = syncFs.realpathSync(rootDir);
-    chmodDirectorySyncBestEffort(rootDir, params.mode);
-    let current = rootDir;
-    for (const segment of path.relative(rootDir, dir).split(path.sep).filter(Boolean)) {
-        current = path.join(current, segment);
-        try {
-            const stat = syncFs.lstatSync(current);
-            if (stat.isSymbolicLink() || !stat.isDirectory()) {
-                throw new FsSafeError("not-file", `${params.messagePrefix} directory component must be a directory: ${current}`);
-            }
-        }
-        catch (error) {
-            if (error.code !== "ENOENT") {
-                throw error;
-            }
-            syncFs.mkdirSync(current, { mode: params.mode });
-        }
-        const currentRootStat = syncFs.lstatSync(rootDir);
-        const currentRootReal = syncFs.realpathSync(rootDir);
-        const currentReal = syncFs.realpathSync(current);
-        if (currentRootStat.isSymbolicLink() ||
-            !currentRootStat.isDirectory() ||
-            !sameFileIdentity(rootStat, currentRootStat) ||
-            currentRootReal !== rootReal ||
-            !isPathInside(rootReal, currentReal)) {
-            throw new FsSafeError("outside-workspace", `${params.messagePrefix} directory escapes root`);
-        }
-        chmodDirectorySyncBestEffort(current, params.mode);
-    }
-    const guard = createSyncDirectoryGuard(dir);
+    const receipt = ensureSyncStoreDirectory(params);
+    const guard = {
+        dir: receipt.dir,
+        realPath: receipt.realPath,
+        stat: syncFs.lstatSync(pathForWindowsFilesystem(receipt.dir)),
+        exactStat: receipt.exactStat,
+    };
     assertSyncDirectoryGuard(guard);
     return guard;
 }

package/node_modules/@openclaw/fs-safe/dist/file-store-copy-source.d.ts

@@ -0,0 +1,5 @@
+export declare function readFileStoreCopySource(params: {
+    sourcePath: string;
+    maxBytes?: number;
+}): Promise<Buffer>;
+//# sourceMappingURL=file-store-copy-source.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/file-store-copy-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-store-copy-source.d.ts","sourceRoot":"","sources":["../src/file-store-copy-source.ts"],"names":[],"mappings":"AAMA,wBAAsB,uBAAuB,CAAC,MAAM,EAAE;IACpD,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,MAAM,CAAC,CA4BlB"}

package/node_modules/@openclaw/fs-safe/dist/file-store-copy-source.js

@@ -0,0 +1,31 @@
+import fs from "node:fs";
+import { FsSafeError } from "./errors.js";
+import { assertFileStoreMaxBytes } from "./file-store-limit.js";
+import { readRegularFile } from "./regular-file.js";
+import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
+export async function readFileStoreCopySource(params) {
+    assertNoWindowsPathAlias(params.sourcePath, "filesystem", "source path uses a Windows filesystem namespace alias");
+    const sourceStat = fs.lstatSync(params.sourcePath);
+    if (sourceStat.isSymbolicLink() || !sourceStat.isFile()) {
+        throw new FsSafeError("not-file", "source path is not a file");
+    }
+    assertFileStoreMaxBytes(sourceStat.size, params.maxBytes);
+    try {
+        return (await readRegularFile({ filePath: params.sourcePath, maxBytes: params.maxBytes }))
+            .buffer;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes("regular file") || message.includes("not a regular file")) {
+            throw new FsSafeError("not-file", "source path is not a file", {
+                cause: error instanceof Error ? error : undefined,
+            });
+        }
+        if (params.maxBytes !== undefined && message.includes(`exceeds ${params.maxBytes} bytes`)) {
+            throw new FsSafeError("too-large", `file exceeds maximum size of ${params.maxBytes} bytes`, {
+                cause: error instanceof Error ? error : undefined,
+            });
+        }
+        throw error;
+    }
+}

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

@@ -0,0 +1,3 @@
+export declare function assertRelativePath(relativePath: string): string;
+export declare function resolveStorePath(rootDir: string, relativePath: string): string;
+//# sourceMappingURL=file-store-path.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/file-store-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-store-path.d.ts","sourceRoot":"","sources":["../src/file-store-path.ts"],"names":[],"mappings":"AAIA,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAe/D;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAY9E"}

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

@@ -0,0 +1,30 @@
+import path from "node:path";
+import { FsSafeError } from "./errors.js";
+import { isPathInside, splitSafeRelativePath } from "./path.js";
+export function assertRelativePath(relativePath) {
+    const raw = relativePath.trim();
+    if (!raw || raw !== relativePath) {
+        throw new FsSafeError("invalid-path", "store key must be non-empty and unpadded");
+    }
+    const segments = splitSafeRelativePath(raw);
+    if (segments.length === 0 ||
+        segments.join("/") !== raw ||
+        raw.normalize("NFC") !== raw ||
+        segments.some((segment) => /[ .]$/u.test(segment))) {
+        throw new FsSafeError("invalid-path", "store key must use one canonical relative spelling");
+    }
+    return raw;
+}
+export function resolveStorePath(rootDir, relativePath) {
+    const key = assertRelativePath(relativePath);
+    // FileStore constructors snapshot an absolute root before this helper runs.
+    // Do not re-resolve it: Node drops the trailing separator from an exact
+    // Windows namespace drive root such as `\\?\C:\`.
+    const root = path.isAbsolute(rootDir) ? rootDir : path.resolve(rootDir);
+    // The immutable key already passed segment validation; keep the containment check.
+    const target = path.resolve(root, key);
+    if (!isPathInside(root, target)) {
+        throw new FsSafeError("outside-workspace", "relative path escapes root");
+    }
+    return target;
+}

package/node_modules/@openclaw/fs-safe/dist/file-store-prune.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-store-prune.d.ts","sourceRoot":"","sources":["../src/file-store-prune.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,qBAAqB,GAAG;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF,wBAAsB,wBAAwB,CAAC,MAAM,EAAE;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,qBAAqB,CAAC;CAChC,GAAG,OAAO,CAAC,IAAI,CAAC,CAsFhB"}
+{"version":3,"file":"file-store-prune.d.ts","sourceRoot":"","sources":["../src/file-store-prune.ts"],"names":[],"mappings":"AAUA,MAAM,MAAM,qBAAqB,GAAG;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF,wBAAsB,wBAAwB,CAAC,MAAM,EAAE;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,qBAAqB,CAAC;CAChC,GAAG,OAAO,CAAC,IAAI,CAAC,CA8FhB"}

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

@@ -3,6 +3,8 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { FsSafeError } from "./errors.js";
 import { isPathInside } from "./path.js";
+import { realpathSync } from "./realpath.js";
+import { recursiveMkdirPath } from "./recursive-mkdir-path.js";
 import { root } from "./root.js";
 import { getFsSafeTestHooks } from "./test-hooks.js";
 export async function pruneExpiredStoreEntries(params) {
@@ -10,8 +12,8 @@ export async function pruneExpiredStoreEntries(params) {
     const recursive = params.options.recursive ?? false;
     const maxDepth = params.options.maxDepth;
     const pruneEmptyDirs = (recursive || maxDepth !== undefined) && (params.options.pruneEmptyDirs ?? false);
-    await fs.mkdir(params.rootDir, { recursive: true, mode: params.dirMode });
-    const rootReal = fsSync.realpathSync.native(params.rootDir);
+    await fs.mkdir(recursiveMkdirPath(params.rootDir), { recursive: true, mode: params.dirMode });
+    const rootReal = realpathSync.native(params.rootDir);
     const scopedRoot = await root(rootReal);
     const rootGuard = {
         dir: rootReal,
@@ -24,7 +26,7 @@ export async function pruneExpiredStoreEntries(params) {
             !stat.isDirectory() ||
             stat.dev !== rootGuard.stat.dev ||
             stat.ino !== rootGuard.stat.ino ||
-            fsSync.realpathSync.native(rootGuard.dir) !== rootGuard.realPath) {
+            realpathSync.native(rootGuard.dir) !== rootGuard.realPath) {
             throw new FsSafeError("path-mismatch", "store root changed during prune");
         }
     }
@@ -33,7 +35,7 @@ export async function pruneExpiredStoreEntries(params) {
         if (!before || before.isSymbolicLink() || !before.isDirectory()) {
             return null;
         }
-        const real = observeOrNull(() => fsSync.realpathSync.native(dir));
+        const real = observeOrNull(() => realpathSync.native(dir));
         if (!real || !isPathInside(rootReal, real)) {
             return null;
         }
@@ -74,7 +76,15 @@ export async function pruneExpiredStoreEntries(params) {
             }
             if (stat.isFile() && now - stat.mtimeMs > params.options.ttlMs) {
                 await assertRootGuard();
-                await scopedRoot.remove(relativePath).catch(() => undefined);
+                await scopedRoot.remove(relativePath, {
+                    assertBeforeMutation: () => {
+                        // Removal preparation can outlive the expiry observation above.
+                        const current = fsSync.lstatSync(fullPath);
+                        if (!current.isFile() || !(now - current.mtimeMs > params.options.ttlMs)) {
+                            throw new FsSafeError("path-mismatch", "store entry is no longer an expired file");
+                        }
+                    },
+                }).catch(() => undefined);
             }
         }
         if (!pruneEmptyDirs) {

package/node_modules/@openclaw/fs-safe/dist/file-store-sync-directory.d.ts

@@ -0,0 +1,16 @@
+import { type BigIntStats } from "node:fs";
+type StoreMessagePrefix = "private store" | "store";
+export type SyncStoreDirectoryReceipt = Readonly<{
+    dir: string;
+    realPath: string;
+    exactStat: BigIntStats;
+}>;
+export declare function ensureSyncStoreDirectory(params: {
+    rootDir: string;
+    targetDir: string;
+    mode: number;
+    messagePrefix: StoreMessagePrefix;
+}): SyncStoreDirectoryReceipt;
+export declare function assertSyncStoreDirectoryReceipt(receipt: SyncStoreDirectoryReceipt): void;
+export {};
+//# sourceMappingURL=file-store-sync-directory.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/file-store-sync-directory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-store-sync-directory.d.ts","sourceRoot":"","sources":["../src/file-store-sync-directory.ts"],"names":[],"mappings":"AAAA,OAAW,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAc/C,KAAK,kBAAkB,GAAG,eAAe,GAAG,OAAO,CAAC;AAOpD,MAAM,MAAM,yBAAyB,GAAG,QAAQ,CAAC;IAC/C,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,WAAW,CAAC;CACxB,CAAC,CAAC;AAkVH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,kBAAkB,CAAC;CACnC,GAAG,yBAAyB,CA4D5B;AAED,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,yBAAyB,GACjC,IAAI,CAsBN"}