@openclaw/openshell-sandbox 2026.9.1 → 2026.9.3

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

@@ -0,0 +1,89 @@
+import { FsSafeError } from "./errors.js";
+type InvalidPathResult = {
+    ok: false;
+    error: string;
+};
+type DirectoryResult = {
+    ok: true;
+    path: string;
+} | {
+    ok: false;
+    error: string;
+    diagnostic?: FsSafeError;
+};
+type ResolvePathsWithinRootParams = {
+    rootDir: string;
+    requestedPaths: string[];
+    scopeLabel: string;
+};
+type ResolvePathsWithinRootResult = {
+    ok: true;
+    paths: string[];
+} | InvalidPathResult;
+export type PathScopeResolveOptions = {
+    defaultName?: string;
+};
+export type PathScopeOptions = {
+    label: string;
+};
+export type PathScope = {
+    rootDir: string;
+    label: string;
+    resolve(requestedPath: string, options?: PathScopeResolveOptions): {
+        ok: true;
+        path: string;
+    } | {
+        ok: false;
+        error: string;
+    };
+    resolveAll(requestedPaths: string[]): ResolvePathsWithinRootResult;
+    existing(requestedPaths: string[]): Promise<ResolvePathsWithinRootResult>;
+    files(requestedPaths: string[]): Promise<ResolvePathsWithinRootResult>;
+    writable(requestedPath: string, options?: PathScopeResolveOptions): Promise<{
+        ok: true;
+        path: string;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    ensureDir(requestedPath: string, options?: PathScopeResolveOptions & {
+        mode?: number;
+    }): Promise<DirectoryResult>;
+};
+export declare function resolvePathWithinRoot(params: {
+    rootDir: string;
+    requestedPath: string;
+    scopeLabel: string;
+    defaultFileName?: string;
+}): {
+    ok: true;
+    path: string;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function resolveWritablePathWithinRoot(params: {
+    rootDir: string;
+    requestedPath: string;
+    scopeLabel: string;
+    defaultFileName?: string;
+}): Promise<{
+    ok: true;
+    path: string;
+} | {
+    ok: false;
+    error: string;
+}>;
+export declare function ensureDirectoryWithinRoot(params: {
+    rootDir: string;
+    requestedPath: string;
+    scopeLabel: string;
+    defaultDirName?: string;
+    mode?: number;
+}): Promise<DirectoryResult>;
+export declare function resolvePathsWithinRoot(params: ResolvePathsWithinRootParams): ResolvePathsWithinRootResult;
+export declare function resolveExistingPathsWithinRoot(params: ResolvePathsWithinRootParams): Promise<ResolvePathsWithinRootResult>;
+export declare function resolveStrictExistingPathsWithinRoot(params: ResolvePathsWithinRootParams): Promise<ResolvePathsWithinRootResult>;
+export declare function pathScope(rootDir: string, options: PathScopeOptions): PathScope;
+export {};
+//# sourceMappingURL=root-paths.d.ts.map

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

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

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

@@ -0,0 +1,381 @@
+import fsSync from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { formatErrorDetail } from "./error-detail.js";
+import { FsSafeError } from "./errors.js";
+import { assertNoNulPathInput, hasNodeErrorCode, isNodeError, isNotFoundPathError, isPathInside, isPathRelativeEscape, } from "./path.js";
+import { root as openRoot } from "./root.js";
+function invalidPath(scopeLabel) {
+    return {
+        ok: false,
+        error: `Invalid path: must stay within ${scopeLabel}`,
+    };
+}
+function pathStaysWithinRoot(rootDir, candidatePath) {
+    const relative = path.relative(rootDir, candidatePath);
+    return Boolean(relative) && !isPathRelativeEscape(relative);
+}
+async function resolveRealPathIfExists(targetPath) {
+    try {
+        return fsSync.realpathSync.native(targetPath);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function resolveTrustedRootRealPath(rootDir) {
+    try {
+        const rootLstat = fsSync.lstatSync(rootDir);
+        if (!rootLstat.isDirectory() || rootLstat.isSymbolicLink()) {
+            return undefined;
+        }
+        return fsSync.realpathSync.native(rootDir);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function validateCanonicalPathWithinRoot(params) {
+    try {
+        const candidateLstat = fsSync.lstatSync(params.candidatePath);
+        if (candidateLstat.isSymbolicLink()) {
+            return "invalid";
+        }
+        if (params.expect === "directory" && !candidateLstat.isDirectory()) {
+            return "invalid";
+        }
+        if (params.expect === "file" && !candidateLstat.isFile()) {
+            return "invalid";
+        }
+        if (params.expect === "file" && candidateLstat.nlink > 1) {
+            return "invalid";
+        }
+        const candidateRealPath = fsSync.realpathSync.native(params.candidatePath);
+        return isPathInside(params.rootRealPath, candidateRealPath) ? "ok" : "invalid";
+    }
+    catch (err) {
+        return isNotFoundPathError(err) ? "not-found" : "invalid";
+    }
+}
+export function resolvePathWithinRoot(params) {
+    const root = path.resolve(params.rootDir);
+    const raw = params.requestedPath.trim();
+    if (!raw) {
+        if (!params.defaultFileName) {
+            return { ok: false, error: "path is required" };
+        }
+        const defaultPath = path.resolve(root, params.defaultFileName);
+        if (!pathStaysWithinRoot(root, defaultPath)) {
+            return { ok: false, error: `Invalid path: must stay within ${params.scopeLabel}` };
+        }
+        return { ok: true, path: defaultPath };
+    }
+    const resolved = path.resolve(root, raw);
+    if (!pathStaysWithinRoot(root, resolved)) {
+        return { ok: false, error: `Invalid path: must stay within ${params.scopeLabel}` };
+    }
+    return { ok: true, path: resolved };
+}
+export async function resolveWritablePathWithinRoot(params) {
+    const lexical = resolvePathWithinRoot(params);
+    if (!lexical.ok) {
+        return lexical;
+    }
+    const rootDir = path.resolve(params.rootDir);
+    const rootRealPath = await resolveTrustedRootRealPath(rootDir);
+    if (!rootRealPath) {
+        return invalidPath(params.scopeLabel);
+    }
+    const requestedPath = lexical.path;
+    const parentDir = path.dirname(requestedPath);
+    const parentStatus = await validateCanonicalPathWithinRoot({
+        rootRealPath,
+        candidatePath: parentDir,
+        expect: "directory",
+    });
+    if (parentStatus !== "ok") {
+        return invalidPath(params.scopeLabel);
+    }
+    const targetStatus = await validateCanonicalPathWithinRoot({
+        rootRealPath,
+        candidatePath: requestedPath,
+        expect: "file",
+    });
+    if (targetStatus === "invalid") {
+        return invalidPath(params.scopeLabel);
+    }
+    return lexical;
+}
+async function resolveNearestExistingPath(targetPath) {
+    let current = path.resolve(targetPath);
+    while (true) {
+        try {
+            fsSync.lstatSync(current);
+            return current;
+        }
+        catch (err) {
+            if (!isNotFoundPathError(err)) {
+                throw err;
+            }
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            throw new Error(`failed to resolve existing path for ${targetPath}`);
+        }
+        current = parent;
+    }
+}
+async function assertNoSymlinkSegments(params) {
+    const relative = path.relative(params.rootDir, params.targetPath);
+    if (isPathRelativeEscape(relative)) {
+        throw new FsSafeError("outside-workspace", `Invalid path: must stay within ${params.scopeLabel}`);
+    }
+    let current = params.rootDir;
+    for (const segment of relative.split(path.sep).filter(Boolean)) {
+        current = path.join(current, segment);
+        try {
+            const stat = fsSync.lstatSync(current);
+            if (stat.isSymbolicLink()) {
+                throw new FsSafeError("symlink", `Invalid path: must not traverse symlinks within ${params.scopeLabel}`);
+            }
+            if (!stat.isDirectory()) {
+                throw new FsSafeError("not-file", `Invalid path: existing segment must be a directory within ${params.scopeLabel}`);
+            }
+        }
+        catch (err) {
+            if (isNotFoundPathError(err)) {
+                return;
+            }
+            throw err;
+        }
+    }
+}
+export async function ensureDirectoryWithinRoot(params) {
+    const scopeLabel = formatErrorDetail(params.scopeLabel.slice(0, 80));
+    try {
+        assertNoNulPathInput(params.rootDir);
+        assertNoNulPathInput(params.requestedPath);
+        if (!params.requestedPath.trim())
+            assertNoNulPathInput(params.defaultDirName ?? "");
+        const lexical = resolvePathWithinRoot({
+            ...params, scopeLabel, defaultFileName: params.defaultDirName,
+        });
+        if (!lexical.ok)
+            return lexical;
+        const rootDir = path.resolve(params.rootDir);
+        const targetPath = lexical.path;
+        const rootStat = fsSync.lstatSync(rootDir);
+        if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) {
+            return invalidPath(scopeLabel);
+        }
+        await assertNoSymlinkSegments({ rootDir, targetPath, scopeLabel });
+        const rootReal = fsSync.realpathSync.native(rootDir);
+        const nearestExistingPath = await resolveNearestExistingPath(targetPath);
+        const nearestExistingReal = fsSync.realpathSync.native(nearestExistingPath);
+        if (!isPathInside(rootReal, nearestExistingReal)) {
+            return invalidPath(scopeLabel);
+        }
+        const relative = path.relative(rootDir, targetPath);
+        let current = rootDir;
+        for (const segment of relative.split(path.sep).filter(Boolean)) {
+            current = path.join(current, segment);
+            while (true) {
+                try {
+                    const stat = fsSync.lstatSync(current);
+                    if (stat.isSymbolicLink() || !stat.isDirectory()) {
+                        return invalidPath(scopeLabel);
+                    }
+                    break;
+                }
+                catch (err) {
+                    if (!isNotFoundPathError(err)) {
+                        throw err;
+                    }
+                    try {
+                        await fs.mkdir(current, { mode: params.mode });
+                    }
+                    catch (mkdirErr) {
+                        if (hasNodeErrorCode(mkdirErr, "EEXIST")) {
+                            continue;
+                        }
+                        throw mkdirErr;
+                    }
+                }
+            }
+            const currentReal = fsSync.realpathSync.native(current);
+            if (!isPathInside(rootReal, currentReal)) {
+                return invalidPath(scopeLabel);
+            }
+        }
+        const targetReal = fsSync.realpathSync.native(targetPath);
+        if (!isPathInside(rootReal, targetReal)) {
+            return invalidPath(scopeLabel);
+        }
+        return { ok: true, path: targetPath };
+    }
+    catch (cause) {
+        if ((cause instanceof FsSafeError && cause.category === "policy") ||
+            hasNodeErrorCode(cause, "ENOTDIR")) {
+            return invalidPath(scopeLabel);
+        }
+        // Native messages include unbounded paths; display only bounded errno metadata.
+        const code = isNodeError(cause) && typeof cause.code === "string"
+            ? formatErrorDetail(cause.code.slice(0, 40)) : "filesystem operation failed";
+        const syscall = isNodeError(cause) && typeof cause.syscall === "string"
+            ? ` during ${formatErrorDetail(cause.syscall.slice(0, 40))}` : "";
+        const diagnostic = new FsSafeError("helper-failed", `Could not prepare ${scopeLabel}: ${code}${syscall}`, { cause });
+        return { ok: false, error: diagnostic.message, diagnostic };
+    }
+}
+export function resolvePathsWithinRoot(params) {
+    const resolvedPaths = [];
+    for (const raw of params.requestedPaths) {
+        const pathResult = resolvePathWithinRoot({
+            rootDir: params.rootDir,
+            requestedPath: raw,
+            scopeLabel: params.scopeLabel,
+        });
+        if (!pathResult.ok) {
+            return { ok: false, error: pathResult.error };
+        }
+        resolvedPaths.push(pathResult.path);
+    }
+    return { ok: true, paths: resolvedPaths };
+}
+export async function resolveExistingPathsWithinRoot(params) {
+    return await resolveCheckedPathsWithinRoot(params, true);
+}
+export async function resolveStrictExistingPathsWithinRoot(params) {
+    return await resolveCheckedPathsWithinRoot(params, false);
+}
+export function pathScope(rootDir, options) {
+    const base = { rootDir, scopeLabel: options.label };
+    return {
+        rootDir,
+        label: options.label,
+        resolve: (requestedPath, pathOptions) => resolvePathWithinRoot({
+            ...base,
+            requestedPath,
+            defaultFileName: pathOptions?.defaultName,
+        }),
+        resolveAll: (requestedPaths) => resolvePathsWithinRoot({
+            ...base,
+            requestedPaths,
+        }),
+        existing: (requestedPaths) => resolveExistingPathsWithinRoot({
+            ...base,
+            requestedPaths,
+        }),
+        files: (requestedPaths) => resolveStrictExistingPathsWithinRoot({
+            ...base,
+            requestedPaths,
+        }),
+        writable: (requestedPath, pathOptions) => resolveWritablePathWithinRoot({
+            ...base,
+            requestedPath,
+            defaultFileName: pathOptions?.defaultName,
+        }),
+        ensureDir: (requestedPath, pathOptions) => ensureDirectoryWithinRoot({
+            ...base,
+            requestedPath,
+            defaultDirName: pathOptions?.defaultName,
+            mode: pathOptions?.mode,
+        }),
+    };
+}
+async function resolveCheckedPathsWithinRoot(params, allowMissingFallback) {
+    const rootDir = path.resolve(params.rootDir);
+    const rootRealPath = await resolveRealPathIfExists(rootDir);
+    const root = rootRealPath ? await openRoot(rootDir) : undefined;
+    const isInRoot = (relativePath) => Boolean(relativePath) &&
+        relativePath !== ".." &&
+        !relativePath.startsWith(`..${path.sep}`) &&
+        !path.isAbsolute(relativePath);
+    const resolveExistingRelativePath = async (requestedPath) => {
+        const raw = requestedPath.trim();
+        const lexicalPathResult = resolvePathWithinRoot({
+            rootDir,
+            requestedPath,
+            scopeLabel: params.scopeLabel,
+        });
+        if (lexicalPathResult.ok) {
+            return {
+                ok: true,
+                relativePath: path.relative(rootDir, lexicalPathResult.path),
+                fallbackPath: lexicalPathResult.path,
+            };
+        }
+        if (!rootRealPath || !raw || !path.isAbsolute(raw)) {
+            return lexicalPathResult;
+        }
+        try {
+            const resolvedExistingPath = fsSync.realpathSync.native(raw);
+            const relativePath = path.relative(rootRealPath, resolvedExistingPath);
+            if (!isInRoot(relativePath)) {
+                return lexicalPathResult;
+            }
+            return {
+                ok: true,
+                relativePath,
+                fallbackPath: resolvedExistingPath,
+            };
+        }
+        catch {
+            return lexicalPathResult;
+        }
+    };
+    const resolvedPaths = [];
+    for (const raw of params.requestedPaths) {
+        const pathResult = await resolveExistingRelativePath(raw);
+        if (!pathResult.ok) {
+            return { ok: false, error: pathResult.error };
+        }
+        let opened;
+        try {
+            if (!root) {
+                throw new FsSafeError("not-found", "root dir not found");
+            }
+            opened = await root.open(pathResult.relativePath);
+            resolvedPaths.push(opened.realPath);
+        }
+        catch (err) {
+            if (allowMissingFallback && err instanceof FsSafeError && err.code === "not-found") {
+                if (!rootRealPath) {
+                    resolvedPaths.push(pathResult.fallbackPath);
+                    continue;
+                }
+                try {
+                    await assertNoSymlinkSegments({
+                        rootDir,
+                        targetPath: pathResult.fallbackPath,
+                        scopeLabel: params.scopeLabel,
+                    });
+                    const existingPath = await resolveNearestExistingPath(pathResult.fallbackPath);
+                    const existingRealPath = fsSync.realpathSync.native(existingPath);
+                    if (!isPathInside(rootRealPath, existingRealPath)) {
+                        return invalidPath(params.scopeLabel);
+                    }
+                }
+                catch {
+                    return invalidPath(params.scopeLabel);
+                }
+                resolvedPaths.push(pathResult.fallbackPath);
+                continue;
+            }
+            if (err instanceof FsSafeError && err.code === "outside-workspace") {
+                return {
+                    ok: false,
+                    error: `File is outside ${params.scopeLabel}`,
+                };
+            }
+            return {
+                ok: false,
+                error: `Invalid path: must stay within ${params.scopeLabel} and be a regular non-symlink file`,
+            };
+        }
+        finally {
+            await opened?.handle.close().catch(() => { });
+        }
+    }
+    return { ok: true, paths: resolvedPaths };
+}

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

@@ -0,0 +1,41 @@
+import type { DirEntry } from "./types.js";
+export type RootWalkSymlinkPolicy = "skip" | "follow-within-root";
+export type RootWalkLimitBehavior = "truncate" | "throw";
+export type RootWalkDirectoryErrorBehavior = "throw" | "skip-and-report";
+export type RootWalkEntryFilterResult = "include" | "skip" | "skip-subtree";
+export type RootWalkDataEntryKind = "file" | "directory" | "other";
+export type RootWalkEntryKind = RootWalkDataEntryKind | "directory-error" | "truncated";
+export type RootWalkDataEntry = {
+    relativePath: string;
+    kind: RootWalkDataEntryKind;
+    size: number;
+};
+export type RootWalkEntry = RootWalkDataEntry | {
+    relativePath: string;
+    kind: "truncated";
+    size: 0;
+} | {
+    relativePath: string;
+    kind: "directory-error";
+    size: 0;
+    error: unknown;
+};
+export type RootWalkEntryFilter = (entry: RootWalkDataEntry) => RootWalkEntryFilterResult;
+export type RootWalkOptions = {
+    maxDepth?: number;
+    maxEntries?: number;
+    symlinkPolicy: RootWalkSymlinkPolicy;
+    signal?: AbortSignal;
+    limitBehavior?: RootWalkLimitBehavior;
+    entryFilter?: RootWalkEntryFilter;
+    onDirectoryError?: RootWalkDirectoryErrorBehavior;
+};
+type RootWalkCapability = {
+    rootReal: string;
+    list(relativePath: string, options: {
+        withFileTypes: true;
+    }): Promise<DirEntry[]>;
+};
+export declare function walkRoot(root: RootWalkCapability, relativePath: string, options: RootWalkOptions): AsyncGenerator<RootWalkEntry>;
+export {};
+//# sourceMappingURL=root-walk.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"root-walk.d.ts","sourceRoot":"","sources":["../src/root-walk.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,oBAAoB,CAAC;AAClE,MAAM,MAAM,qBAAqB,GAAG,UAAU,GAAG,OAAO,CAAC;AACzD,MAAM,MAAM,8BAA8B,GAAG,OAAO,GAAG,iBAAiB,CAAC;AACzE,MAAM,MAAM,yBAAyB,GAAG,SAAS,GAAG,MAAM,GAAG,cAAc,CAAC;AAC5E,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,WAAW,GAAG,OAAO,CAAC;AACnE,MAAM,MAAM,iBAAiB,GAAG,qBAAqB,GAAG,iBAAiB,GAAG,WAAW,CAAC;AAExF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,qBAAqB,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,aAAa,GACrB,iBAAiB,GACjB;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,CAAC,CAAA;CAAE,GACpD;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,iBAAiB,CAAC;IAAC,IAAI,EAAE,CAAC,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAE/E,MAAM,MAAM,mBAAmB,GAAG,CAAC,KAAK,EAAE,iBAAiB,KAAK,yBAAyB,CAAC;AAE1F,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,qBAAqB,CAAC;IACrC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,aAAa,CAAC,EAAE,qBAAqB,CAAC;IACtC,WAAW,CAAC,EAAE,mBAAmB,CAAC;IAClC,gBAAgB,CAAC,EAAE,8BAA8B,CAAC;CACnD,CAAC;AAEF,KAAK,kBAAkB,GAAG;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,aAAa,EAAE,IAAI,CAAA;KAAE,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;CACnF,CAAC;AAqBF,wBAAuB,QAAQ,CAC7B,IAAI,EAAE,kBAAkB,EACxB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,eAAe,GACvB,cAAc,CAAC,aAAa,CAAC,CAyH/B"}

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

@@ -0,0 +1,133 @@
+import path from "node:path";
+import { FsSafeError } from "./errors.js";
+import { resolveRootPath } from "./root-path.js";
+function validateBudget(name, value) {
+    if (value === undefined)
+        return Number.POSITIVE_INFINITY;
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new RangeError(`${name} must be a non-negative safe integer`);
+    }
+    return value;
+}
+function entryKind(entry) {
+    if (entry.isSymbolicLink)
+        return "symlink";
+    if (entry.isDirectory)
+        return "directory";
+    if (entry.isFile)
+        return "file";
+    return "other";
+}
+function limitEntry(relativePath) {
+    return { relativePath, kind: "truncated", size: 0 };
+}
+export async function* walkRoot(root, relativePath, options) {
+    if (!["skip", "follow-within-root"].includes(options.symlinkPolicy)) {
+        throw new TypeError(`invalid root walk symlink policy: ${String(options.symlinkPolicy)}`);
+    }
+    if (options.limitBehavior !== undefined &&
+        !["truncate", "throw"].includes(options.limitBehavior)) {
+        throw new TypeError(`invalid root walk limit behavior: ${String(options.limitBehavior)}`);
+    }
+    if (options.onDirectoryError !== undefined &&
+        !["throw", "skip-and-report"].includes(options.onDirectoryError)) {
+        throw new TypeError(`invalid root walk directory error behavior: ${String(options.onDirectoryError)}`);
+    }
+    const maxDepth = validateBudget("maxDepth", options.maxDepth);
+    const maxEntries = validateBudget("maxEntries", options.maxEntries);
+    const visitedDirectories = new Set();
+    let examined = 0;
+    let truncated = false;
+    const onLimit = (atPath) => {
+        if ((options.limitBehavior ?? "truncate") === "throw") {
+            throw new FsSafeError("too-large", `root walk budget exceeded at ${atPath || "."}`);
+        }
+        truncated = true;
+        return limitEntry(atPath);
+    };
+    async function* visit(directory, depth) {
+        options.signal?.throwIfAborted();
+        let entries;
+        try {
+            const resolvedDirectory = await resolveRootPath({
+                absolutePath: path.resolve(root.rootReal, directory),
+                rootPath: root.rootReal,
+                rootCanonicalPath: root.rootReal,
+                boundaryLabel: "root walk",
+            });
+            if (!resolvedDirectory.exists || resolvedDirectory.kind !== "directory") {
+                throw new FsSafeError("not-file", `root walk path is not a directory: ${directory || "."}`);
+            }
+            if (visitedDirectories.has(resolvedDirectory.canonicalPath)) {
+                return;
+            }
+            visitedDirectories.add(resolvedDirectory.canonicalPath);
+            options.signal?.throwIfAborted();
+            const listingDirectory = path
+                .relative(root.rootReal, resolvedDirectory.canonicalPath)
+                .split(path.sep)
+                .join(path.posix.sep);
+            entries = await root.list(listingDirectory, { withFileTypes: true });
+        }
+        catch (error) {
+            // Cancellation is never a recoverable directory read failure.
+            options.signal?.throwIfAborted();
+            if ((options.onDirectoryError ?? "throw") === "throw")
+                throw error;
+            yield { relativePath: directory, kind: "directory-error", size: 0, error };
+            return;
+        }
+        options.signal?.throwIfAborted();
+        for (const entry of entries) {
+            options.signal?.throwIfAborted();
+            const child = directory
+                ? path.posix.join(directory.split(path.sep).join(path.posix.sep), entry.name)
+                : entry.name;
+            if (examined >= maxEntries) {
+                yield onLimit(child);
+                return;
+            }
+            examined += 1;
+            let kind = entryKind(entry);
+            let size = entry.size;
+            if (kind === "symlink") {
+                if (options.symlinkPolicy === "skip") {
+                    continue;
+                }
+                const resolved = await resolveRootPath({
+                    absolutePath: path.resolve(root.rootReal, child),
+                    rootPath: root.rootReal,
+                    rootCanonicalPath: root.rootReal,
+                    boundaryLabel: "root walk",
+                });
+                if (!resolved.exists) {
+                    continue;
+                }
+                kind = resolved.kind === "directory" ? "directory" : resolved.kind === "file" ? "file" : "other";
+                size = entry.size;
+            }
+            const walkEntry = { relativePath: child, kind, size };
+            const filterResult = options.entryFilter?.(walkEntry) ?? "include";
+            if (!["include", "skip", "skip-subtree"].includes(filterResult)) {
+                throw new TypeError(`invalid root walk entryFilter result: ${String(filterResult)}`);
+            }
+            if (filterResult === "include") {
+                yield walkEntry;
+            }
+            if (kind !== "directory") {
+                continue;
+            }
+            if (filterResult === "skip-subtree") {
+                continue;
+            }
+            if (depth >= maxDepth) {
+                yield onLimit(child);
+                return;
+            }
+            yield* visit(child, depth + 1);
+            if (truncated)
+                return;
+        }
+    }
+    yield* visit(relativePath, 0);
+}

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

@@ -0,0 +1,6 @@
+export declare function inheritWriteTargetMode(params: {
+    targetPath: string;
+    rootWithSep: string;
+    requestedMode?: number;
+}): Promise<number>;
+//# sourceMappingURL=root-write-mode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"root-write-mode.d.ts","sourceRoot":"","sources":["../src/root-write-mode.ts"],"names":[],"mappings":"AAUA,wBAAsB,sBAAsB,CAAC,MAAM,EAAE;IACnD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,GAAG,OAAO,CAAC,MAAM,CAAC,CAwClB"}