@openclaw/openshell-sandbox 2026.9.4 → 2026.9.6

package/node_modules/@openclaw/fs-safe/dist/home-dir.js

@@ -1,6 +1,21 @@
 import os from "node:os";
 import path from "node:path";
+import process from "node:process";
 import { normalizeOptionalString } from "./string-coerce.js";
+import { assertNoWindowsPathAlias, assertNoWindowsPathAliasForPlatform, repairResolvedWindowsRoot, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
+const PATH_ALIAS_MESSAGE = "path uses a Windows filesystem namespace alias";
+function isOrdinaryRootedWindowsDrivePath(input) {
+    const drive = input.charCodeAt(0);
+    return input.length >= 3 &&
+        ((drive >= 0x41 && drive <= 0x5a) || (drive >= 0x61 && drive <= 0x7a)) &&
+        input.charCodeAt(1) === 0x3a &&
+        (input.charCodeAt(2) === 0x5c || input.charCodeAt(2) === 0x2f) &&
+        input.indexOf(":", 2) === -1;
+}
+function hasHomePrefix(input) {
+    return input === "~" || input.startsWith("~/") ||
+        (path.sep === "\\" && input.startsWith("~\\"));
+}
 function normalize(value) {
     const trimmed = normalizeOptionalString(value);
     if (!trimmed) {
@@ -13,15 +28,19 @@ function normalize(value) {
 }
 export function resolveEffectiveHomeDir(env = process.env, homedir = os.homedir) {
     const raw = resolveRawHomeDir(env, homedir);
-    return raw ? path.resolve(raw) : undefined;
+    if (!raw)
+        return undefined;
+    assertNoWindowsPathAlias(raw, "filesystem", "home path uses a Windows filesystem namespace alias");
+    const resolved = resolvePathPreservingWindowsRoot(raw);
+    assertNoWindowsPathAlias(resolved, "filesystem", "home path uses a Windows filesystem namespace alias");
+    return resolved;
 }
 function resolveRawHomeDir(env, homedir) {
     const explicitHome = normalize(env.OPENCLAW_HOME);
     if (!explicitHome) {
         return resolveRawOsHomeDir(env, homedir);
     }
-    const segments = path.normalize(explicitHome).split(path.sep);
-    if (segments[0] !== "~") {
+    if (!hasHomePrefix(explicitHome)) {
         return explicitHome;
     }
     // OPENCLAW_HOME starts with "~"; expand against the os home dir. Fall
@@ -53,11 +72,12 @@ function normalizeSafe(homedir) {
     }
 }
 export function resolveRequiredHomeDir(env = process.env, homedir = os.homedir) {
-    return resolveEffectiveHomeDir(env, homedir) ?? path.resolve(process.cwd());
+    const resolved = resolveEffectiveHomeDir(env, homedir) ?? path.resolve(process.cwd());
+    assertNoWindowsPathAlias(resolved, "filesystem", "home path uses a Windows filesystem namespace alias");
+    return resolved;
 }
 export function expandHomePrefix(input, opts) {
-    const segments = path.normalize(input).split(path.sep);
-    if (segments[0] !== "~") {
+    if (!hasHomePrefix(input)) {
         return input;
     }
     const home = normalize(opts?.home) ??
@@ -65,20 +85,65 @@ export function expandHomePrefix(input, opts) {
     if (!home) {
         return input;
     }
-    return path.join(home, ...segments.slice(1));
+    // Expand before normalizing so a following .. traverses the actual home.
+    return path.join(home, input.slice(2));
 }
-export function resolveHomeRelativePath(input, opts) {
-    if (!input) {
-        return input;
-    }
-    const segments = path.normalize(input).split(path.sep);
-    if (segments[0] !== "~") {
-        return path.resolve(input);
-    }
+function resolveExpandedHomePath(input, opts) {
     const expanded = expandHomePrefix(input, {
         home: resolveRequiredHomeDir(opts?.env ?? process.env, opts?.homedir ?? os.homedir),
         env: opts?.env,
         homedir: opts?.homedir,
     });
-    return path.resolve(expanded);
+    const resolved = resolvePathPreservingWindowsRoot(expanded);
+    assertNoWindowsPathAlias(resolved, "filesystem", PATH_ALIAS_MESSAGE);
+    return resolved;
+}
+function admitFinalHomePath(resolved, platform) {
+    assertNoWindowsPathAliasForPlatform(resolved, "filesystem", PATH_ALIAS_MESSAGE, platform);
+    return resolved;
+}
+function finishOrdinaryHomePath(input, resolved) {
+    const resolvedPlatform = process.platform;
+    if (resolved === input && resolvedPlatform !== undefined)
+        return resolved;
+    return admitFinalHomePath(resolved, resolvedPlatform);
+}
+function repairAndFinishOrdinaryHomePath(input, resolved) {
+    return finishOrdinaryHomePath(input, repairResolvedWindowsRoot(input, resolved));
+}
+function resolveHomePathCold(input, opts, rawPlatform, ordinaryRawAdmitted) {
+    if (ordinaryRawAdmitted) {
+        return finishOrdinaryHomePath(input, resolvePathPreservingWindowsRoot(input));
+    }
+    assertNoWindowsPathAliasForPlatform(input, "filesystem", PATH_ALIAS_MESSAGE, rawPlatform);
+    if (!hasHomePrefix(input)) {
+        const resolved = resolvePathPreservingWindowsRoot(input);
+        // This cold branch was not admitted as an ordinary rooted drive. Recheck
+        // even an unchanged result because the live platform can change between
+        // raw admission and resolved-path admission. Passing undefined preserves
+        // the classifier's default process.platform read.
+        return admitFinalHomePath(resolved, process.platform);
+    }
+    return resolveExpandedHomePath(input, opts);
+}
+export function resolveHomeRelativePath(input, opts) {
+    if (!input) {
+        return input;
+    }
+    const rawPlatform = process.platform;
+    // Primitive ordinary drive paths have exactly one structural colon. Record
+    // that admission so an unchanged resolved string does not need rescanning.
+    const ordinaryRawAdmitted = rawPlatform === "win32" &&
+        typeof input === "string" &&
+        isOrdinaryRootedWindowsDrivePath(input);
+    // Keep the overwhelmingly common rooted-drive path close to path.resolve
+    // itself. Seven-byte inputs retain the general helper's observable
+    // namespace-root preflight; a rare six-byte result retains its repair.
+    if (!ordinaryRawAdmitted || input.length === 7) {
+        return resolveHomePathCold(input, opts, rawPlatform, ordinaryRawAdmitted);
+    }
+    const resolved = path.resolve(input);
+    return resolved.length === 6
+        ? repairAndFinishOrdinaryHomePath(input, resolved)
+        : finishOrdinaryHomePath(input, resolved);
 }

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

@@ -1,7 +1,9 @@
-export { FsSafeError, categorizeFsSafeError, type FsSafeErrorCategory, type FsSafeErrorCode, type FsSafeErrorDetails, } from "./errors.js";
-export { DEFAULT_ROOT_MAX_BYTES, root, type DenyMutationPolicy, type HardlinkPolicy, type RenameIdentityPolicy, type OpenResult, type ReadResult, type Root, type RootAppendOptions, type RootCopyOptions, type RootCreateJsonOptions, type RootCreateOptions, type RootDefaults, type RootMkdirOptions, type RootMoveOptions, type RootOpenOptions, type RootOpenWritableOptions, type RootOptions, type RootReadOptions, type RootRemoveOptions, type RootWriteJsonOptions, type RootWriteOptions, type RootWalkDataEntry, type RootWalkDataEntryKind, type RootWalkDirectoryErrorBehavior, type RootWalkEntry, type RootWalkEntryFilter, type RootWalkEntryFilterResult, type RootWalkEntryKind, type RootWalkLimitBehavior, type RootWalkOptions, type RootWalkSymlinkPolicy, type SymlinkPolicy, type WritableOpenMode, type WritableOpenResult, } from "./root.js";
-export type { ContainmentGuarantee } from "./containment.js";
-export { configureFsSafePython, configureFsSafeNative, getFsSafeNativeConfig, type FsSafePythonConfig, type FsSafeNativeConfig, type FsSafeNativeMode, } from "./native-config.js";
-export { writeExternalFileWithinRoot, type ExternalFileWriteOptions, type ExternalFileWriteResult, } from "./output.js";
-export { configureFsSafeLocks, getFsSafeLockConfig, type FsSafeLockConfig, } from "./lock-config.js";
-//# sourceMappingURL=index.d.ts.map
+export { FsSafeError, categorizeFsSafeError, } from "./errors.js";
+export type * from "./errors.js";
+export { DEFAULT_ROOT_MAX_BYTES, root, type Root, } from "./root.js";
+export type * from "./root-public-types.js";
+export { configureFsSafePython, configureFsSafeNative, getFsSafeNativeConfig, } from "./native-config.js";
+export type * from "./config.js";
+export { writeExternalFileWithinRoot, } from "./output.js";
+export type * from "./output.js";
+export { configureFsSafeLocks, getFsSafeLockConfig, } from "./lock-config.js";

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

@@ -1,5 +1,11 @@
 export declare function safeDirName(input: string): string;
+/** Legacy readable encoding; distinct IDs can share a result. Use V2 for untrusted IDs. */
 export declare function safePathSegmentHashed(input: string): string;
+/**
+ * Versioned install-ID encoding: every trimmed ID receives a domain-separated
+ * SHA-256 digest. Only surrounding whitespace is intentionally equivalent.
+ */
+export declare function safePathSegmentHashedV2(input: string): string;
 export declare function resolveSafeInstallDir(params: {
     baseDir: string;
     id: string;
@@ -17,4 +23,3 @@ export declare function assertCanonicalPathWithinBase(params: {
     candidatePath: string;
     boundaryLabel: string;
 }): Promise<void>;
-//# sourceMappingURL=install-path.d.ts.map

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

@@ -1,7 +1,9 @@
 import { createHash } from "node:crypto";
-import fs from "node:fs/promises";
+import fsSync from "node:fs";
 import path from "node:path";
 import { isPathInside } from "./path.js";
+import { realpathSync } from "./realpath.js";
+import { hasWindowsPathAlias, pathForWindowsFilesystem, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
 export function safeDirName(input) {
     const trimmed = input.trim();
     if (!trimmed) {
@@ -9,31 +11,51 @@ export function safeDirName(input) {
     }
     return trimmed.replaceAll("/", "__").replaceAll("\\", "__");
 }
+/** Legacy readable encoding; distinct IDs can share a result. Use V2 for untrusted IDs. */
 export function safePathSegmentHashed(input) {
     const trimmed = input.trim();
     const base = trimmed
-        .replaceAll(/[\\/]/g, "-")
-        .replaceAll(/[^a-zA-Z0-9._-]/g, "-")
-        .replaceAll(/-+/g, "-")
-        .replaceAll(/^-+/g, "")
-        .replaceAll(/-+$/g, "");
+        .replaceAll(/[^a-zA-Z0-9._]+/g, "-")
+        .replaceAll(/^-|-$/g, "");
     const normalized = base.length > 0 ? base : "skill";
     const safe = normalized === "." || normalized === ".." ? "skill" : normalized;
-    const hash = createHash("sha256").update(trimmed).digest("hex").slice(0, 10);
-    if (safe !== trimmed) {
-        const prefix = safe.length > 50 ? safe.slice(0, 50) : safe;
-        return `${prefix}-${hash}`;
-    }
-    if (safe.length > 60) {
+    if (safe !== trimmed || safe.length > 60) {
+        const hash = createHash("sha256").update(trimmed).digest("hex").slice(0, 10);
         return `${safe.slice(0, 50)}-${hash}`;
     }
     return safe;
 }
+/**
+ * Versioned install-ID encoding: every trimmed ID receives a domain-separated
+ * SHA-256 digest. Only surrounding whitespace is intentionally equivalent.
+ */
+export function safePathSegmentHashedV2(input) {
+    const hash = createHash("sha256")
+        .update("@openclaw/fs-safe:install-path:v2\0", "utf8")
+        // UTF-16LE preserves every JavaScript code unit, including lone surrogates.
+        .update(input.trim(), "utf16le")
+        .digest("hex");
+    return `id-v2-${hash}`;
+}
 export function resolveSafeInstallDir(params) {
+    const baseDir = params.baseDir;
+    if (hasWindowsPathAlias(baseDir, "filesystem")) {
+        return { ok: false, error: params.invalidNameMessage };
+    }
     const encodedName = (params.nameEncoder ?? safeDirName)(params.id);
-    const targetDir = path.join(params.baseDir, encodedName);
-    const resolvedBase = path.resolve(params.baseDir);
+    if (hasWindowsPathAlias(encodedName, "relative")) {
+        return { ok: false, error: params.invalidNameMessage };
+    }
+    const targetDir = path.join(baseDir, encodedName);
+    if (hasWindowsPathAlias(targetDir, "filesystem")) {
+        return { ok: false, error: params.invalidNameMessage };
+    }
+    const resolvedBase = resolvePathPreservingWindowsRoot(baseDir);
     const resolvedTarget = path.resolve(targetDir);
+    if (hasWindowsPathAlias(resolvedBase, "filesystem") ||
+        hasWindowsPathAlias(resolvedTarget, "filesystem")) {
+        return { ok: false, error: params.invalidNameMessage };
+    }
     const relative = path.relative(resolvedBase, resolvedTarget);
     if (!relative ||
         relative === ".." ||
@@ -44,40 +66,58 @@ export function resolveSafeInstallDir(params) {
     return { ok: true, path: resolvedTarget };
 }
 export async function assertCanonicalPathWithinBase(params) {
-    const baseDir = path.resolve(params.baseDir);
-    const candidatePath = path.resolve(params.candidatePath);
+    const baseDirInput = params.baseDir;
+    const candidatePathInput = params.candidatePath;
+    const boundaryLabel = params.boundaryLabel;
+    const invalidPath = () => new Error(`Invalid path: must stay within ${boundaryLabel}`);
+    const assertAdmittedPath = (value) => {
+        if (hasWindowsPathAlias(value, "filesystem"))
+            throw invalidPath();
+    };
+    assertAdmittedPath(baseDirInput);
+    assertAdmittedPath(candidatePathInput);
+    const baseDir = resolvePathPreservingWindowsRoot(baseDirInput);
+    const candidatePath = resolvePathPreservingWindowsRoot(candidatePathInput);
+    assertAdmittedPath(baseDir);
+    assertAdmittedPath(candidatePath);
     if (!isPathInside(baseDir, candidatePath)) {
-        throw new Error(`Invalid path: must stay within ${params.boundaryLabel}`);
+        throw invalidPath();
     }
-    const baseLstat = await fs.lstat(baseDir);
+    const baseOperationPath = pathForWindowsFilesystem(baseDir);
+    const baseLstat = fsSync.lstatSync(baseOperationPath);
     if (baseLstat.isSymbolicLink()) {
-        const baseStat = await fs.stat(baseDir);
+        const baseStat = fsSync.statSync(baseOperationPath);
         if (!baseStat.isDirectory()) {
-            throw new Error(`Invalid ${params.boundaryLabel}: base directory must resolve to a directory`);
+            throw new Error(`Invalid ${boundaryLabel}: base directory must resolve to a directory`);
         }
     }
     else if (!baseLstat.isDirectory()) {
-        throw new Error(`Invalid ${params.boundaryLabel}: base directory must be a directory`);
+        throw new Error(`Invalid ${boundaryLabel}: base directory must be a directory`);
     }
-    const baseRealPath = await fs.realpath(baseDir);
+    const baseRealPath = realpathSync.native(baseOperationPath);
+    assertAdmittedPath(baseRealPath);
     const validateDirectory = async (dirPath) => {
-        const resolvedDirPath = path.resolve(dirPath);
-        const dirLstat = await fs.lstat(dirPath);
+        assertAdmittedPath(dirPath);
+        const resolvedDirPath = resolvePathPreservingWindowsRoot(dirPath);
+        assertAdmittedPath(resolvedDirPath);
+        const operationPath = pathForWindowsFilesystem(dirPath);
+        const dirLstat = fsSync.lstatSync(operationPath);
         if (dirLstat.isSymbolicLink()) {
             if (resolvedDirPath !== baseDir) {
-                throw new Error(`Invalid path: must stay within ${params.boundaryLabel}`);
+                throw new Error(`Invalid path: must stay within ${boundaryLabel}`);
             }
-            const dirStat = await fs.stat(dirPath);
+            const dirStat = fsSync.statSync(operationPath);
             if (!dirStat.isDirectory()) {
-                throw new Error(`Invalid path: must stay within ${params.boundaryLabel}`);
+                throw new Error(`Invalid path: must stay within ${boundaryLabel}`);
             }
         }
         else if (!dirLstat.isDirectory()) {
-            throw new Error(`Invalid path: must stay within ${params.boundaryLabel}`);
+            throw new Error(`Invalid path: must stay within ${boundaryLabel}`);
         }
-        const dirRealPath = await fs.realpath(dirPath);
+        const dirRealPath = realpathSync.native(operationPath);
+        assertAdmittedPath(dirRealPath);
         if (!isPathInside(baseRealPath, dirRealPath)) {
-            throw new Error(`Invalid path: must stay within ${params.boundaryLabel}`);
+            throw invalidPath();
         }
     };
     try {
@@ -90,5 +130,7 @@ export async function assertCanonicalPathWithinBase(params) {
             throw err;
         }
     }
-    await validateDirectory(path.dirname(candidatePath));
+    const candidateParent = path.dirname(candidatePath);
+    assertAdmittedPath(candidateParent);
+    await validateDirectory(candidateParent);
 }

package/node_modules/@openclaw/fs-safe/dist/json-document-store.d.ts

@@ -9,6 +9,8 @@ export type JsonStoreLockOptions = {
     managerKey?: string;
 };
 export type JsonFileStoreOptions = {
+    /** Overrides the parent store's durability for every JSON mutation. */
+    durable?: boolean;
     trailingNewline?: boolean;
     lock?: boolean | JsonStoreLockOptions;
 };
@@ -29,7 +31,7 @@ export type JsonStoreAdapter<T> = {
     readRequired(): Promise<T>;
     write(value: T, options?: {
         trailingNewline?: boolean;
+        durable?: boolean;
     }): Promise<void>;
 };
 export declare function createJsonStore<T>(adapter: JsonStoreAdapter<T>, options?: JsonFileStoreOptions): JsonStore<T>;
-//# sourceMappingURL=json-document-store.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/json-document-store.js

@@ -35,10 +35,11 @@ export function createJsonStore(adapter, options = {}) {
         const current = await read();
         return current === undefined ? cloneFallback(fallback) : current;
     }
-    async function write(value) {
-        await adapter.write(value, {
+    function snapshotWriteOptions() {
+        return {
             trailingNewline: options.trailingNewline ?? true,
-        });
+            durable: options.durable,
+        };
     }
     async function withSerializedMutation(run) {
         const canonicalPath = await canonicalPathFromExistingAncestor(adapter.filePath);
@@ -78,20 +79,27 @@ export function createJsonStore(adapter, options = {}) {
         readOr,
         readRequired: adapter.readRequired,
         write: async (value) => {
+            const writeOptions = snapshotWriteOptions();
             await withSerializedMutation(async () => {
-                await write(value);
+                await adapter.write(value, writeOptions);
+            });
+        },
+        update: async (run) => {
+            const writeOptions = snapshotWriteOptions();
+            return await withSerializedMutation(async () => {
+                const next = await run(await read());
+                await adapter.write(next, writeOptions);
+                return next;
+            });
+        },
+        updateOr: async (fallback, run) => {
+            const writeOptions = snapshotWriteOptions();
+            return await withSerializedMutation(async () => {
+                const current = await read();
+                const next = await run(current === undefined ? cloneFallback(fallback) : current);
+                await adapter.write(next, writeOptions);
+                return next;
             });
         },
-        update: async (run) => await withSerializedMutation(async () => {
-            const next = await run(await read());
-            await write(next);
-            return next;
-        }),
-        updateOr: async (fallback, run) => await withSerializedMutation(async () => {
-            const current = await read();
-            const next = await run(current === undefined ? cloneFallback(fallback) : current);
-            await write(next);
-            return next;
-        }),
     };
 }

package/node_modules/@openclaw/fs-safe/dist/json-durable-queue-directory.d.ts

@@ -1,2 +1,14 @@
+export declare function queueDirectories(queueDir: string, failedDir: string): Promise<{
+    queue: QueueDirectory;
+    failed: QueueDirectory;
+}>;
+declare class QueueDirectory {
+    private readonly dir;
+    private readonly root;
+    private readonly allowSymlinkBase;
+    constructor(dir: string);
+    ensure(): Promise<void>;
+    assert(allowMissing?: boolean): Promise<void>;
+}
 export declare function syncQueueDirectoryCreation(dir: string, validationBase: string): Promise<void>;
-//# sourceMappingURL=json-durable-queue-directory.d.ts.map
+export {};

package/node_modules/@openclaw/fs-safe/dist/json-durable-queue-directory.js

@@ -1,10 +1,144 @@
-import fs from "node:fs/promises";
+import fs from "node:fs";
 import path from "node:path";
 import { syncDirectory } from "./directory-durability.js";
 import { isPathRelativeEscape } from "./path.js";
+import { realpathSync } from "./realpath.js";
+import { recursiveMkdirPath } from "./recursive-mkdir-path.js";
+import { assertNoWindowsPathAlias, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
+export async function queueDirectories(queueDir, failedDir) {
+    const queue = new QueueDirectory(queueDir);
+    return { queue, failed: new QueueDirectory(failedDir) };
+}
+class QueueDirectory {
+    dir;
+    root;
+    allowSymlinkBase;
+    constructor(dir) {
+        this.dir = dir;
+        this.root = path.parse(resolveQueueFilesystemPath(dir)).root;
+        this.allowSymlinkBase = process.platform === "darwin";
+    }
+    async ensure() {
+        await this.assert(true);
+        await fs.promises.mkdir(recursiveMkdirPath(this.dir), { recursive: true, mode: 0o700 });
+        await this.assert();
+        await chmodQueueDirectory(this.dir);
+        await syncQueueDirectoryCreation(this.dir, this.root);
+    }
+    async assert(allowMissing = false) {
+        const dir = this.dir;
+        let base = resolveQueueFilesystemPath(this.root);
+        let target = resolveQueueFilesystemPath(dir);
+        let current = base;
+        let baseStat = fs.lstatSync(base);
+        if (baseStat.isSymbolicLink() && this.allowSymlinkBase) {
+            const relative = path.relative(base, target);
+            if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+                throw new Error(`durable queue path is not a directory: ${dir}`);
+            }
+            base = realpathSync.native(base);
+            target = path.join(base, ...relative.split(path.sep).filter(Boolean));
+            current = base;
+            baseStat = fs.lstatSync(base);
+        }
+        if (baseStat.isSymbolicLink() || !baseStat.isDirectory()) {
+            throw new Error(`durable queue path is not a directory: ${dir}`);
+        }
+        const segments = path.relative(base, target).split(path.sep).filter(Boolean);
+        for (let index = 0; index < segments.length; index++) {
+            const segment = segments[index];
+            if (segment === undefined) {
+                continue;
+            }
+            current = path.join(current, segment);
+            let stat;
+            try {
+                stat = fs.lstatSync(current);
+            }
+            catch (error) {
+                if (allowMissing && error.code === "ENOENT") {
+                    return;
+                }
+                throw error;
+            }
+            if (stat.isSymbolicLink() || !stat.isDirectory()) {
+                if (stat.isSymbolicLink() && this.allowSymlinkBase) {
+                    if (await isDarwinSystemAlias(current, stat)) {
+                        current = realpathSync.native(current);
+                        continue;
+                    }
+                }
+                throw new Error(`durable queue path is not a directory: ${dir}`);
+            }
+        }
+    }
+}
+async function isDarwinSystemAlias(dir, stat) {
+    if (process.platform !== "darwin" || !stat.isSymbolicLink()) {
+        return false;
+    }
+    const resolved = path.resolve(dir);
+    if (resolved !== "/tmp" && resolved !== "/var") {
+        return false;
+    }
+    try {
+        return realpathSync.native(resolved) === `/private${resolved}`;
+    }
+    catch {
+        return false;
+    }
+}
+async function chmodQueueDirectory(dir) {
+    const noFollow = typeof fs.constants.O_NOFOLLOW === "number" && process.platform !== "win32"
+        ? fs.constants.O_NOFOLLOW
+        : 0;
+    const directoryFlag = typeof fs.constants.O_DIRECTORY === "number" && process.platform !== "win32"
+        ? fs.constants.O_DIRECTORY
+        : 0;
+    if (noFollow || directoryFlag) {
+        let handle;
+        try {
+            handle = await fs.promises.open(dir, fs.constants.O_RDONLY | noFollow | directoryFlag);
+            const stat = fs.fstatSync(handle.fd);
+            if (!stat.isDirectory()) {
+                throw new Error(`durable queue path is not a directory: ${dir}`);
+            }
+            try {
+                await handle.chmod(0o700);
+            }
+            catch {
+                // Best-effort on platforms that do not enforce POSIX modes.
+            }
+            return;
+        }
+        finally {
+            try {
+                await handle?.close();
+            }
+            catch {
+                // Best-effort cleanup after chmod/open failures.
+            }
+        }
+    }
+    const stat = fs.lstatSync(dir);
+    if (stat.isSymbolicLink() || !stat.isDirectory()) {
+        throw new Error(`durable queue path is not a directory: ${dir}`);
+    }
+    try {
+        await fs.promises.chmod(dir, 0o700);
+    }
+    catch {
+        // Best-effort on platforms that do not enforce POSIX modes.
+    }
+}
+function resolveQueueFilesystemPath(value) {
+    const resolved = resolvePathPreservingWindowsRoot(value);
+    assertNoWindowsPathAlias(resolved);
+    return resolved;
+}
 export async function syncQueueDirectoryCreation(dir, validationBase) {
-    const baseReal = await fs.realpath(validationBase);
-    const targetReal = await fs.realpath(dir);
+    const baseReal = realpathSync.native(validationBase);
+    const targetReal = realpathSync.native(dir);
     const relative = path.relative(baseReal, targetReal);
     if (isPathRelativeEscape(relative)) {
         throw new Error(`durable queue directory escapes validation base: ${dir}`);

package/node_modules/@openclaw/fs-safe/dist/json-durable-queue-ownership.d.ts

@@ -1,12 +1,19 @@
+import { type BigIntStats } from "node:fs";
 export type DurableQueueEntryPathsLike = {
     jsonPath: string;
     deliveredPath: string;
     processingPath?: string;
 };
-export declare function durableQueueProcessingPath(paths: DurableQueueEntryPathsLike): string;
+export type ValidatedDurableQueueEntryPaths = Readonly<{
+    jsonPath: string;
+    deliveredPath: string;
+    processingPath: string;
+}>;
+export declare function validateDurableQueueEntryPaths(paths: DurableQueueEntryPathsLike): ValidatedDurableQueueEntryPaths;
 export declare function claimDurableQueueEntry(paths: DurableQueueEntryPathsLike, options?: {
     skipUnowned?: boolean;
 }): Promise<string | null>;
+export declare function migrateDurableQueueEntry<T>(paths: DurableQueueEntryPathsLike, expected: BigIntStats, releaseReadPin: () => Promise<void>, run: (filePath: string, beforePublish: () => Promise<void>) => Promise<T>): Promise<T>;
 export declare function completeDeliveredQueueEntry(paths: DurableQueueEntryPathsLike): Promise<boolean>;
 export declare function acknowledgeDurableQueueEntry(paths: DurableQueueEntryPathsLike): Promise<void>;
 export declare function moveDurableQueueEntryToFailed(params: {
@@ -14,4 +21,3 @@ export declare function moveDurableQueueEntryToFailed(params: {
     failedPath: string;
 }): Promise<void>;
 export declare function getErrorCode(error: unknown): string | null;
-//# sourceMappingURL=json-durable-queue-ownership.d.ts.map