@openclaw/openshell-sandbox 2026.9.1 → 2026.9.3

package/node_modules/@openclaw/fs-safe/dist/temp-workspace-owner.js

@@ -0,0 +1,320 @@
+import { randomUUID } from "node:crypto";
+import fsSync from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { createAsyncDirectoryGuard, createSyncDirectoryGuard } from "./directory-guard.js";
+import { FsSafeError } from "./errors.js";
+import { sameFileIdentityForCleanup } from "./file-identity.js";
+import { withAsyncDirectoryGuards, withSyncDirectoryGuards } from "./guarded-mutation.js";
+import { getNativeBinding } from "./native.js";
+import { assertStagedDirectoryCurrent, openStagedDirectory } from "./staged-directory.js";
+import { getFsSafeTestHooks } from "./test-hooks.js";
+function isNativeCleanupBinding(binding) {
+    return typeof binding?.renameNoReplace === "function" &&
+        typeof binding.removeOwnedTree === "function" &&
+        typeof binding.removeOwnedTreeSync === "function" &&
+        typeof binding.ownedTreeRemovalAvailable === "function";
+}
+function nativeRemovalError(result) {
+    if (!result.errorCode)
+        return undefined;
+    return Object.assign(new Error(result.errorMessage ?? "native owned-tree cleanup failed"), {
+        code: result.errorCode,
+    });
+}
+export class TempWorkspaceCleanupCapability {
+    binding;
+    parent;
+    #ownedTreeRemovalAvailable;
+    #closed = false;
+    constructor(root, safety) {
+        let binding;
+        try {
+            binding = getNativeBinding();
+        }
+        catch (error) {
+            if (safety === "require-bounded")
+                throw error;
+        }
+        this.binding = binding;
+        let parent;
+        try {
+            parent = openStagedDirectory(root);
+            assertStagedDirectoryCurrent(parent.receipt);
+        }
+        catch {
+            if (parent)
+                fsSync.closeSync(parent.fd);
+            parent = undefined;
+        }
+        this.parent = parent;
+        let available = false;
+        if (parent && isNativeCleanupBinding(binding)) {
+            try {
+                available = binding.ownedTreeRemovalAvailable(parent.fd) === true;
+            }
+            catch {
+                // Runtime denial must select fallback or reject before child creation.
+            }
+        }
+        this.#ownedTreeRemovalAvailable = available;
+        if (safety === "require-bounded" && !this.canRemoveOwnedTree) {
+            this.close();
+            throw new FsSafeError("helper-unavailable", "temp workspace owned-tree cleanup is unavailable");
+        }
+    }
+    get canRemoveOwnedTree() {
+        return !this.#closed && this.#ownedTreeRemovalAvailable;
+    }
+    assertCurrent() {
+        if (this.#closed || !this.parent) {
+            throw new FsSafeError("path-mismatch", "temp workspace cleanup parent is unavailable");
+        }
+        assertStagedDirectoryCurrent(this.parent.receipt);
+        const current = fsSync.fstatSync(this.parent.fd, { bigint: true });
+        if (!sameFileIdentityForCleanup(current, this.parent.receipt.identity)) {
+            throw new FsSafeError("path-mismatch", "temp workspace cleanup parent changed");
+        }
+    }
+    close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        if (this.parent)
+            fsSync.closeSync(this.parent.fd);
+    }
+}
+export class TempWorkspaceCleanupOwner {
+    #dir;
+    #identity;
+    #capability;
+    #directory;
+    #closed = false;
+    #running = false;
+    #exitInterrupted = false;
+    #result;
+    #pending;
+    constructor(dir, identity, capability) {
+        this.#dir = dir;
+        this.#identity = { dev: identity.dev, ino: identity.ino };
+        this.#capability = capability;
+        let directory;
+        if (capability.canRemoveOwnedTree) {
+            directory = openStagedDirectory(dir);
+            const current = fsSync.fstatSync(directory.fd, { bigint: true });
+            if (!sameFileIdentityForCleanup(current, this.#identity)) {
+                fsSync.closeSync(directory.fd);
+                capability.close();
+                throw new FsSafeError("path-mismatch", "temp workspace changed while retaining cleanup authority");
+            }
+        }
+        this.#directory = directory;
+    }
+    #repeat() {
+        return this.#result === "removed" ? "missing" : this.#result;
+    }
+    #close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        const errors = [];
+        if (this.#directory) {
+            try {
+                fsSync.closeSync(this.#directory.fd);
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        try {
+            this.#capability.close();
+        }
+        catch (error) {
+            errors.push(error);
+        }
+        if (errors.length === 1)
+            throw errors[0];
+        if (errors.length > 1)
+            throw new AggregateError(errors, "temp workspace cleanup descriptor close failed");
+    }
+    #finish(result) {
+        this.#result ??= this.#exitInterrupted ? "indeterminate" : result;
+        try {
+            this.#close();
+        }
+        catch (error) {
+            this.#result = "indeterminate";
+            throw error;
+        }
+        return this.#result;
+    }
+    #fallbackResult() {
+        try {
+            const current = fsSync.lstatSync(this.#dir, { bigint: true });
+            return current.isDirectory() && !current.isSymbolicLink() &&
+                sameFileIdentityForCleanup(current, this.#identity)
+                ? "indeterminate"
+                : "identity-mismatch";
+        }
+        catch (error) {
+            return error.code === "ENOENT" ? "missing" : "indeterminate";
+        }
+    }
+    #prepare() {
+        const parent = this.#capability.parent;
+        if (!parent)
+            return this.#fallbackResult();
+        try {
+            this.#capability.assertCurrent();
+            let current;
+            try {
+                current = fsSync.lstatSync(this.#dir, { bigint: true });
+            }
+            catch (error) {
+                this.#capability.assertCurrent();
+                return error.code === "ENOENT" ? "missing" : "indeterminate";
+            }
+            this.#capability.assertCurrent();
+            if (!current.isDirectory() || current.isSymbolicLink() ||
+                !sameFileIdentityForCleanup(current, this.#identity)) {
+                return "identity-mismatch";
+            }
+            const name = `.fs-safe-workspace-cleanup-${randomUUID()}`;
+            const quarantinePath = path.join(parent.receipt.path, name);
+            const nativeRemoval = this.#capability.canRemoveOwnedTree && this.#directory !== undefined;
+            if (nativeRemoval) {
+                this.#capability.binding.renameNoReplace(parent.fd, path.basename(this.#dir), parent.fd, name);
+            }
+            else {
+                const guard = createSyncDirectoryGuard(parent.receipt.path);
+                withSyncDirectoryGuards([guard], () => {
+                    this.#capability.assertCurrent();
+                    fsSync.renameSync(this.#dir, quarantinePath);
+                });
+            }
+            this.#capability.assertCurrent();
+            const quarantined = fsSync.lstatSync(quarantinePath, { bigint: true });
+            this.#capability.assertCurrent();
+            if (!quarantined.isDirectory() || quarantined.isSymbolicLink() ||
+                !sameFileIdentityForCleanup(quarantined, this.#identity)) {
+                return "indeterminate";
+            }
+            return { name, path: quarantinePath, nativeRemoval };
+        }
+        catch {
+            // A failed rename can still have committed on a remote filesystem.
+            return "indeterminate";
+        }
+    }
+    #assertQuarantine(quarantine) {
+        const current = fsSync.lstatSync(quarantine.path, { bigint: true });
+        if (!current.isDirectory() || current.isSymbolicLink() ||
+            !sameFileIdentityForCleanup(current, this.#identity)) {
+            throw new FsSafeError("path-mismatch", "temp workspace quarantine changed");
+        }
+        this.#capability.assertCurrent();
+    }
+    #mapRemoval(result) {
+        const error = nativeRemovalError(result);
+        if (error) {
+            if (error.code === "path-mismatch")
+                return "indeterminate";
+            throw error;
+        }
+        return result.outcome === "removed" ? "removed" : "indeterminate";
+    }
+    async #remove(quarantine) {
+        if (quarantine.nativeRemoval) {
+            const beforeNativeRemoval = getFsSafeTestHooks()?.beforeTempWorkspaceNativeRemoval;
+            if (beforeNativeRemoval)
+                await beforeNativeRemoval(quarantine.path);
+            return this.#mapRemoval(await this.#capability.binding.removeOwnedTree(this.#capability.parent.fd, quarantine.name, this.#directory.fd));
+        }
+        let removalError;
+        try {
+            const guard = await createAsyncDirectoryGuard(this.#capability.parent.receipt.path);
+            await withAsyncDirectoryGuards([guard], async () => {
+                this.#assertQuarantine(quarantine);
+                try {
+                    await fs.rm(quarantine.path, { recursive: true, force: true });
+                }
+                catch (error) {
+                    removalError = error;
+                    throw error;
+                }
+            });
+            return "removed";
+        }
+        catch (error) {
+            if (error === removalError)
+                throw error;
+            return "indeterminate";
+        }
+    }
+    #removeSync(quarantine) {
+        if (quarantine.nativeRemoval) {
+            getFsSafeTestHooks()?.beforeTempWorkspaceNativeRemovalSync?.(quarantine.path);
+            return this.#mapRemoval(this.#capability.binding.removeOwnedTreeSync(this.#capability.parent.fd, quarantine.name, this.#directory.fd));
+        }
+        let removalError;
+        try {
+            const guard = createSyncDirectoryGuard(this.#capability.parent.receipt.path);
+            withSyncDirectoryGuards([guard], () => {
+                this.#assertQuarantine(quarantine);
+                try {
+                    fsSync.rmSync(quarantine.path, { recursive: true, force: true });
+                }
+                catch (error) {
+                    removalError = error;
+                    throw error;
+                }
+            });
+            return "removed";
+        }
+        catch (error) {
+            if (error === removalError)
+                throw error;
+            return "indeterminate";
+        }
+    }
+    async #run() {
+        let result = "indeterminate";
+        try {
+            const prepared = this.#prepare();
+            result = typeof prepared === "string" ? prepared : await this.#remove(prepared);
+            return this.#finish(result);
+        }
+        finally {
+            if (!this.#closed)
+                this.#finish(result);
+        }
+    }
+    cleanup() {
+        if (this.#result)
+            return Promise.resolve(this.#repeat());
+        if (this.#pending)
+            return this.#pending.then(() => this.#repeat());
+        this.#running = true;
+        this.#pending = this.#run();
+        return this.#pending;
+    }
+    cleanupSync() {
+        if (this.#result)
+            return this.#repeat();
+        if (this.#running) {
+            this.#exitInterrupted = true;
+            return "indeterminate";
+        }
+        this.#running = true;
+        let result = "indeterminate";
+        try {
+            const prepared = this.#prepare();
+            result = typeof prepared === "string" ? prepared : this.#removeSync(prepared);
+            return this.#finish(result);
+        }
+        finally {
+            if (!this.#closed)
+                this.#finish(result);
+        }
+    }
+}

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

@@ -0,0 +1,4 @@
+export { tempWorkspace, type TempWorkspace, type TempWorkspaceOptions, type TempWorkspaceCleanupResult, type TempWorkspaceCleanupSafety, tempWorkspaceSync, type TempWorkspaceSync, withTempWorkspace, withTempWorkspaceSync, } from "./private-temp-workspace.js";
+export type { TempPathIdentityReceipt } from "./temp-cleanup.js";
+export { resolveSecureTempRoot, type ResolveSecureTempRootOptions } from "./secure-temp-dir.js";
+//# sourceMappingURL=temp.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"temp.d.ts","sourceRoot":"","sources":["../src/temp.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,KAAK,0BAA0B,EAC/B,KAAK,0BAA0B,EAC/B,iBAAiB,EACjB,KAAK,iBAAiB,EACtB,iBAAiB,EACjB,qBAAqB,GACtB,MAAM,6BAA6B,CAAC;AACrC,YAAY,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,EAAE,qBAAqB,EAAE,KAAK,4BAA4B,EAAE,MAAM,sBAAsB,CAAC"}

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

@@ -0,0 +1,2 @@
+export { tempWorkspace, tempWorkspaceSync, withTempWorkspace, withTempWorkspaceSync, } from "./private-temp-workspace.js";
+export { resolveSecureTempRoot } from "./secure-temp-dir.js";

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

@@ -0,0 +1,25 @@
+import type { FileHandle } from "node:fs/promises";
+import type { FileIdentityStat } from "./file-identity.js";
+export type FsSafeTestHooks = {
+    afterPreOpenLstat?: (filePath: string) => Promise<void> | void;
+    beforeOpen?: (filePath: string, flags: number) => Promise<void> | void;
+    afterOpen?: (filePath: string, handle: FileHandle) => Promise<void> | void;
+    afterOpenedPathIdentityCheck?: (filePath: string, handle: FileHandle) => Promise<void> | void;
+    beforeArchiveOutputMutation?: (operation: "mkdir" | "chmod", targetPath: string) => Promise<void> | void;
+    beforeFileStorePruneDescend?: (dirPath: string) => Promise<void> | void;
+    beforeFileStoreSyncPrivateWrite?: (filePath: string) => void;
+    beforeRootFallbackMutation?: (operation: "mkdir" | "move" | "remove", targetPath: string) => Promise<void> | void;
+    afterPinnedWriteFallbackRename?: (targetPath: string) => Promise<void> | void;
+    beforeSiblingTempWrite?: (tempPath: string) => Promise<void> | void;
+    beforeSidecarLockSnapshotOpen?: (lockPath: string) => Promise<void> | void;
+    beforeRegularFileAppendOpen?: (filePath: string) => Promise<void> | void;
+    beforeRegularFileAppendOpenSync?: (filePath: string) => void;
+    beforeTempWorkspaceNativeRemoval?: (quarantinePath: string) => Promise<void> | void;
+    beforeTempWorkspaceNativeRemovalSync?: (quarantinePath: string) => void;
+    beforeTrashMove?: (targetPath: string, destPath: string) => void;
+    afterPublishTargetCreated?: (method: "hardlink" | "exclusive-copy" | "rename-noreplace", targetPath: string, identity: FileIdentityStat) => Promise<void> | void;
+    beforePublishDirectorySync?: (method: "hardlink" | "exclusive-copy" | "rename-noreplace", targetPath: string, identity: FileIdentityStat) => Promise<void> | void;
+};
+export declare function getFsSafeTestHooks(): FsSafeTestHooks | undefined;
+export declare function __setFsSafeTestHooksForTest(hooks?: FsSafeTestHooks): void;
+//# sourceMappingURL=test-hooks.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/test-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-hooks.d.ts","sourceRoot":"","sources":["../src/test-hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,MAAM,MAAM,eAAe,GAAG;IAC5B,iBAAiB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC/D,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACvE,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC3E,4BAA4B,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC9F,2BAA2B,CAAC,EAAE,CAC5B,SAAS,EAAE,OAAO,GAAG,OAAO,EAC5B,UAAU,EAAE,MAAM,KACf,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC1B,2BAA2B,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACxE,+BAA+B,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7D,0BAA0B,CAAC,EAAE,CAC3B,SAAS,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,EACtC,UAAU,EAAE,MAAM,KACf,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC1B,8BAA8B,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC9E,sBAAsB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACpE,6BAA6B,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC3E,2BAA2B,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACzE,+BAA+B,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7D,gCAAgC,CAAC,EAAE,CAAC,cAAc,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACpF,oCAAoC,CAAC,EAAE,CAAC,cAAc,EAAE,MAAM,KAAK,IAAI,CAAC;IACxE,eAAe,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACjE,yBAAyB,CAAC,EAAE,CAC1B,MAAM,EAAE,UAAU,GAAG,gBAAgB,GAAG,kBAAkB,EAC1D,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,gBAAgB,KACvB,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC1B,0BAA0B,CAAC,EAAE,CAC3B,MAAM,EAAE,UAAU,GAAG,gBAAgB,GAAG,kBAAkB,EAC1D,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,gBAAgB,KACvB,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAC3B,CAAC;AAQF,wBAAgB,kBAAkB,IAAI,eAAe,GAAG,SAAS,CAEhE;AAED,wBAAgB,2BAA2B,CAAC,KAAK,CAAC,EAAE,eAAe,GAAG,IAAI,CAKzE"}

package/node_modules/@openclaw/fs-safe/dist/test-hooks.js

@@ -0,0 +1,13 @@
+let fsSafeTestHooks;
+function allowFsSafeTestHooks() {
+    return process.env.NODE_ENV === "test" || process.env.VITEST === "true";
+}
+export function getFsSafeTestHooks() {
+    return fsSafeTestHooks;
+}
+export function __setFsSafeTestHooksForTest(hooks) {
+    if (hooks && !allowFsSafeTestHooks()) {
+        throw new Error("__setFsSafeTestHooksForTest is only available in tests");
+    }
+    fsSafeTestHooks = hooks;
+}

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

@@ -0,0 +1,14 @@
+export type WriteTextAtomicOptions = {
+    mode?: number;
+    dirMode?: number;
+    trailingNewline?: boolean;
+    /**
+     * When false, skip the temp-file and parent-directory fsync calls while
+     * preserving the temp-file replace/rename behavior.
+     *
+     * Defaults to true.
+     */
+    durable?: boolean;
+};
+export declare function writeTextAtomic(filePath: string, content: string, options?: WriteTextAtomicOptions): Promise<void>;
+//# sourceMappingURL=text-atomic.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/text-atomic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-atomic.d.ts","sourceRoot":"","sources":["../src/text-atomic.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,wBAAsB,eAAe,CACnC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,IAAI,CAAC,CAYf"}

package/node_modules/@openclaw/fs-safe/dist/text-atomic.js

@@ -0,0 +1,14 @@
+import { replaceFileAtomic } from "./replace-file.js";
+export async function writeTextAtomic(filePath, content, options) {
+    const payload = options?.trailingNewline && !content.endsWith("\n") ? `${content}\n` : content;
+    const durable = options?.durable ?? true;
+    await replaceFileAtomic({
+        filePath,
+        content: payload,
+        mode: options?.mode ?? 0o600,
+        dirMode: options?.dirMode ?? (0o777 & ~process.umask()),
+        copyFallbackOnPermissionError: true,
+        syncTempFile: durable,
+        syncParentDir: durable,
+    });
+}

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

@@ -0,0 +1,8 @@
+export declare function sleep(ms: number): Promise<void>;
+export declare function sleepSync(ms: number): void;
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, labelOrOptions?: string | {
+    label?: string;
+    message?: string;
+    createError?: () => Error;
+}): Promise<T>;
+//# sourceMappingURL=timing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"timing.d.ts","sourceRoot":"","sources":["../src/timing.ts"],"names":[],"mappings":"AAAA,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/C;AAED,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAK1C;AAED,wBAAsB,WAAW,CAAC,CAAC,EACjC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,SAAS,EAAE,MAAM,EACjB,cAAc,GAAE,MAAM,GAAG;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,KAAK,CAAA;CAErF,GACA,OAAO,CAAC,CAAC,CAAC,CA6BZ"}

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

@@ -0,0 +1,40 @@
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function sleepSync(ms) {
+    if (ms <= 0) {
+        return;
+    }
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+export async function withTimeout(promise, timeoutMs, labelOrOptions = {
+    message: "timeout",
+}) {
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+        return await promise;
+    }
+    const options = typeof labelOrOptions === "string" ? { label: labelOrOptions } : labelOrOptions;
+    const createError = options.createError ??
+        (() => new Error(options.message ?? `${options.label ?? "operation"} timed out after ${timeoutMs}ms`));
+    let timeoutId;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                timeoutId = setTimeout(() => {
+                    try {
+                        reject(createError());
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                }, timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+    }
+}

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

@@ -0,0 +1,5 @@
+export type MovePathToTrashOptions = {
+    allowedRoots?: Iterable<string>;
+};
+export declare function movePathToTrash(targetPath: string, options?: MovePathToTrashOptions): Promise<string>;
+//# sourceMappingURL=trash.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trash.d.ts","sourceRoot":"","sources":["../src/trash.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,sBAAsB,GAAG;IACnC,YAAY,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;CACjC,CAAC;AAkLF,wBAAsB,eAAe,CACnC,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,MAAM,CAAC,CAcjB"}

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

@@ -0,0 +1,171 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { sameFileIdentity } from "./file-identity.js";
+import { guardedRenameSync, guardedRmSync } from "./guarded-mutation.js";
+import { getFsSafeTestHooks } from "./test-hooks.js";
+const TRASH_DESTINATION_COLLISION_CODES = new Set(["EEXIST", "ENOTEMPTY", "ERR_FS_CP_EEXIST"]);
+const TRASH_DESTINATION_RETRY_LIMIT = 4;
+function getFsErrorCode(error) {
+    if (!error || typeof error !== "object" || !("code" in error)) {
+        return undefined;
+    }
+    const code = error.code;
+    return typeof code === "string" ? code : undefined;
+}
+function isTrashDestinationCollision(error) {
+    const code = getFsErrorCode(error);
+    return Boolean(code && TRASH_DESTINATION_COLLISION_CODES.has(code));
+}
+function isSameOrChildPath(candidate, parent) {
+    return candidate === parent || candidate.startsWith(`${parent}${path.sep}`);
+}
+function resolveAllowedTrashRoots(allowedRoots) {
+    const roots = [...(allowedRoots ?? [os.homedir(), os.tmpdir()])].flatMap((root) => {
+        const lexicalRoot = path.resolve(root);
+        try {
+            // Keep both spellings: broken symlink targets cannot be realpathed and
+            // may only compare equal to the caller's lexical allowed root.
+            return [path.resolve(fs.realpathSync.native(root)), lexicalRoot];
+        }
+        catch {
+            return [lexicalRoot];
+        }
+    });
+    return [...new Set(roots)];
+}
+function resolveTrashTargetPath(targetPath) {
+    try {
+        return { path: path.resolve(fs.realpathSync.native(targetPath)), resolved: true };
+    }
+    catch {
+        // Broken symlinks are valid trash targets. Fall back to the lexical path,
+        // then rely on lstat identity so the move renames the symlink itself.
+        return { path: path.resolve(targetPath), resolved: false };
+    }
+}
+function assertAllowedTrashTarget(targetPath, allowedRoots) {
+    const stat = fs.lstatSync(path.resolve(targetPath));
+    const resolvedTarget = resolveTrashTargetPath(targetPath);
+    const resolvedTargetPath = resolvedTarget.path;
+    const isAllowed = resolveAllowedTrashRoots(allowedRoots).some((root) => resolvedTargetPath !== root && isSameOrChildPath(resolvedTargetPath, root));
+    if (!isAllowed) {
+        throw new Error(`Refusing to trash path outside allowed roots: ${targetPath}`);
+    }
+    return {
+        path: path.resolve(targetPath),
+        realPath: resolvedTargetPath,
+        realPathResolved: resolvedTarget.resolved,
+        stat,
+    };
+}
+function assertTrashTargetGuard(guard) {
+    const stat = fs.lstatSync(guard.path);
+    if (!sameFileIdentity(stat, guard.stat)) {
+        throw new Error(`Refusing to trash path after it changed: ${guard.path}`);
+    }
+    const current = resolveTrashTargetPath(guard.path);
+    if (guard.realPathResolved && (!current.resolved || current.path !== guard.realPath)) {
+        throw new Error(`Refusing to trash path after it changed: ${guard.path}`);
+    }
+    if (!guard.realPathResolved && current.resolved) {
+        throw new Error(`Refusing to trash path after it changed: ${guard.path}`);
+    }
+}
+function resolveTrashDir() {
+    const homeDir = os.homedir();
+    const trashDir = path.join(homeDir, ".Trash");
+    fs.mkdirSync(trashDir, { recursive: true, mode: 0o700 });
+    const trashDirStat = fs.lstatSync(trashDir);
+    if (!trashDirStat.isDirectory() || trashDirStat.isSymbolicLink()) {
+        throw new Error(`Refusing to use non-directory/symlink trash directory: ${trashDir}`);
+    }
+    const realHome = path.resolve(fs.realpathSync.native(homeDir));
+    const resolvedTrashDir = path.resolve(fs.realpathSync.native(trashDir));
+    if (resolvedTrashDir === realHome || !isSameOrChildPath(resolvedTrashDir, realHome)) {
+        throw new Error(`Trash directory escaped home directory: ${trashDir}`);
+    }
+    return resolvedTrashDir;
+}
+function trashBaseName(targetPath) {
+    const resolvedTargetPath = path.resolve(targetPath);
+    if (resolvedTargetPath === path.parse(resolvedTargetPath).root) {
+        throw new Error(`Refusing to trash root path: ${targetPath}`);
+    }
+    const base = path.basename(resolvedTargetPath).replace(/[\\/]+/g, "");
+    if (!base) {
+        throw new Error(`Unable to derive safe trash basename for: ${targetPath}`);
+    }
+    return base;
+}
+function resolveContainedPath(root, leaf) {
+    const resolvedRoot = path.resolve(root);
+    const resolvedPath = path.resolve(resolvedRoot, leaf);
+    if (!isSameOrChildPath(resolvedPath, resolvedRoot) || resolvedPath === resolvedRoot) {
+        throw new Error(`Trash destination escaped trash directory: ${resolvedPath}`);
+    }
+    return resolvedPath;
+}
+function reserveTrashDestination(trashDir, base, timestamp) {
+    const containerPrefix = resolveContainedPath(trashDir, `${base}-${timestamp}-`);
+    const container = fs.mkdtempSync(containerPrefix);
+    const resolvedContainer = path.resolve(container);
+    const resolvedTrashDir = path.resolve(trashDir);
+    if (resolvedContainer === resolvedTrashDir ||
+        !isSameOrChildPath(resolvedContainer, resolvedTrashDir)) {
+        throw new Error(`Trash destination escaped trash directory: ${container}`);
+    }
+    return resolveContainedPath(container, base);
+}
+function copyTrashTargetSync(target, dest) {
+    if (target.stat.isSymbolicLink()) {
+        const linkTarget = fs.readlinkSync(target.path);
+        assertTrashTargetGuard(target);
+        fs.symlinkSync(linkTarget, dest);
+        return;
+    }
+    fs.cpSync(target.path, dest, { recursive: true, force: false, errorOnExist: true });
+}
+function movePathToDestination(target, dest) {
+    getFsSafeTestHooks()?.beforeTrashMove?.(target.path, dest);
+    assertTrashTargetGuard(target);
+    try {
+        guardedRenameSync({ from: target.path, to: dest });
+        return true;
+    }
+    catch (error) {
+        if (getFsErrorCode(error) !== "EXDEV") {
+            if (isTrashDestinationCollision(error)) {
+                return false;
+            }
+            throw error;
+        }
+    }
+    try {
+        assertTrashTargetGuard(target);
+        copyTrashTargetSync(target, dest);
+        assertTrashTargetGuard(target);
+        guardedRmSync({ target: target.path, recursive: true, force: false, verifyAfter: false });
+        return true;
+    }
+    catch (error) {
+        if (isTrashDestinationCollision(error)) {
+            return false;
+        }
+        throw error;
+    }
+}
+export async function movePathToTrash(targetPath, options = {}) {
+    // Avoid resolving external trash helpers through the service PATH during cleanup.
+    const base = trashBaseName(targetPath);
+    const target = assertAllowedTrashTarget(targetPath, options.allowedRoots);
+    const trashDir = resolveTrashDir();
+    const timestamp = Date.now();
+    for (let attempt = 0; attempt < TRASH_DESTINATION_RETRY_LIMIT; attempt += 1) {
+        const dest = reserveTrashDestination(trashDir, base, timestamp);
+        if (movePathToDestination(target, dest)) {
+            return dest;
+        }
+    }
+    throw new Error(`Unable to choose a unique trash destination for ${targetPath}`);
+}

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

@@ -0,0 +1,23 @@
+export type FastPathMode = "auto" | "never" | "require";
+export type SafeEncoding = BufferEncoding | null;
+export type PathStat = {
+    dev: number;
+    gid: number;
+    ino: number;
+    isDirectory: boolean;
+    isFile: boolean;
+    isSymbolicLink: boolean;
+    mode: number;
+    mtimeMs: number;
+    nlink: number;
+    size: number;
+    uid: number;
+};
+export type DirEntry = PathStat & {
+    name: string;
+};
+export type BasePathOptions = {
+    rootDir: string;
+    relativePath: string;
+};
+//# sourceMappingURL=types.d.ts.map