@openclaw/openshell-sandbox 2026.9.4 → 2026.9.6

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

@@ -3,34 +3,33 @@ import fsSync from "node:fs";
 import path from "node:path";
 import { readFileDescriptorBoundedSync } from "./bounded-read.js";
 import { FsSafeError } from "./errors.js";
-import { sameFileIdentityForCleanup } from "./file-identity.js";
 import { stringifyJsonDocument } from "./json-stringify.js";
 import { readRegularFile, readRegularFileSync, statRegularFile } from "./regular-file.js";
 import { openRootFileSync } from "./root-file.js";
-import { resolveReadOpenFlags } from "./read-open-flags.js";
+import { recursiveMkdirPath } from "./recursive-mkdir-path.js";
+import { writeTempFileSync } from "./replace-file-descriptor.js";
+import { SyncAtomicTempOwner } from "./replace-file-temp-owner.js";
+import { admitStandalonePublicationPath, assertNoWindowsPathAlias } from "./windows-path-alias.js";
 import { writeTextAtomic } from "./text-atomic.js";
 import { sleep } from "./timing.js";
 const READ_RETRY_MAX_ATTEMPTS = 5;
 const READ_RETRY_BASE_DELAY_MS = 50;
-function isRetryableReadError(err, options) {
+function isRetryableReadError(err) {
     if (err instanceof FsSafeError && err.code === "path-mismatch") {
         return true;
     }
-    if (options.retryOpenRaceErrors !== true) {
-        return false;
-    }
     const code = getErrorCode(err);
     return code === "ENOENT" || code === "EPERM";
 }
-async function readRegularFileWithRetry(filePath, options = {}) {
+async function readRegularFileWithRetry(filePath, maxBytes) {
     let lastErr;
     for (let attempt = 0; attempt < READ_RETRY_MAX_ATTEMPTS; attempt++) {
         try {
-            return (await readRegularFile({ filePath, maxBytes: options.maxBytes })).buffer;
+            return (await readRegularFile({ filePath, maxBytes })).buffer;
         }
         catch (err) {
             lastErr = err;
-            if (!isRetryableReadError(err, options) || attempt === READ_RETRY_MAX_ATTEMPTS - 1) {
+            if (!isRetryableReadError(err) || attempt === READ_RETRY_MAX_ATTEMPTS - 1) {
                 throw err;
             }
             await sleep(READ_RETRY_BASE_DELAY_MS * Math.pow(2, attempt));
@@ -43,52 +42,19 @@ async function readRegularFileIfExistsWithRetry(filePath, options = {}) {
     if (initial.missing) {
         return null;
     }
-    return await readRegularFileWithRetry(filePath, {
-        maxBytes: options.maxBytes,
-        retryOpenRaceErrors: true,
-    });
+    return await readRegularFileWithRetry(filePath, options.maxBytes);
 }
 const JSON_FILE_MODE = 0o600;
 const JSON_DIR_MODE = 0o700;
 function getErrorCode(err) {
     return err instanceof Error ? err.code : undefined;
 }
-function trySetSecureMode(pathname, expectedIdentity) {
-    let fd;
+function trySetSecureMode(fd) {
     try {
-        const before = fsSync.lstatSync(pathname, { bigint: true });
-        if (before.isSymbolicLink() ||
-            !before.isFile() ||
-            before.nlink !== 1n ||
-            !sameFileIdentityForCleanup(before, expectedIdentity)) {
-            return;
-        }
-        fd = fsSync.openSync(pathname, resolveReadOpenFlags());
-        const opened = fsSync.fstatSync(fd, { bigint: true });
-        const current = fsSync.lstatSync(pathname, { bigint: true });
-        if (!opened.isFile() ||
-            opened.nlink !== 1n ||
-            current.isSymbolicLink() ||
-            !current.isFile() ||
-            current.nlink !== 1n ||
-            !sameFileIdentityForCleanup(opened, expectedIdentity) ||
-            !sameFileIdentityForCleanup(current, opened)) {
-            return;
-        }
         fsSync.fchmodSync(fd, JSON_FILE_MODE);
     }
     catch {
-        // Best-effort mode application never falls back to a mutable pathname.
-    }
-    finally {
-        if (fd !== undefined) {
-            try {
-                fsSync.closeSync(fd);
-            }
-            catch {
-                // best-effort cleanup
-            }
-        }
+        // Best-effort mode application stays on the retained staging descriptor.
     }
 }
 function trySyncDirectory(pathname) {
@@ -111,48 +77,24 @@ function trySyncDirectory(pathname) {
         }
     }
 }
-function renameJsonFileWithFallback(tmpPath, pathname) {
+function renameJsonFileWithFallback(owner, pathname) {
+    owner.assertCurrent(fsSync);
     try {
-        fsSync.renameSync(tmpPath, pathname);
+        fsSync.renameSync(owner.pathname, pathname);
         return;
     }
     catch (error) {
-        const code = error.code;
+        const code = error?.code;
         if (code === "EPERM" || code === "EEXIST") {
-            const existing = (() => {
-                try {
-                    return fsSync.lstatSync(pathname);
-                }
-                catch (lstatError) {
-                    if (lstatError.code === "ENOENT") {
-                        return null;
-                    }
-                    throw lstatError;
-                }
-            })();
-            if (existing?.isSymbolicLink()) {
-                fsSync.rmSync(pathname, { force: true });
-                fsSync.renameSync(tmpPath, pathname);
-                return;
-            }
+            owner.assertCurrent(fsSync);
             fsSync.rmSync(pathname, { force: true });
-            fsSync.renameSync(tmpPath, pathname);
+            owner.assertCurrent(fsSync);
+            fsSync.renameSync(owner.pathname, pathname);
             return;
         }
         throw error;
     }
 }
-function writeTempJsonFile(pathname, payload) {
-    const fd = fsSync.openSync(pathname, "wx", JSON_FILE_MODE);
-    try {
-        fsSync.writeFileSync(fd, payload, "utf8");
-        fsSync.fsyncSync(fd);
-        return fsSync.fstatSync(fd, { bigint: true });
-    }
-    finally {
-        fsSync.closeSync(fd);
-    }
-}
 export function tryReadJsonSync(pathname, options = {}) {
     try {
         const raw = readRegularFileSync({
@@ -166,24 +108,36 @@ export function tryReadJsonSync(pathname, options = {}) {
     }
 }
 export function writeJsonSync(pathname, data) {
+    const filePath = admitStandalonePublicationPath(pathname);
     // Keep literal parent segments so staging follows the same symlinks as the target.
-    const tmpPath = path.format({ ...path.parse(pathname), base: `.fs-safe-${randomUUID()}.tmp` });
+    const tmpPath = path.format({ ...path.parse(filePath), base: `.fs-safe-${randomUUID()}.tmp` });
     const payload = `${stringifyJsonDocument(data, null, 2)}\n`;
-    fsSync.mkdirSync(path.dirname(pathname), { recursive: true, mode: JSON_DIR_MODE });
+    fsSync.mkdirSync(recursiveMkdirPath(path.dirname(filePath)), { recursive: true, mode: JSON_DIR_MODE });
+    const owner = new SyncAtomicTempOwner(tmpPath);
+    let originalFailure;
     try {
-        const tempIdentity = writeTempJsonFile(tmpPath, payload);
-        trySetSecureMode(tmpPath, tempIdentity);
-        renameJsonFileWithFallback(tmpPath, pathname);
-        trySetSecureMode(pathname, tempIdentity);
-        trySyncDirectory(pathname);
+        owner.start();
+        const temp = writeTempFileSync({
+            fsModule: fsSync, tempPath: tmpPath, content: payload, mode: JSON_FILE_MODE,
+            sync: false, onIdentity: owner.onIdentity,
+        });
+        owner.adopt(temp);
+        owner.assertCurrent(fsSync);
+        trySetSecureMode(temp.fd);
+        fsSync.fsyncSync(temp.fd);
+        renameJsonFileWithFallback(owner, filePath);
+        owner.markRenamed();
+        owner.assertPublished(fsSync, filePath);
+        trySetSecureMode(temp.fd);
+        trySyncDirectory(filePath);
+        owner.assertPublished(fsSync, filePath);
+    }
+    catch (error) {
+        originalFailure = { error };
+        throw error;
     }
     finally {
-        try {
-            fsSync.rmSync(tmpPath, { force: true });
-        }
-        catch {
-            // best-effort cleanup when rename does not happen
-        }
+        owner.finish({ fsModule: fsSync, originalFailure, throwOnCleanupError: false });
     }
 }
 export class JsonFileReadError extends Error {
@@ -206,29 +160,59 @@ function resolveInvalidMessage(invalidMessage, relativePath) {
     return invalidMessage ?? `${relativePath} has an unexpected shape`;
 }
 export function readRootStructuredFileSync(options) {
-    const absolutePath = path.resolve(options.rootDir, options.relativePath);
+    return readRootStructuredFileSyncInternal(options, options);
+}
+function readRootStructuredFileSyncInternal(options, parser) {
+    let absolutePath;
+    let relativePath;
+    let rootDir;
+    let rootRealPath;
+    try {
+        rootDir = options.rootDir;
+        relativePath = options.relativePath;
+        rootRealPath = options.rootRealPath;
+        assertNoWindowsPathAlias(rootDir);
+        assertNoWindowsPathAlias(relativePath, "relative");
+        if (rootRealPath !== undefined) {
+            assertNoWindowsPathAlias(rootRealPath);
+        }
+        absolutePath = path.resolve(rootDir, relativePath);
+        assertNoWindowsPathAlias(absolutePath);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            reason: "open",
+            failure: { ok: false, reason: "validation", error },
+        };
+    }
+    const boundaryLabel = options.boundaryLabel;
+    const rejectHardlinks = options.rejectHardlinks;
+    const maxBytes = options.maxBytes;
     const opened = openRootFileSync({
         absolutePath,
-        rootPath: options.rootDir,
-        ...(options.rootRealPath !== undefined ? { rootRealPath: options.rootRealPath } : {}),
-        boundaryLabel: options.boundaryLabel,
-        rejectHardlinks: options.rejectHardlinks,
-        maxBytes: options.maxBytes,
+        rootPath: rootDir,
+        rootRealPath,
+        boundaryLabel,
+        rejectHardlinks,
+        maxBytes,
         allowedType: "file",
     });
     if (!opened.ok) {
         return { ok: false, reason: "open", failure: opened };
     }
     try {
-        const raw = options.maxBytes === undefined
+        const raw = maxBytes === undefined
             ? fsSync.readFileSync(opened.fd, "utf8")
-            : readFileDescriptorBoundedSync(opened.fd, options.maxBytes).toString("utf8");
-        const parsed = options.parse(raw);
-        if (options.validate && !options.validate(parsed)) {
+            : readFileDescriptorBoundedSync(opened.fd, maxBytes).toString("utf8");
+        const parse = parser.parse;
+        const parsed = Reflect.apply(parse, parser, [raw]);
+        const validate = parser.validate;
+        if (validate && !Reflect.apply(validate, parser, [parsed])) {
             return {
                 ok: false,
                 reason: "invalid",
-                error: resolveInvalidMessage(options.invalidMessage, options.relativePath),
+                error: resolveInvalidMessage(parser.invalidMessage, relativePath),
             };
         }
         return {
@@ -243,7 +227,7 @@ export function readRootStructuredFileSync(options) {
         return {
             ok: false,
             reason: "parse",
-            error: `failed to parse ${options.relativePath}: ${String(error)}`,
+            error: `failed to parse ${relativePath}: ${String(error)}`,
         };
     }
     finally {
@@ -251,14 +235,12 @@ export function readRootStructuredFileSync(options) {
     }
 }
 export function readRootJsonSync(options) {
-    return readRootStructuredFileSync({
-        ...options,
+    return readRootStructuredFileSyncInternal(options, {
         parse: (raw) => JSON.parse(raw),
     });
 }
 export function readRootJsonObjectSync(options) {
-    return readRootStructuredFileSync({
-        ...options,
+    return readRootStructuredFileSyncInternal(options, {
         parse: (raw) => JSON.parse(raw),
         validate: isRecord,
         invalidMessage: (relativePath) => `${relativePath} must contain a JSON object`,
@@ -280,10 +262,7 @@ export async function tryReadJson(filePath, options = {}) {
 export async function readJson(filePath, options = {}) {
     let raw;
     try {
-        raw = (await readRegularFileWithRetry(filePath, {
-            maxBytes: options.maxBytes,
-            retryOpenRaceErrors: true,
-        })).toString("utf8");
+        raw = (await readRegularFileWithRetry(filePath, options.maxBytes)).toString("utf8");
     }
     catch (err) {
         throw new JsonFileReadError(filePath, "read", err);
@@ -333,8 +312,9 @@ export function readJsonSync(filePath, options = {}) {
     }
 }
 export async function writeJson(filePath, value, options) {
+    const admittedPath = admitStandalonePublicationPath(filePath);
     const text = stringifyJsonDocument(value, null, 2);
-    await writeTextAtomic(filePath, text, {
+    await writeTextAtomic(admittedPath, text, {
         mode: options?.mode,
         dirMode: options?.dirMode,
         trailingNewline: options?.trailingNewline,

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

@@ -6,4 +6,3 @@ export declare function assertNoWindowsNetworkPath(filePath: string, label?: str
 export declare function safeFileURLToPath(fileUrl: string, platform?: NodeJS.Platform): string;
 export declare function trySafeFileURLToPath(fileUrl: string, platform?: NodeJS.Platform): string | undefined;
 export declare function basenameFromMediaSource(source?: string): string | undefined;
-//# sourceMappingURL=local-file-access.d.ts.map

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

@@ -1,6 +1,8 @@
 import path from "node:path";
 import { fileURLToPath, URL } from "node:url";
 import { normalizeLowercaseStringOrEmpty } from "./string-coerce.js";
+import { hasWindowsPathAlias } from "./windows-path-alias.js";
+import { isWindowsSeparator, rootedWindowsDriveColonIndex, windowsNamespaceMarker, } from "./windows-path-syntax.js";
 const ENCODED_FILE_URL_SEPARATOR_RE = /%(?:2f|5c)/i;
 const FILE_URL_PREFIX_RE = /^file:\/\//i;
 export function isFileUrl(input) {
@@ -17,16 +19,8 @@ export function isWindowsNetworkPath(filePath, platform = process.platform) {
     if (platform !== "win32") {
         return false;
     }
-    const normalized = filePath.replace(/\//g, "\\");
-    const extendedDrive = normalized.length >= 7 &&
-        normalized.startsWith("\\\\?\\") &&
-        /^[a-z]$/i.test(normalized[4] ?? "") &&
-        normalized[5] === ":" &&
-        normalized[6] === "\\";
-    if (extendedDrive) {
-        return false;
-    }
-    return normalized.startsWith("\\\\");
+    return isWindowsSeparator(filePath, 0) && isWindowsSeparator(filePath, 1) &&
+        !(windowsNamespaceMarker(filePath) === "?" && rootedWindowsDriveColonIndex(filePath) === 5);
 }
 export function isWindowsDriveLetterPath(filePath, platform = process.platform) {
     return platform === "win32" && /^[A-Za-z]:[\\/]/.test(filePath);
@@ -54,6 +48,9 @@ export function safeFileURLToPath(fileUrl, platform = process.platform) {
         throw new Error(`file:// URLs cannot encode path separators: ${fileUrl}`);
     }
     const filePath = fileURLToPath(parsed, { windows: platform === "win32" });
+    if (hasWindowsPathAlias(filePath, "filesystem", platform)) {
+        throw new Error(`Local file URL cannot use Windows filesystem namespace aliases: ${filePath}`);
+    }
     if (isWindowsNetworkPath(filePath, platform)) {
         throw new Error(`Local file URL cannot use Windows network paths: ${filePath}`);
     }

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

@@ -0,0 +1,16 @@
+import type { BigIntStats, Stats } from "node:fs";
+import type { FileHandle } from "node:fs/promises";
+import type { HardlinkPolicy } from "./root-options.js";
+import type { SymlinkPolicy } from "./root-symlink-policy.js";
+type OwnedLocalFile = {
+    handle: FileHandle;
+    stat: Stats;
+    identity: BigIntStats;
+    preOpenStat: BigIntStats | undefined;
+};
+export declare function openLocalFileDescriptor(filePath: string, options?: {
+    hardlinks?: HardlinkPolicy;
+    symlinks?: SymlinkPolicy;
+    readWrite?: true;
+}): Promise<OwnedLocalFile>;
+export {};

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

@@ -0,0 +1,84 @@
+import fsSync from "node:fs";
+import fs from "node:fs/promises";
+import { FsSafeError } from "./errors.js";
+import { recordFileOpenFailure, recordPreOpenFileChange } from "./opened-file-failure.js";
+import { assertNoUnsafeDeviceReadPath, hasNodeErrorCode, isNotFoundPathError, isSymlinkOpenError, } from "./path.js";
+import { resolveReadOpenFlags } from "./read-open-flags.js";
+import { fileNotFoundError, hardlinkedPathNotAllowedError } from "./root-errors.js";
+import { inspectFileIdentity } from "./strict-file-identity.js";
+import { getFsSafeTestHooks } from "./test-hooks.js";
+const OPEN_READ_FLAGS = resolveReadOpenFlags();
+const OPEN_READ_FOLLOW_FLAGS = resolveReadOpenFlags({ followSymlinks: true });
+// Ownership transfers only after descriptor verification. Each admission caller
+// must close on rejection and construct an OpenResult only after admission.
+export async function openLocalFileDescriptor(filePath, options) {
+    assertNoUnsafeDeviceReadPath(filePath);
+    const fsSafeTestHooks = getFsSafeTestHooks();
+    let preOpenStat;
+    let observedBeforeOpen = false;
+    // Reject directories before opening so we never surface EISDIR to callers (e.g. tool
+    // results that get sent to messaging channels). See openclaw/openclaw#31186.
+    try {
+        preOpenStat = await inspectFileIdentity(() => {
+            const stat = fsSync.lstatSync(filePath, { bigint: true });
+            observedBeforeOpen = true;
+            if (stat.isSymbolicLink() && options?.symlinks !== "follow-within-root") {
+                throw new FsSafeError("symlink", "symlink not allowed");
+            }
+            if (!stat.isFile() && !stat.isSymbolicLink()) {
+                throw new FsSafeError("not-file", "not a file");
+            }
+            return stat;
+        });
+    }
+    catch (err) {
+        if (err instanceof FsSafeError || observedBeforeOpen) {
+            throw err;
+        }
+        // Only an initial lookup failure falls through; a failed re-inspection aborts.
+    }
+    if (preOpenStat) {
+        await fsSafeTestHooks?.afterPreOpenLstat?.(filePath);
+    }
+    const openFlags = (options?.symlinks === "follow-within-root"
+        ? OPEN_READ_FOLLOW_FLAGS
+        : OPEN_READ_FLAGS) | (options?.readWrite ? fsSync.constants.O_RDWR : 0);
+    await fsSafeTestHooks?.beforeOpen?.(filePath, openFlags);
+    let handle;
+    try {
+        handle = await fs.open(filePath, openFlags).catch((error) => recordFileOpenFailure(isNotFoundPathError(error) ? fileNotFoundError() : error, filePath));
+    }
+    catch (err) {
+        if (isSymlinkOpenError(err)) {
+            throw new FsSafeError("symlink", "symlink open blocked", { cause: err });
+        }
+        // Defensive: if open still throws EISDIR (e.g. race), sanitize so it never leaks.
+        if (hasNodeErrorCode(err, "EISDIR")) {
+            throw new FsSafeError("not-file", "not a file");
+        }
+        throw err;
+    }
+    try {
+        await fsSafeTestHooks?.afterOpen?.(filePath, handle);
+        const stat = fsSync.fstatSync(handle.fd);
+        if (!stat.isFile()) {
+            throw new FsSafeError("not-file", "not a file");
+        }
+        // Keep numeric Stats for the public receipt, never for identity verification.
+        let openedIdentity;
+        const identity = await inspectFileIdentity(() => (openedIdentity = fsSync.fstatSync(handle.fd, { bigint: true })), preOpenStat && !preOpenStat.isSymbolicLink() ? preOpenStat : undefined).catch(async (error) => {
+            if ([0, 1].includes(stat.nlink)) {
+                await recordPreOpenFileChange(error, handle, filePath, preOpenStat, openedIdentity);
+            }
+            throw error;
+        });
+        if (options?.hardlinks === "reject" && stat.nlink > 1) {
+            throw hardlinkedPathNotAllowedError();
+        }
+        return { handle, stat, identity, preOpenStat };
+    }
+    catch (err) {
+        await handle.close().catch(() => { });
+        throw err;
+    }
+}

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

@@ -23,4 +23,3 @@ export type ReadLocalFileFromRootsOptions = LocalRootsInputOptions & {
 };
 export declare function resolveLocalPathFromRootsSync(options: ResolveLocalPathFromRootsSyncOptions): LocalRootsPathResult | null;
 export declare function readLocalFileFromRoots(options: ReadLocalFileFromRootsOptions): Promise<LocalRootsReadResult | null>;
-//# sourceMappingURL=local-roots.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/local-roots.js

@@ -2,11 +2,12 @@ import fsSync from "node:fs";
 import path from "node:path";
 import { normalizeMaxBytes } from "./byte-budget.js";
 import { FsSafeError } from "./errors.js";
-import { expandHomePrefix, resolveHomeRelativePath } from "./home-dir.js";
+import { expandHomePrefix, resolveRequiredHomeDir } from "./home-dir.js";
 import { isFileUrl, safeFileURLToPath } from "./local-file-access.js";
-import { isPathInside } from "./path.js";
-import { resolveRootPathSync } from "./root-path.js";
+import { realpathSync } from "./realpath.js";
+import { ROOT_PATH_ALIAS_POLICIES, resolveRootPathSync } from "./root-path.js";
 import { root } from "./root.js";
+import { assertNoWindowsPathAlias, isWindowsPathAliasError, pathForWindowsFilesystem, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
 function resolveLocalPathInput(input, label) {
     if (isFileUrl(input)) {
         try {
@@ -20,7 +21,18 @@ function resolveLocalPathInput(input, label) {
     if (input.includes("\0")) {
         throw new FsSafeError("invalid-path", `${label} must not contain NUL bytes`);
     }
-    return resolveHomeRelativePath(input);
+    assertNoWindowsPathAlias(input, "filesystem", `${label} uses a Windows filesystem namespace alias`);
+    const homePrefix = input === "~" || input.startsWith("~/") ||
+        (path.sep === "\\" && input.startsWith("~\\"));
+    const expanded = homePrefix ? `${resolveRequiredHomeDir()}${path.sep}${input.slice(2)}` : input;
+    assertNoWindowsPathAlias(expanded, "filesystem", `${label} uses a Windows filesystem namespace alias`);
+    if (path.isAbsolute(expanded))
+        return expanded;
+    const drive = path.parse(expanded).root;
+    const base = drive ? path.resolve(drive) : process.cwd();
+    const resolved = `${base}${path.sep}${expanded.slice(drive.length)}`;
+    assertNoWindowsPathAlias(resolved, "filesystem", `${label} uses a Windows filesystem namespace alias`);
+    return resolved;
 }
 function resolveLocalRootInput(input, label) {
     const trimmed = input.trim();
@@ -33,29 +45,51 @@ function resolveLocalRootInput(input, label) {
     if (resolved.includes("\0")) {
         throw new FsSafeError("invalid-path", `${label} entry must not contain NUL bytes`);
     }
+    assertNoWindowsPathAlias(resolved, "filesystem", `${label} entry uses a Windows filesystem namespace alias`);
     if (!path.isAbsolute(resolved)) {
         throw new FsSafeError("invalid-path", `${label} entries must be absolute paths: ${input}`);
     }
-    return path.resolve(resolved);
+    const absolute = resolvePathPreservingWindowsRoot(resolved);
+    assertNoWindowsPathAlias(absolute, "filesystem", `${label} entry uses a Windows filesystem namespace alias`);
+    return absolute;
 }
 function resolveRootRealSync(rootDir) {
+    let realPath;
     try {
         // Configured roots may themselves be symlinks. Follow only this trusted
         // root entry, then use its canonical directory for containment checks.
-        const stat = fsSync.statSync(rootDir);
+        const operationPath = pathForWindowsFilesystem(rootDir);
+        const stat = fsSync.statSync(operationPath);
         if (!stat.isDirectory()) {
             return null;
         }
-        return fsSync.realpathSync(rootDir);
+        realPath = realpathSync(operationPath);
     }
     catch {
         return null;
     }
+    assertNoWindowsPathAlias(realPath, "filesystem", "local root uses a Windows filesystem namespace alias");
+    return realPath;
 }
-export function resolveLocalPathFromRootsSync(options) {
+function prepareLocalRootsInput(options) {
     const label = options.label ?? "local roots";
-    const requestedPath = path.resolve(resolveLocalPathInput(options.filePath, "file path"));
     const rootDirs = options.roots.map((rootEntry) => resolveLocalRootInput(rootEntry, label));
+    let requestedPath;
+    try {
+        requestedPath = resolveLocalPathInput(options.filePath, "file path");
+    }
+    catch (error) {
+        if (isWindowsPathAliasError(error))
+            return null;
+        throw error;
+    }
+    return { label, rootDirs, requestedPath };
+}
+export function resolveLocalPathFromRootsSync(options) {
+    const input = prepareLocalRootsInput(options);
+    if (!input)
+        return null;
+    const { label, rootDirs, requestedPath } = input;
     for (const rootDir of rootDirs) {
         const rootReal = resolveRootRealSync(rootDir);
         if (!rootReal) {
@@ -69,6 +103,7 @@ export function resolveLocalPathFromRootsSync(options) {
                 rootCanonicalPath: rootReal,
                 boundaryLabel: label,
                 rejectUnresolvedSymlinks: true,
+                policy: options.requireFile ? ROOT_PATH_ALIAS_POLICIES.unlinkTarget : undefined,
             });
         }
         catch {
@@ -77,11 +112,12 @@ export function resolveLocalPathFromRootsSync(options) {
         if (!candidate.exists && options.allowMissing !== true) {
             continue;
         }
+        if (candidate.exists && options.requireFile === true && candidate.kind !== "file")
+            continue;
         if (candidate.exists && options.requireFile === true) {
             try {
-                if (!fsSync.lstatSync(requestedPath).isFile()) {
+                if (!fsSync.lstatSync(pathForWindowsFilesystem(requestedPath)).isFile())
                     continue;
-                }
             }
             catch {
                 continue;
@@ -93,9 +129,17 @@ export function resolveLocalPathFromRootsSync(options) {
 }
 export async function readLocalFileFromRoots(options) {
     const maxBytes = normalizeMaxBytes(options.maxBytes);
-    const label = options.label ?? "local roots";
-    const requestedPath = path.resolve(resolveLocalPathInput(options.filePath, "file path"));
-    const rootDirs = options.roots.map((rootEntry) => resolveLocalRootInput(rootEntry, label));
+    const input = prepareLocalRootsInput(options);
+    if (!input || input.rootDirs.length === 0)
+        return null;
+    const { rootDirs, requestedPath } = input;
+    const readOptions = {
+        hardlinks: options.hardlinks,
+        symlinks: options.symlinks,
+    };
+    // Omission keeps Root's default cap; one policy snapshot serves every root.
+    if (maxBytes !== undefined)
+        readOptions.maxBytes = maxBytes;
     for (const rootDir of rootDirs) {
         let scopedRoot;
         try {
@@ -104,31 +148,12 @@ export async function readLocalFileFromRoots(options) {
         catch {
             continue;
         }
-        const readOptions = {
-            hardlinks: options.hardlinks,
-            symlinks: options.symlinks,
-        };
-        // Leave maxBytes absent when the caller omits it so Root's own default
-        // cap remains in force instead of being overwritten by undefined.
-        if (maxBytes !== undefined) {
-            readOptions.maxBytes = maxBytes;
+        try {
+            const result = await scopedRoot.readAbsolute(requestedPath, readOptions);
+            return { ...result, root: scopedRoot.rootReal };
         }
-        // A trusted root symlink has two valid spellings. Preserve the caller's
-        // lexical spelling when possible so Root.read() still enforces its
-        // symlink policy, while also accepting a path expressed below rootReal.
-        const relativePaths = [scopedRoot.rootDir, scopedRoot.rootReal]
-            .filter((rootPath, index, roots) => roots.indexOf(rootPath) === index)
-            .filter((rootPath) => isPathInside(rootPath, requestedPath))
-            .map((rootPath) => path.relative(rootPath, requestedPath))
-            .filter(Boolean);
-        for (const relativePath of relativePaths) {
-            try {
-                const result = await scopedRoot.read(relativePath, readOptions);
-                return { ...result, root: scopedRoot.rootReal };
-            }
-            catch {
-                // Try the canonical spelling before moving to the next configured root.
-            }
+        catch {
+            // Root handles both trusted spellings; try the next configured root.
         }
     }
     return null;

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

@@ -7,4 +7,3 @@ export type FsSafeLockConfig = {
 };
 export declare function configureFsSafeLocks(config: Partial<FsSafeLockConfig>): void;
 export declare function getFsSafeLockConfig(): FsSafeLockConfig;
-//# sourceMappingURL=lock-config.d.ts.map