@openclaw/openshell-sandbox 2026.9.2 → 2026.9.4

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

@@ -0,0 +1,189 @@
+import syncFs from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { createByteLimitTransform } from "./bounded-read-stream.js";
+import { normalizeMaxBytes } from "./byte-budget.js";
+import { pipeline } from "node:stream/promises";
+import { assertSyncDirectoryGuard as assertDirectoryGuardSync, createSyncDirectoryGuard, } from "./directory-guard.js";
+import { FsSafeError } from "./errors.js";
+import { sameFileIdentity } from "./file-identity.js";
+import { isPathInside, isPathRelativeEscape } from "./path.js";
+import { resolveOpenedFileRealPathForHandle, root } from "./root.js";
+import { ensureTrailingSep } from "./root-context.js";
+import { RootHandle } from "./root-impl.js";
+import { prepareSecretFileWrite } from "./secret-file.js";
+import { resolveSecureTempRoot } from "./secure-temp-dir.js";
+function parentRelativePath(relativePath) {
+    const parent = path.posix.dirname(relativePath);
+    return parent === "." ? "" : parent;
+}
+export async function ensureParentInRoot(scopedRoot, relativePath, mode) {
+    const parent = parentRelativePath(relativePath);
+    if (!parent) {
+        return;
+    }
+    await scopedRoot.mkdir(parent);
+    await chmodDirectoryInRootBestEffort(scopedRoot, parent, mode).catch(() => undefined);
+}
+export async function openWritableStoreRoot(params) {
+    const maxBytes = normalizeMaxBytes(params.maxBytes);
+    await fs.mkdir(params.rootDir, { recursive: true, mode: params.dirMode });
+    await fs.chmod(params.rootDir, params.dirMode).catch(() => undefined);
+    return await root(params.rootDir, { hardlinks: "reject", maxBytes });
+}
+export async function openPrivateStoreLockRoot(params) {
+    const { parentGuard } = await prepareSecretFileWrite(params);
+    // Bind to the admitted parent, never resolve a replacement into a fresh capability.
+    return new RootHandle({
+        rootDir: parentGuard.dir,
+        rootReal: parentGuard.realPath,
+        rootWithSep: ensureTrailingSep(parentGuard.realPath),
+        rootIdentity: { dev: parentGuard.stat.dev, ino: parentGuard.stat.ino },
+    }, { hardlinks: "reject" });
+}
+async function chmodDirectoryInRootBestEffort(scopedRoot, relativePath, mode) {
+    const dirPath = await scopedRoot.resolve(relativePath);
+    const directoryFlag = "O_DIRECTORY" in syncFs.constants ? syncFs.constants.O_DIRECTORY : 0;
+    const noFollowFlag = process.platform !== "win32" && "O_NOFOLLOW" in syncFs.constants
+        ? syncFs.constants.O_NOFOLLOW
+        : 0;
+    const handle = await fs.open(dirPath, syncFs.constants.O_RDONLY | directoryFlag | noFollowFlag);
+    try {
+        const stat = syncFs.fstatSync(handle.fd);
+        if (!stat.isDirectory()) {
+            return;
+        }
+        const realPath = await resolveOpenedFileRealPathForHandle(handle, dirPath);
+        if (!isPathInside(scopedRoot.rootWithSep, realPath)) {
+            throw new FsSafeError("outside-workspace", "directory is outside store root");
+        }
+        await handle.chmod(mode).catch(() => undefined);
+    }
+    finally {
+        await handle.close().catch(() => undefined);
+    }
+}
+function createMaxBytesTransform(maxBytes) {
+    const limit = normalizeMaxBytes(maxBytes);
+    if (limit === undefined) {
+        return undefined;
+    }
+    return createByteLimitTransform(limit, () => new FsSafeError("too-large", `file exceeds maximum size of ${limit} bytes`));
+}
+export async function writeStreamToTempSource(params) {
+    const maxBytes = normalizeMaxBytes(params.maxBytes);
+    const tempRoot = resolveSecureTempRoot({
+        fallbackPrefix: "fs-safe-file-store",
+        unsafeFallbackLabel: "file store temp dir",
+        warn: () => undefined,
+    });
+    const dir = await fs.mkdtemp(path.join(tempRoot, "fs-safe-file-store-"));
+    const filePath = path.join(dir, "payload");
+    let handle = null;
+    let handleClosedByStream = false;
+    try {
+        handle = await fs.open(filePath, "wx", params.mode);
+        const writable = handle.createWriteStream();
+        writable.once("close", () => {
+            handleClosedByStream = true;
+        });
+        const limiter = createMaxBytesTransform(maxBytes);
+        if (limiter) {
+            await pipeline(params.stream, limiter, writable);
+        }
+        else {
+            await pipeline(params.stream, writable);
+        }
+        if (!handleClosedByStream) {
+            await handle.close().catch(() => undefined);
+        }
+        await fs.chmod(filePath, params.mode).catch(() => undefined);
+        return {
+            path: filePath,
+            cleanup: async () => {
+                await fs.rm(dir, { recursive: true, force: true }).catch(() => undefined);
+            },
+        };
+    }
+    catch (err) {
+        if (handle && !handleClosedByStream) {
+            await handle.close().catch(() => undefined);
+        }
+        await fs.rm(dir, { recursive: true, force: true }).catch(() => undefined);
+        throw err;
+    }
+}
+export function assertSyncDirectoryGuard(guard) {
+    try {
+        assertDirectoryGuardSync(guard);
+    }
+    catch (error) {
+        if (error instanceof FsSafeError && error.code === "path-mismatch") {
+            throw new FsSafeError("path-mismatch", "store directory changed during write", {
+                cause: error,
+            });
+        }
+        throw error;
+    }
+}
+function chmodDirectorySyncBestEffort(dir, mode) {
+    try {
+        syncFs.chmodSync(dir, mode);
+    }
+    catch {
+        // Best-effort on platforms that do not enforce POSIX modes.
+    }
+}
+export function ensureParentSync(params) {
+    return ensureStoreDirectorySync({
+        rootDir: params.rootDir,
+        targetDir: path.dirname(path.resolve(params.filePath)),
+        mode: params.mode,
+        messagePrefix: "store",
+    });
+}
+export function ensureStoreDirectorySync(params) {
+    const rootDir = path.resolve(params.rootDir);
+    const dir = path.resolve(params.targetDir);
+    const relative = path.relative(rootDir, dir);
+    if (isPathRelativeEscape(relative)) {
+        throw new FsSafeError("outside-workspace", "file path escapes store root");
+    }
+    syncFs.mkdirSync(rootDir, { recursive: true, mode: params.mode });
+    const rootStat = syncFs.lstatSync(rootDir);
+    if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) {
+        throw new FsSafeError("not-file", `${params.messagePrefix} root must be a directory: ${rootDir}`);
+    }
+    const rootReal = syncFs.realpathSync(rootDir);
+    chmodDirectorySyncBestEffort(rootDir, params.mode);
+    let current = rootDir;
+    for (const segment of path.relative(rootDir, dir).split(path.sep).filter(Boolean)) {
+        current = path.join(current, segment);
+        try {
+            const stat = syncFs.lstatSync(current);
+            if (stat.isSymbolicLink() || !stat.isDirectory()) {
+                throw new FsSafeError("not-file", `${params.messagePrefix} directory component must be a directory: ${current}`);
+            }
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+            syncFs.mkdirSync(current, { mode: params.mode });
+        }
+        const currentRootStat = syncFs.lstatSync(rootDir);
+        const currentRootReal = syncFs.realpathSync(rootDir);
+        const currentReal = syncFs.realpathSync(current);
+        if (currentRootStat.isSymbolicLink() ||
+            !currentRootStat.isDirectory() ||
+            !sameFileIdentity(rootStat, currentRootStat) ||
+            currentRootReal !== rootReal ||
+            !isPathInside(rootReal, currentReal)) {
+            throw new FsSafeError("outside-workspace", `${params.messagePrefix} directory escapes root`);
+        }
+        chmodDirectorySyncBestEffort(current, params.mode);
+    }
+    const guard = createSyncDirectoryGuard(dir);
+    assertSyncDirectoryGuard(guard);
+    return guard;
+}

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

@@ -0,0 +1,2 @@
+export declare function assertFileStoreMaxBytes(size: number, maxBytes?: number): void;
+//# sourceMappingURL=file-store-limit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"file-store-limit.d.ts","sourceRoot":"","sources":["../src/file-store-limit.ts"],"names":[],"mappings":"AAGA,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAK7E"}

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

@@ -0,0 +1,8 @@
+import { normalizeMaxBytes } from "./byte-budget.js";
+import { FsSafeError } from "./errors.js";
+export function assertFileStoreMaxBytes(size, maxBytes) {
+    const limit = normalizeMaxBytes(maxBytes);
+    if (limit !== undefined && size > limit) {
+        throw new FsSafeError("too-large", `file exceeds maximum size of ${limit} bytes`);
+    }
+}

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

@@ -0,0 +1,12 @@
+export type FileStorePruneOptions = {
+    ttlMs: number;
+    recursive?: boolean;
+    maxDepth?: number;
+    pruneEmptyDirs?: boolean;
+};
+export declare function pruneExpiredStoreEntries(params: {
+    rootDir: string;
+    dirMode: number;
+    options: FileStorePruneOptions;
+}): Promise<void>;
+//# sourceMappingURL=file-store-prune.d.ts.map

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

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

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

@@ -0,0 +1,95 @@
+import fsSync, {} from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { FsSafeError } from "./errors.js";
+import { isPathInside } from "./path.js";
+import { root } from "./root.js";
+import { getFsSafeTestHooks } from "./test-hooks.js";
+export async function pruneExpiredStoreEntries(params) {
+    const now = Date.now();
+    const recursive = params.options.recursive ?? false;
+    const maxDepth = params.options.maxDepth;
+    const pruneEmptyDirs = (recursive || maxDepth !== undefined) && (params.options.pruneEmptyDirs ?? false);
+    await fs.mkdir(params.rootDir, { recursive: true, mode: params.dirMode });
+    const rootReal = fsSync.realpathSync.native(params.rootDir);
+    const scopedRoot = await root(rootReal);
+    const rootGuard = {
+        dir: rootReal,
+        realPath: rootReal,
+        stat: fsSync.lstatSync(rootReal),
+    };
+    async function assertRootGuard() {
+        const stat = fsSync.lstatSync(rootGuard.dir);
+        if (stat.isSymbolicLink() ||
+            !stat.isDirectory() ||
+            stat.dev !== rootGuard.stat.dev ||
+            stat.ino !== rootGuard.stat.ino ||
+            fsSync.realpathSync.native(rootGuard.dir) !== rootGuard.realPath) {
+            throw new FsSafeError("path-mismatch", "store root changed during prune");
+        }
+    }
+    async function readStableDirectory(dir) {
+        const before = observeOrNull(() => fsSync.lstatSync(dir));
+        if (!before || before.isSymbolicLink() || !before.isDirectory()) {
+            return null;
+        }
+        const real = observeOrNull(() => fsSync.realpathSync.native(dir));
+        if (!real || !isPathInside(rootReal, real)) {
+            return null;
+        }
+        const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => null);
+        if (!entries) {
+            return null;
+        }
+        const after = observeOrNull(() => fsSync.lstatSync(dir));
+        if (!after || before.dev !== after.dev || before.ino !== after.ino) {
+            return null;
+        }
+        return entries;
+    }
+    async function pruneDir(dir, relativeDir, depth) {
+        const entries = await readStableDirectory(dir);
+        if (!entries) {
+            return false;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            const relativePath = relativeDir ? `${relativeDir}/${entry.name}` : entry.name;
+            const stat = observeOrNull(() => fsSync.lstatSync(fullPath));
+            if (!stat || stat.isSymbolicLink()) {
+                continue;
+            }
+            if (stat.isDirectory()) {
+                const shouldDescend = maxDepth !== undefined ? depth < maxDepth : recursive;
+                if (shouldDescend) {
+                    await getFsSafeTestHooks()?.beforeFileStorePruneDescend?.(fullPath);
+                }
+                if (shouldDescend && (await pruneDir(fullPath, relativePath, depth + 1))) {
+                    await assertRootGuard();
+                    // Keep empty-dir pruning on the same root-bounded remove path as files;
+                    // the Root fallback handles empty directories without recursive delete.
+                    await scopedRoot.remove(relativePath).catch(() => undefined);
+                }
+                continue;
+            }
+            if (stat.isFile() && now - stat.mtimeMs > params.options.ttlMs) {
+                await assertRootGuard();
+                await scopedRoot.remove(relativePath).catch(() => undefined);
+            }
+        }
+        if (!pruneEmptyDirs) {
+            return false;
+        }
+        const remaining = await readStableDirectory(dir);
+        return remaining !== null && remaining.length === 0;
+    }
+    await pruneDir(rootReal, "", 0);
+}
+function observeOrNull(observe) {
+    try {
+        return observe();
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1,9 @@
+export declare function writeFileSyncAtomic(params: {
+    rootDir: string;
+    filePath: string;
+    content: string | Uint8Array;
+    privateMode: boolean;
+    dirMode: number;
+    mode: number;
+}): string;
+//# sourceMappingURL=file-store-sync-write.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"file-store-sync-write.d.ts","sourceRoot":"","sources":["../src/file-store-sync-write.ts"],"names":[],"mappings":"AAwBA,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,GAAG,UAAU,CAAC;IAC7B,WAAW,EAAE,OAAO,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,MAAM,CA6GT"}

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

@@ -0,0 +1,127 @@
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { syncDirectorySync } from "./directory-durability.js";
+import { FsSafeError } from "./errors.js";
+import { sameFileIdentity } from "./file-identity.js";
+import { assertSyncDirectoryGuard, ensureParentSync, ensureStoreDirectorySync, } from "./file-store-boundary.js";
+import { isPathInside } from "./path.js";
+import { getFsSafeTestHooks } from "./test-hooks.js";
+function ensurePrivateDirectorySync(rootDir, targetDir, mode) {
+    return ensureStoreDirectorySync({
+        rootDir,
+        targetDir,
+        mode,
+        messagePrefix: "private store",
+    });
+}
+export function writeFileSyncAtomic(params) {
+    const filePath = path.resolve(params.filePath);
+    if (!isPathInside(params.rootDir, filePath)) {
+        throw new FsSafeError("outside-workspace", "file path escapes store root");
+    }
+    let parentGuard;
+    if (params.privateMode) {
+        parentGuard = ensurePrivateDirectorySync(params.rootDir, path.dirname(filePath), params.dirMode);
+        try {
+            const stat = fs.lstatSync(filePath);
+            if (stat.isSymbolicLink() || !stat.isFile()) {
+                throw new FsSafeError("not-file", `private store target must be a regular file: ${filePath}`);
+            }
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+    else {
+        parentGuard = ensureParentSync({
+            rootDir: params.rootDir,
+            filePath,
+            mode: params.dirMode,
+        });
+    }
+    const tempPath = path.join(parentGuard?.dir ?? path.dirname(filePath), `.fs-safe-${process.pid}-${randomUUID()}.tmp`);
+    let tempExists = false;
+    try {
+        getFsSafeTestHooks()?.beforeFileStoreSyncPrivateWrite?.(filePath);
+        if (parentGuard) {
+            assertSyncDirectoryGuard(parentGuard);
+        }
+        const tempStat = (() => {
+            const descriptor = fs.openSync(tempPath, "wx", params.mode);
+            tempExists = true;
+            try {
+                fs.writeFileSync(descriptor, params.content);
+                try {
+                    fs.fchmodSync(descriptor, params.mode);
+                }
+                catch {
+                    // Best-effort on platforms that do not enforce POSIX modes.
+                }
+                const opened = fs.fstatSync(descriptor);
+                if (!opened.isFile() || opened.nlink > 1) {
+                    throw new FsSafeError("path-mismatch", "store temp is not an owned regular file");
+                }
+                fs.fsyncSync(descriptor);
+                return opened;
+            }
+            finally {
+                fs.closeSync(descriptor);
+            }
+        })();
+        const tempPathStat = fs.lstatSync(tempPath);
+        if (tempPathStat.isSymbolicLink() ||
+            !tempPathStat.isFile() ||
+            tempPathStat.nlink > 1 ||
+            !sameFileIdentity(tempPathStat, tempStat)) {
+            throw new FsSafeError("path-mismatch", "store temp changed before publication");
+        }
+        if (parentGuard) {
+            assertSyncDirectoryGuard(parentGuard);
+        }
+        fs.renameSync(tempPath, filePath);
+        tempExists = false;
+        if (parentGuard) {
+            assertSyncDirectoryGuard(parentGuard);
+        }
+        try {
+            const publishedStat = fs.lstatSync(filePath);
+            if (publishedStat.isSymbolicLink() ||
+                !publishedStat.isFile() ||
+                publishedStat.nlink > 1 ||
+                !sameFileIdentity(tempStat, publishedStat)) {
+                throw new FsSafeError("path-mismatch", "store target changed after write");
+            }
+        }
+        catch (error) {
+            if (error instanceof FsSafeError) {
+                throw error;
+            }
+            throw new FsSafeError("path-mismatch", "store target changed after write", {
+                cause: error instanceof Error ? error : undefined,
+            });
+        }
+        if (parentGuard) {
+            assertSyncDirectoryGuard(parentGuard);
+            syncDirectorySync({
+                path: parentGuard.dir,
+                realPath: parentGuard.realPath,
+                identity: parentGuard.stat,
+            }, { label: "store parent" });
+            assertSyncDirectoryGuard(parentGuard);
+        }
+        return filePath;
+    }
+    finally {
+        if (tempExists) {
+            try {
+                fs.unlinkSync(tempPath);
+            }
+            catch {
+                // Best-effort cleanup after write failure.
+            }
+        }
+    }
+}

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

@@ -0,0 +1,62 @@
+import type { Readable } from "node:stream";
+import { type FileStorePruneOptions } from "./file-store-prune.js";
+export type { FileStorePruneOptions } from "./file-store-prune.js";
+import { type JsonFileStoreOptions, type JsonStore } from "./json-document-store.js";
+import { type OpenResult, type ReadResult, type Root, type RootReadOptions } from "./root.js";
+export type FileStoreOptions = {
+    rootDir: string;
+    private?: boolean;
+    dirMode?: number;
+    mode?: number;
+    maxBytes?: number;
+};
+export type FileStoreWriteOptions = {
+    dirMode?: number;
+    mode?: number;
+    maxBytes?: number;
+    tempPrefix?: string;
+};
+export type FileStoreReadOptions = RootReadOptions & {
+    encoding?: BufferEncoding;
+};
+export type FileStore = {
+    readonly rootDir: string;
+    path(relativePath: string): string;
+    root(): Promise<Root>;
+    write(relativePath: string, data: string | Uint8Array, options?: FileStoreWriteOptions): Promise<string>;
+    writeStream(relativePath: string, stream: Readable, options?: FileStoreWriteOptions): Promise<string>;
+    copyIn(relativePath: string, sourcePath: string, options?: FileStoreWriteOptions): Promise<string>;
+    open(relativePath: string, options?: RootReadOptions): Promise<OpenResult>;
+    read(relativePath: string, options?: RootReadOptions): Promise<ReadResult>;
+    readBytes(relativePath: string, options?: RootReadOptions): Promise<Buffer>;
+    readText(relativePath: string, options?: FileStoreReadOptions): Promise<string>;
+    readTextIfExists(relativePath: string, options?: FileStoreReadOptions): Promise<string | null>;
+    readJson<T = unknown>(relativePath: string, options?: FileStoreReadOptions): Promise<T>;
+    readJsonIfExists<T = unknown>(relativePath: string, options?: FileStoreReadOptions): Promise<T | null>;
+    remove(relativePath: string): Promise<void>;
+    exists(relativePath: string): Promise<boolean>;
+    writeText(relativePath: string, data: string | Uint8Array, options?: FileStoreWriteOptions): Promise<string>;
+    writeJson(relativePath: string, data: unknown, options?: FileStoreWriteOptions & {
+        trailingNewline?: boolean;
+    }): Promise<string>;
+    json<T = unknown>(relativePath: string, options?: JsonFileStoreOptions): JsonStore<T>;
+    pruneExpired(options: FileStorePruneOptions): Promise<void>;
+};
+export type FileStoreSync = {
+    readonly rootDir: string;
+    path(relativePath: string): string;
+    readTextIfExists(relativePath: string, options?: {
+        maxBytes?: number;
+    }): string | null;
+    readJsonIfExists<T = unknown>(relativePath: string, options?: {
+        maxBytes?: number;
+    }): T | null;
+    write(relativePath: string, data: string | Uint8Array, options?: FileStoreWriteOptions): string;
+    writeText(relativePath: string, data: string | Uint8Array, options?: FileStoreWriteOptions): string;
+    writeJson(relativePath: string, data: unknown, options?: FileStoreWriteOptions & {
+        trailingNewline?: boolean;
+    }): string;
+};
+export declare function fileStore(options: FileStoreOptions): FileStore;
+export declare function fileStoreSync(options: FileStoreOptions): FileStoreSync;
+//# sourceMappingURL=file-store.d.ts.map

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

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