@openclaw/openshell-sandbox 2026.9.3 → 2026.9.5

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

@@ -1,12 +1,92 @@
 import fs from "node:fs";
 import path from "node:path";
-import { isNotFoundPathError } from "./path.js";
+import { FsSafeError } from "./errors.js";
+import { formatErrorDetail } from "./error-detail.js";
+import { isNotFoundPathError, isPathInside } from "./path.js";
+import { realpathSync } from "./realpath.js";
+import { assertNoWindowsPathAlias, pathForWindowsFilesystem, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
+import { admitPathInsideRoot } from "./root-boundary.js";
+export function absolutePathWithRawSegments(candidate) {
+    if (path.sep !== "\\") {
+        if (path.isAbsolute(candidate))
+            return candidate;
+        const base = process.cwd();
+        return `${base}${base.endsWith(path.sep) ? "" : path.sep}${candidate}`;
+    }
+    const raw = path.sep === "\\" ? candidate.replaceAll("/", "\\") : candidate;
+    const absolute = path.isAbsolute(raw);
+    if (absolute && raw[0] !== "\\")
+        return raw;
+    const drive = path.parse(raw).root;
+    if (absolute && drive !== "\\")
+        return raw;
+    const base = drive ? path.resolve(drive) : process.cwd();
+    return `${base}${base.endsWith(path.sep) ? "" : path.sep}${raw.slice(drive.length)}`;
+}
+export function rawPathRelativeToCanonicalRoot(candidate, rootCanonicalPath, options = {}) {
+    assertNoWindowsPathAlias(candidate);
+    assertNoWindowsPathAlias(rootCanonicalPath);
+    const absolute = absolutePathWithRawSegments(candidate);
+    const raw = process.platform === "win32" ? absolute.replaceAll("/", path.sep) : absolute;
+    const filesystemRoot = path.parse(raw).root;
+    const segments = raw.slice(filesystemRoot.length).split(path.sep);
+    const finalComponentIndex = segments.findLastIndex(segment => segment !== "" && segment !== ".");
+    let prefix = filesystemRoot;
+    let traversedSymlink = false;
+    const identityCache = process.platform === "win32" ? new Map() : undefined;
+    for (let index = 0; index < segments.length; index += 1) {
+        prefix += `${prefix.endsWith(path.sep) ? "" : path.sep}${segments[index]}`;
+        let canonical;
+        let isSymlink = false;
+        try {
+            const operationPath = pathForWindowsFilesystem(prefix);
+            const stat = fs.lstatSync(operationPath);
+            isSymlink = stat.isSymbolicLink();
+            // Check the original leaf before canonicalization can erase an entry alias.
+            if (isSymlink && options.rejectFinalSymlink && index === finalComponentIndex) {
+                throw new FsSafeError("symlink", "final symlink not allowed");
+            }
+            if (!isSymlink && !stat.isDirectory() && index < segments.length - 1)
+                return undefined;
+            traversedSymlink ||= isSymlink;
+            canonical = realpathSync.native(operationPath);
+            assertNoWindowsPathAlias(canonical);
+            if (isSymlink && index < segments.length - 1 &&
+                !fs.statSync(pathForWindowsFilesystem(canonical)).isDirectory())
+                return undefined;
+            if (isSymlink && !isPathInside(rootCanonicalPath, canonical) && !isPathInside(canonical, rootCanonicalPath)) {
+                throw new FsSafeError("outside-workspace", `symlink prefix resolves outside the root ancestry: ${formatErrorDetail(candidate)}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof FsSafeError)
+                throw error;
+            if (isSymlink)
+                return undefined;
+            continue;
+        }
+        const admitted = admitPathInsideRoot({
+            rootPath: rootCanonicalPath,
+            candidatePath: canonical,
+            rootIdentity: options.rootIdentity,
+            identityCache,
+        });
+        if (!admitted)
+            continue;
+        if (options.rejectSymlinks && traversedSymlink) {
+            throw new FsSafeError("symlink", "symlink path component not allowed");
+        }
+        return [admitted.relativePath, ...segments.slice(index + 1)]
+            .filter(Boolean).join(path.sep);
+    }
+    return undefined;
+}
 function isFilesystemRoot(candidate) {
     return path.parse(candidate).root === candidate;
 }
 async function pathExists(targetPath) {
     try {
-        fs.lstatSync(targetPath);
+        fs.lstatSync(pathForWindowsFilesystem(targetPath));
         return true;
     }
     catch (error) {
@@ -17,7 +97,9 @@ async function pathExists(targetPath) {
     }
 }
 export async function resolvePathViaExistingAncestor(targetPath) {
-    const normalized = path.resolve(targetPath);
+    assertNoWindowsPathAlias(targetPath);
+    const normalized = resolvePathPreservingWindowsRoot(targetPath);
+    assertNoWindowsPathAlias(normalized);
     let cursor = normalized;
     const missingSuffix = [];
     while (!isFilesystemRoot(cursor) && !(await pathExists(cursor))) {
@@ -31,21 +113,30 @@ export async function resolvePathViaExistingAncestor(targetPath) {
     if (!(await pathExists(cursor))) {
         return normalized;
     }
+    let rawResolvedAncestor;
     try {
-        const resolvedAncestor = path.resolve(fs.realpathSync.native(cursor));
-        return missingSuffix.length === 0
-            ? resolvedAncestor
-            : path.resolve(resolvedAncestor, ...missingSuffix);
+        rawResolvedAncestor = realpathSync.native(pathForWindowsFilesystem(cursor));
     }
     catch {
         return normalized;
     }
+    assertNoWindowsPathAlias(rawResolvedAncestor);
+    const resolvedAncestor = resolvePathPreservingWindowsRoot(rawResolvedAncestor);
+    assertNoWindowsPathAlias(resolvedAncestor);
+    const resolved = missingSuffix.length === 0
+        ? resolvedAncestor
+        : path.resolve(resolvedAncestor, ...missingSuffix);
+    assertNoWindowsPathAlias(resolved);
+    return resolved;
 }
 export function resolvePathViaExistingAncestorSync(targetPath) {
-    const normalized = path.resolve(targetPath);
+    assertNoWindowsPathAlias(targetPath);
+    const normalized = resolvePathPreservingWindowsRoot(targetPath);
+    assertNoWindowsPathAlias(normalized);
     let cursor = normalized;
     const missingSuffix = [];
-    while (!isFilesystemRoot(cursor) && !fs.existsSync(cursor)) {
+    while (!isFilesystemRoot(cursor) &&
+        !fs.existsSync(pathForWindowsFilesystem(cursor))) {
         missingSuffix.unshift(path.basename(cursor));
         const parent = path.dirname(cursor);
         if (parent === cursor) {
@@ -53,16 +144,22 @@ export function resolvePathViaExistingAncestorSync(targetPath) {
         }
         cursor = parent;
     }
-    if (!fs.existsSync(cursor)) {
+    if (!fs.existsSync(pathForWindowsFilesystem(cursor))) {
         return normalized;
     }
+    let rawResolvedAncestor;
     try {
-        const resolvedAncestor = path.resolve(fs.realpathSync(cursor));
-        return missingSuffix.length === 0
-            ? resolvedAncestor
-            : path.resolve(resolvedAncestor, ...missingSuffix);
+        rawResolvedAncestor = realpathSync(pathForWindowsFilesystem(cursor));
     }
     catch {
         return normalized;
     }
+    assertNoWindowsPathAlias(rawResolvedAncestor);
+    const resolvedAncestor = resolvePathPreservingWindowsRoot(rawResolvedAncestor);
+    assertNoWindowsPathAlias(resolvedAncestor);
+    const resolved = missingSuffix.length === 0
+        ? resolvedAncestor
+        : path.resolve(resolvedAncestor, ...missingSuffix);
+    assertNoWindowsPathAlias(resolved);
+    return resolved;
 }

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

@@ -0,0 +1,63 @@
+import fs, { type BigIntStats } from "node:fs";
+import { type DirectoryObservationGuard } from "./directory-guard.js";
+import { type NativeDirectoryObservationBackend, type NativeDirectoryObservationGuard } from "./native-directory-observation.js";
+import { type RootBoundaryIdentity } from "./root-boundary.js";
+import { type StatObservationReceipt } from "./stat-observation.js";
+export type RootPathObservationKind = "stat" | "directory";
+export type RootPathDirectoryObservationGuard = DirectoryObservationGuard | NativeDirectoryObservationGuard;
+export type RootPathTargetObservation = StatObservationReceipt | NativeDirectoryObservationGuard;
+/** An exact receipt owned by one stat/list operation. Never cache it. */
+export type RootPathObservationReceipt = {
+    kind: RootPathObservationKind;
+    rootGuard: DirectoryObservationGuard;
+    directoryGuard: RootPathDirectoryObservationGuard;
+    directoryObserver?: NativeDirectoryObservationBackend;
+    targetPath: string;
+    target: RootPathTargetObservation;
+};
+/** A failed initial target lookup must not discard its already admitted parent. */
+export type RootPathParentObservationReceipt = Omit<RootPathObservationReceipt, "kind" | "target"> & {
+    kind: "stat-parent";
+};
+export type RootPathObservationRequest = {
+    kind: RootPathObservationKind;
+    rootGuard: DirectoryObservationGuard;
+    directoryObserver?: NativeDirectoryObservationBackend;
+};
+export type RootPathTraversalObservation = {
+    enabled: boolean;
+    request: RootPathObservationRequest;
+    targetIndex: number;
+    directoryIndex: number;
+    directoryGuard?: RootPathDirectoryObservationGuard;
+    directoryObserver?: NativeDirectoryObservationBackend;
+    targetPath?: string;
+    target?: RootPathTargetObservation;
+};
+export type RootPathObservedTraversalEntry = StatObservationReceipt | {
+    stat: fs.Stats | BigIntStats;
+    identity?: undefined;
+} | NativeDirectoryObservationGuard;
+export declare class RootPathObservationError extends Error {
+    readonly error: unknown;
+    readonly parentReceipt?: RootPathParentObservationReceipt | undefined;
+    readonly traversalFailure: boolean;
+    constructor(error: unknown, parentReceipt?: RootPathParentObservationReceipt | undefined, traversalFailure?: boolean);
+}
+export type RootPathTraversalContext = {
+    observationEligible: boolean;
+    rootPath: string;
+    rootCanonicalPath: string;
+    resolveParams: {
+        rootIdentity?: RootBoundaryIdentity;
+    };
+    state: {
+        finalComponentIndex: number;
+        relativePath: string;
+        segments: string[];
+    };
+};
+export declare function createRootPathTraversalObservation(context: RootPathTraversalContext, request?: RootPathObservationRequest): RootPathTraversalObservation | undefined;
+export declare function inspectRootPathTraversalEntry(pathname: string, directorySlot: boolean, observation: RootPathTraversalObservation): RootPathObservedTraversalEntry;
+export declare function captureRootPathObservedDirectory(observation: RootPathTraversalObservation, observed: RootPathObservedTraversalEntry, publicPath: string, canonicalPath: string, rootCanonicalPath: string, rootIdentity?: RootBoundaryIdentity): boolean;
+//# sourceMappingURL=root-path-observation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"root-path-observation.d.ts","sourceRoot":"","sources":["../src/root-path-observation.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,180 @@
+import fs, {} from "node:fs";
+import { extendDirectoryObservationGuard, } from "./directory-guard.js";
+import { FsSafeError } from "./errors.js";
+import { extendNativeDirectoryObservationGuard, inspectNativeDirectoryObservation, isNativeDirectoryObservationGuard, } from "./native-directory-observation.js";
+import { admitPathInsideRoot, } from "./root-boundary.js";
+import { realpathSync } from "./realpath.js";
+import { inspectStatObservationSync } from "./stat-observation.js";
+// Observation-only failures happen after ordinary traversal has admitted the
+// name. Keep them distinguishable so Root preserves existing error precedence.
+export class RootPathObservationError extends Error {
+    error;
+    parentReceipt;
+    traversalFailure;
+    constructor(error, parentReceipt, traversalFailure = false) {
+        super("root path observation failed", { cause: error });
+        this.error = error;
+        this.parentReceipt = parentReceipt;
+        this.traversalFailure = traversalFailure;
+        this.name = "RootPathObservationError";
+    }
+}
+function straightTraversalPath(value) {
+    if (value.length === 0)
+        return false;
+    const windows = process.platform === "win32";
+    let segmentStart = 0;
+    for (let index = 0; index <= value.length; index += 1) {
+        const separator = index === value.length || value[index] === "/" ||
+            (windows && value[index] === "\\");
+        if (!separator)
+            continue;
+        const segmentLength = index - segmentStart;
+        if (segmentLength === 0 ||
+            (segmentLength === 1 && value.charCodeAt(segmentStart) === 0x2e) ||
+            (segmentLength === 2 && value.charCodeAt(segmentStart) === 0x2e &&
+                value.charCodeAt(segmentStart + 1) === 0x2e))
+            return false;
+        segmentStart = index + 1;
+    }
+    return true;
+}
+export function createRootPathTraversalObservation(context, request) {
+    const { state } = context;
+    const rootTraversal = state.finalComponentIndex < 0 &&
+        (state.relativePath === "" || state.relativePath === ".");
+    if (!request || !context.observationEligible ||
+        request.rootGuard.dir !== context.rootCanonicalPath ||
+        request.rootGuard.realPath !== context.rootCanonicalPath ||
+        context.rootPath !== context.rootCanonicalPath ||
+        (!rootTraversal && !straightTraversalPath(state.relativePath)) ||
+        (!rootTraversal && state.finalComponentIndex !== state.segments.length - 1))
+        return undefined;
+    if (state.finalComponentIndex >= 0) {
+        const directoryIndex = request.kind === "stat"
+            ? state.finalComponentIndex - 1
+            : state.finalComponentIndex;
+        return {
+            enabled: true,
+            request,
+            targetIndex: state.finalComponentIndex,
+            directoryIndex,
+            directoryGuard: directoryIndex < 0 ? request.rootGuard : undefined,
+            // A direct-child stat has no selected-directory slot at which the
+            // optional helper can establish a receipt. Keep its final Root fence on
+            // the established JavaScript path so helper unavailability cannot first
+            // appear after the target has been admitted.
+            directoryObserver: directoryIndex < 0 ? undefined : request.directoryObserver,
+        };
+    }
+    if (!rootTraversal)
+        return undefined;
+    let directoryGuard = request.rootGuard;
+    // Root-only stat likewise has no pre-admission helper observation. Root
+    // listing below does establish one and may safely retain the backend.
+    let directoryObserver = request.kind === "stat" ? undefined : request.directoryObserver;
+    if (request.kind === "directory") {
+        if (directoryObserver) {
+            try {
+                const observed = inspectNativeDirectoryObservation(directoryObserver, request.rootGuard.dir, request.rootGuard.identity);
+                const admitted = admitPathInsideRoot({
+                    rootPath: context.rootCanonicalPath,
+                    candidatePath: observed.realPath,
+                    rootIdentity: context.resolveParams.rootIdentity,
+                });
+                if (!admitted || admitted.relativePath !== "") {
+                    throw new FsSafeError("path-mismatch", "root path changed during operation");
+                }
+                observed.realPath = admitted.path;
+                directoryGuard = extendNativeDirectoryObservationGuard(observed, request.rootGuard.dir);
+            }
+            catch (error) {
+                if (error instanceof FsSafeError && error.code === "path-mismatch") {
+                    throw new RootPathObservationError(error);
+                }
+                directoryObserver = undefined;
+            }
+        }
+        if (!directoryObserver) {
+            try {
+                const admitted = admitPathInsideRoot({
+                    rootPath: context.rootCanonicalPath,
+                    candidatePath: realpathSync.native(request.rootGuard.dir),
+                    rootIdentity: context.resolveParams.rootIdentity,
+                });
+                if (!admitted || admitted.relativePath !== "") {
+                    throw new FsSafeError("path-mismatch", "root path changed during operation");
+                }
+            }
+            catch (error) {
+                throw new RootPathObservationError(error);
+            }
+        }
+    }
+    return {
+        enabled: true,
+        request,
+        targetIndex: -1,
+        directoryIndex: -1,
+        directoryGuard,
+        directoryObserver,
+        targetPath: context.rootCanonicalPath,
+        target: directoryGuard,
+    };
+}
+export function inspectRootPathTraversalEntry(pathname, directorySlot, observation) {
+    if (directorySlot && observation.directoryObserver) {
+        try {
+            return extendNativeDirectoryObservationGuard(inspectNativeDirectoryObservation(observation.directoryObserver, pathname), pathname);
+        }
+        catch {
+            // This directory has not been admitted yet. Preserve the established
+            // resolver and error ordering when the optional observation is unusable.
+            observation.directoryObserver = undefined;
+        }
+    }
+    const first = process.platform === "win32"
+        ? fs.lstatSync(pathname, { bigint: true }) : fs.lstatSync(pathname);
+    if (first.isSymbolicLink() || (directorySlot && !first.isDirectory()))
+        return { stat: first };
+    try {
+        return inspectStatObservationSync(bigint => bigint
+            ? fs.lstatSync(pathname, { bigint: true }) : fs.lstatSync(pathname), undefined, first);
+    }
+    catch (error) {
+        if (error instanceof FsSafeError && error.code === "path-mismatch") {
+            throw new RootPathObservationError(error);
+        }
+        throw error;
+    }
+}
+export function captureRootPathObservedDirectory(observation, observed, publicPath, canonicalPath, rootCanonicalPath, rootIdentity) {
+    if (!isNativeDirectoryObservationGuard(observed) && !observed.stat.isDirectory())
+        return false;
+    let realPath;
+    try {
+        realPath = isNativeDirectoryObservationGuard(observed)
+            ? observed.realPath
+            : realpathSync.native(canonicalPath);
+    }
+    catch (error) {
+        throw new RootPathObservationError(error);
+    }
+    const admitted = admitPathInsideRoot({
+        rootPath: rootCanonicalPath,
+        candidatePath: realPath,
+        rootIdentity,
+    });
+    if (!admitted) {
+        throw new RootPathObservationError(new FsSafeError("outside-workspace", "directory is outside workspace root"));
+    }
+    if (isNativeDirectoryObservationGuard(observed)) {
+        observed.dir = publicPath;
+        observed.realPath = admitted.path;
+        observation.directoryGuard = observed;
+    }
+    else {
+        observation.directoryGuard = extendDirectoryObservationGuard(observed, publicPath, admitted.path);
+    }
+    return true;
+}

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

@@ -0,0 +1,5 @@
+import type { RootContext } from "./root-context.js";
+import type { RootPathObservationReceipt } from "./root-path.js";
+import type { PathStat } from "./types.js";
+export declare function statResolvedPathInRoot(root: RootContext, resolvedPath: string, receipt?: RootPathObservationReceipt): Promise<PathStat>;
+//# sourceMappingURL=root-path-stat.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/root-path-stat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-path-stat.d.ts","sourceRoot":"","sources":["../src/root-path-stat.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AAIjE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAwB3C,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,WAAW,EACjB,YAAY,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE,0BAA0B,GACnC,OAAO,CAAC,QAAQ,CAAC,CA8EnB"}

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

@@ -0,0 +1,101 @@
+import fsSync from "node:fs";
+import path from "node:path";
+import { FsSafeError } from "./errors.js";
+import { recordFileObservationFailure } from "./file-observation.js";
+import { hasNodeErrorCode, isNotFoundPathError } from "./path.js";
+import { assertRootDirectoryObservationGuard, assertRootPathObservationReceiptCurrent, createRootDirectoryObservationGuard, pathStatFromStats, } from "./root-directory-list.js";
+import { fileNotFoundError } from "./root-errors.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
+import { assertStatObservationSync } from "./stat-observation.js";
+import { getFsSafeTestHooks } from "./test-hooks.js";
+async function missingObservedFileError(cause, pathname, before, assertParents) {
+    const failure = new FsSafeError("path-mismatch", "file changed during operation", {
+        cause: cause instanceof Error ? cause : undefined,
+    });
+    if (hasNodeErrorCode(cause, "ENOENT") && before?.isFile() && !before.isSymbolicLink() &&
+        (before.nlink === 1 || before.nlink === 1n)) {
+        try {
+            await assertParents();
+            // Metadata loss permits discarding a probe, never reading or owning a file.
+            recordFileObservationFailure(failure, `stat-leaf-missing:${pathname}`);
+        }
+        catch {
+            // Keep the public mismatch and withhold provenance when ancestry changed.
+        }
+    }
+    return failure;
+}
+export async function statResolvedPathInRoot(root, resolvedPath, receipt) {
+    let admittedTarget = false;
+    try {
+        if (receipt) {
+            if (receipt.kind !== "stat" || receipt.targetPath !== resolvedPath) {
+                throw new FsSafeError("path-mismatch", "file observation receipt does not match target");
+            }
+            admittedTarget = true;
+            const beforeObservation = getFsSafeTestHooks()?.beforeRootStatObservation;
+            if (beforeObservation)
+                await beforeObservation(resolvedPath);
+            let observed;
+            try {
+                observed = assertStatObservationSync(bigint => bigint ? fsSync.lstatSync(resolvedPath, { bigint: true }) : fsSync.lstatSync(resolvedPath), receipt.target.identity);
+            }
+            catch (error) {
+                if (isNotFoundPathError(error)) {
+                    throw await missingObservedFileError(error, resolvedPath, "stat" in receipt.target ? receipt.target.stat : undefined, () => assertRootPathObservationReceiptCurrent(root, receipt));
+                }
+                throw error;
+            }
+            if (observed.isSymbolicLink()) {
+                throw new FsSafeError("path-mismatch", "file changed during operation");
+            }
+            assertRootPathObservationReceiptCurrent(root, receipt, observed);
+            return pathStatFromStats(observed);
+        }
+        const guardPath = resolvedPath === root.rootReal ? root.rootReal : path.dirname(resolvedPath);
+        const parentGuard = guardPath === root.rootReal && root.rootGuard
+            ? root.rootGuard
+            : await createRootDirectoryObservationGuard(root, guardPath);
+        let expected;
+        try {
+            const beforeInitialObservation = getFsSafeTestHooks()?.beforeRootStatInitialObservation;
+            if (beforeInitialObservation)
+                await beforeInitialObservation(resolvedPath);
+            expected = inspectFileIdentitySync(() => fsSync.lstatSync(resolvedPath, { bigint: true }));
+            if (expected.isSymbolicLink()) {
+                throw new FsSafeError("path-mismatch", "file changed during operation");
+            }
+        }
+        catch (error) {
+            // No initial target error is safe to expose until the admitted parent is
+            // proven current; a redirect must win over an ordinary lookup failure.
+            await assertRootDirectoryObservationGuard(root, parentGuard);
+            throw error;
+        }
+        admittedTarget = true;
+        const beforeObservation = getFsSafeTestHooks()?.beforeRootStatObservation;
+        if (beforeObservation)
+            await beforeObservation(resolvedPath);
+        let observed;
+        try {
+            observed = inspectFileIdentitySync(() => fsSync.lstatSync(resolvedPath, { bigint: true }), expected);
+        }
+        catch (error) {
+            if (isNotFoundPathError(error)) {
+                throw await missingObservedFileError(error, resolvedPath, expected, () => assertRootDirectoryObservationGuard(root, parentGuard));
+            }
+            throw error;
+        }
+        if (observed.isSymbolicLink()) {
+            throw new FsSafeError("path-mismatch", "file changed during operation");
+        }
+        await assertRootDirectoryObservationGuard(root, parentGuard);
+        return pathStatFromStats(observed);
+    }
+    catch (error) {
+        if (!admittedTarget && isNotFoundPathError(error)) {
+            throw fileNotFoundError(error instanceof Error ? error : undefined);
+        }
+        throw error;
+    }
+}

package/node_modules/@openclaw/fs-safe/dist/root-path-symlink.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"root-path-symlink.d.ts","sourceRoot":"","sources":["../src/root-path-symlink.ts"],"names":[],"mappings":"AASA,KAAK,wBAAwB,GAAG;IAC9B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAiBF,wBAAsB,qBAAqB,CACzC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,MAAM,CAAC,CAQjB;AAED,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,wBAA6B,GACrC,MAAM,CAQR"}
+{"version":3,"file":"root-path-symlink.d.ts","sourceRoot":"","sources":["../src/root-path-symlink.ts"],"names":[],"mappings":"AAeA,KAAK,wBAAwB,GAAG;IAC9B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAsBF,wBAAsB,qBAAqB,CACzC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,MAAM,CAAC,CAejB;AAED,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,wBAA6B,GACrC,MAAM,CAeR"}

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

@@ -2,7 +2,9 @@ import fs from "node:fs";
 import path from "node:path";
 import { FsSafeError } from "./errors.js";
 import { isNotFoundPathError, isSymlinkOpenError } from "./path.js";
+import { realpathSync } from "./realpath.js";
 import { resolvePathViaExistingAncestor, resolvePathViaExistingAncestorSync, } from "./root-path-existing.js";
+import { assertNoWindowsPathAlias, resolvePathFromBasePreservingWindowsRoot, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
 function normalizeSymlinkResolutionError(error, options) {
     if (isSymlinkOpenError(error) ||
         (options.rejectUnresolved && isNotFoundPathError(error))) {
@@ -13,23 +15,41 @@ function normalizeSymlinkResolutionError(error, options) {
     if (!isNotFoundPathError(error))
         throw error;
 }
+function resolveSymlinkTargetPath(symlinkPath, linkTarget) {
+    const linkDir = resolvePathPreservingWindowsRoot(path.dirname(symlinkPath));
+    return resolvePathFromBasePreservingWindowsRoot(linkDir, linkTarget);
+}
 export async function resolveSymlinkHopPath(symlinkPath, options = {}) {
     try {
-        return path.resolve(fs.realpathSync.native(symlinkPath));
+        const rawRealPath = realpathSync.native(symlinkPath);
+        assertNoWindowsPathAlias(rawRealPath, "filesystem", "resolved symlink path uses a Windows filesystem namespace alias");
+        const realPath = resolvePathPreservingWindowsRoot(rawRealPath);
+        assertNoWindowsPathAlias(realPath, "filesystem", "resolved symlink path uses a Windows filesystem namespace alias");
+        return realPath;
     }
     catch (error) {
         normalizeSymlinkResolutionError(error, options);
         const linkTarget = fs.readlinkSync(symlinkPath);
-        return resolvePathViaExistingAncestor(path.resolve(path.dirname(symlinkPath), linkTarget));
+        assertNoWindowsPathAlias(linkTarget, "filesystem", "symlink target uses a Windows filesystem namespace alias");
+        const resolved = await resolvePathViaExistingAncestor(resolveSymlinkTargetPath(symlinkPath, linkTarget));
+        assertNoWindowsPathAlias(resolved, "filesystem", "resolved symlink path uses a Windows filesystem namespace alias");
+        return resolved;
     }
 }
 export function resolveSymlinkHopPathSync(symlinkPath, options = {}) {
     try {
-        return path.resolve(fs.realpathSync(symlinkPath));
+        const rawRealPath = realpathSync(symlinkPath);
+        assertNoWindowsPathAlias(rawRealPath, "filesystem", "resolved symlink path uses a Windows filesystem namespace alias");
+        const realPath = resolvePathPreservingWindowsRoot(rawRealPath);
+        assertNoWindowsPathAlias(realPath, "filesystem", "resolved symlink path uses a Windows filesystem namespace alias");
+        return realPath;
     }
     catch (error) {
         normalizeSymlinkResolutionError(error, options);
         const linkTarget = fs.readlinkSync(symlinkPath);
-        return resolvePathViaExistingAncestorSync(path.resolve(path.dirname(symlinkPath), linkTarget));
+        assertNoWindowsPathAlias(linkTarget, "filesystem", "symlink target uses a Windows filesystem namespace alias");
+        const resolved = resolvePathViaExistingAncestorSync(resolveSymlinkTargetPath(symlinkPath, linkTarget));
+        assertNoWindowsPathAlias(resolved, "filesystem", "resolved symlink path uses a Windows filesystem namespace alias");
+        return resolved;
     }
 }

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

@@ -1,4 +1,8 @@
+import { type RootBoundaryIdentity } from "./root-boundary.js";
+import { type RootPathObservationReceipt, type RootPathObservationRequest } from "./root-path-observation.js";
+import type { RemovalPathReceipts } from "./root-remove-receipt.js";
 export { resolvePathViaExistingAncestorSync } from "./root-path-existing.js";
+export { RootPathObservationError, type RootPathDirectoryObservationGuard, type RootPathObservationKind, type RootPathObservationReceipt, type RootPathParentObservationReceipt, type RootPathObservationRequest, type RootPathTargetObservation, } from "./root-path-observation.js";
 type RootPathIntent = "read" | "write" | "create" | "delete" | "stat";
 export type RootPathAliasPolicy = {
     allowFinalSymlinkForUnlink?: boolean;
@@ -21,9 +25,11 @@ type ResolveRootPathParams = {
     intent?: RootPathIntent;
     policy?: RootPathAliasPolicy;
     rejectSymlinks?: boolean;
+    rejectFinalSymlink?: boolean;
     rejectUnresolvedSymlinks?: boolean;
     skipLexicalRootCheck?: boolean;
     rootCanonicalPath?: string;
+    rootIdentity?: RootBoundaryIdentity;
 };
 type ResolvedRootPathKind = "missing" | "file" | "directory" | "symlink" | "other";
 export type ResolvedRootPath = {
@@ -35,6 +41,14 @@ export type ResolvedRootPath = {
     exists: boolean;
     kind: ResolvedRootPathKind;
 };
+export type ObservedRootPath = {
+    resolved: ResolvedRootPath;
+    receipt?: RootPathObservationReceipt;
+};
 export declare function resolveRootPath(params: ResolveRootPathParams): Promise<ResolvedRootPath>;
+export declare function resolveRootPathWithCanonicalRootObservation(params: ResolveRootPathParams, observeRoot: (rootCanonicalPath: string) => void): Promise<ResolvedRootPath>;
+export declare function resolveRootPathWithObservation(params: ResolveRootPathParams, request: RootPathObservationRequest): Promise<ObservedRootPath>;
+export declare function resolveRootPathForRemoval(params: ResolveRootPathParams, receipts: RemovalPathReceipts): Promise<ResolvedRootPath>;
 export declare function resolveRootPathSync(params: ResolveRootPathParams): ResolvedRootPath;
+export declare function resolveRootPathSyncWithCanonicalRootObservation(params: ResolveRootPathParams, observeRoot: (rootCanonicalPath: string) => void): ResolvedRootPath;
 //# sourceMappingURL=root-path.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"root-path.d.ts","sourceRoot":"","sources":["../src/root-path.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,kCAAkC,EAAE,MAAM,yBAAyB,CAAC;AAE7E,KAAK,cAAc,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEtE,MAAM,MAAM,mBAAmB,GAAG;IAChC,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACvC,CAAC;AAEF,eAAO,MAAM,wBAAwB;aACnC,MAAM;;;;aAIN,YAAY;;;;CAIJ,CAAC;AAEX,KAAK,qBAAqB,GAAG;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,KAAK,oBAAoB,GAAG,SAAS,GAAG,MAAM,GAAG,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC;AAEnF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,oBAAoB,CAAC;CAC5B,CAAC;AAEF,wBAAsB,eAAe,CACnC,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,gBAAgB,CAAC,CAM3B;AAsCD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,qBAAqB,GAAG,gBAAgB,CAMnF"}
+{"version":3,"file":"root-path.d.ts","sourceRoot":"","sources":["../src/root-path.ts"],"names":[],"mappings":"AAiBA,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAKL,KAAK,0BAA0B,EAE/B,KAAK,0BAA0B,EAEhC,MAAM,4BAA4B,CAAC;AAGpC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAQpE,OAAO,EAAE,kCAAkC,EAAE,MAAM,yBAAyB,CAAC;AAC7E,OAAO,EACL,wBAAwB,EACxB,KAAK,iCAAiC,EACtC,KAAK,uBAAuB,EAC5B,KAAK,0BAA0B,EAC/B,KAAK,gCAAgC,EACrC,KAAK,0BAA0B,EAC/B,KAAK,yBAAyB,GAC/B,MAAM,4BAA4B,CAAC;AAEpC,KAAK,cAAc,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEtE,MAAM,MAAM,mBAAmB,GAAG;IAChC,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACvC,CAAC;AAEF,eAAO,MAAM,wBAAwB;aACnC,MAAM;;;;aAIN,YAAY;;;;CAIJ,CAAC;AAEX,KAAK,qBAAqB,GAAG;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,YAAY,CAAC,EAAE,oBAAoB,CAAC;CACrC,CAAC;AAEF,KAAK,oBAAoB,GAAG,SAAS,GAAG,MAAM,GAAG,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC;AAEnF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,oBAAoB,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,OAAO,CAAC,EAAE,0BAA0B,CAAC;CACtC,CAAC;AAEF,wBAAsB,eAAe,CACnC,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,gBAAgB,CAAC,CAM3B;AAED,wBAAsB,2CAA2C,CAC/D,MAAM,EAAE,qBAAqB,EAC7B,WAAW,EAAE,CAAC,iBAAiB,EAAE,MAAM,KAAK,IAAI,GAC/C,OAAO,CAAC,gBAAgB,CAAC,CAM3B;AA4BD,wBAAsB,8BAA8B,CAClD,MAAM,EAAE,qBAAqB,EAC7B,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,gBAAgB,CAAC,CAQ3B;AAID,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,qBAAqB,EAC7B,QAAQ,EAAE,mBAAmB,GAC5B,OAAO,CAAC,gBAAgB,CAAC,CAM3B;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,qBAAqB,GAAG,gBAAgB,CAMnF;AAED,wBAAgB,+CAA+C,CAC7D,MAAM,EAAE,qBAAqB,EAC7B,WAAW,EAAE,CAAC,iBAAiB,EAAE,MAAM,KAAK,IAAI,GAC/C,gBAAgB,CAMlB"}