@openclaw/openshell-sandbox 2026.9.2 → 2026.9.3

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

@@ -0,0 +1,78 @@
+import fsSync from "node:fs";
+import path from "node:path";
+import { FsSafeError } from "./errors.js";
+import { hasNodeErrorCode, isPathRelativeEscape } from "./path.js";
+function resolvePathWalk(params) {
+    const root = path.resolve(params.rootDir);
+    const target = path.resolve(params.targetPath);
+    const relative = path.relative(root, target);
+    if (isPathRelativeEscape(relative)) {
+        if (params.allowOutsideRoot) {
+            return null;
+        }
+        throw new Error(`${params.messagePrefix ?? "Path"} must stay under ${root}.`);
+    }
+    return {
+        root,
+        segments: relative && relative !== "." ? relative.split(path.sep).filter(Boolean) : [],
+    };
+}
+function formatUnsafePath(params, current) {
+    return `${params.messagePrefix ?? "Path"} must not traverse symlinked directory: ${current}`;
+}
+export async function assertNoSymlinkParents(params) {
+    const walk = resolvePathWalk(params);
+    if (!walk) {
+        return;
+    }
+    let current = walk.root;
+    for (const [index, segment] of walk.segments.entries()) {
+        current = path.join(current, segment);
+        try {
+            const stat = fsSync.lstatSync(current);
+            if (stat.isSymbolicLink()) {
+                if (params.allowRootChildSymlink && path.dirname(current) === walk.root) {
+                    continue;
+                }
+                throw new Error(formatUnsafePath(params, current));
+            }
+            if ((params.requireDirectories || index < walk.segments.length - 1) && !stat.isDirectory()) {
+                throw new FsSafeError("not-file", `${params.messagePrefix ?? "Path"} must traverse directories: ${current}`);
+            }
+        }
+        catch (err) {
+            if (hasNodeErrorCode(err, "ENOENT") && params.allowMissing !== false) {
+                return;
+            }
+            throw err;
+        }
+    }
+}
+export function assertNoSymlinkParentsSync(params) {
+    const walk = resolvePathWalk(params);
+    if (!walk) {
+        return;
+    }
+    let current = walk.root;
+    for (const [index, segment] of walk.segments.entries()) {
+        current = path.join(current, segment);
+        try {
+            const stat = fsSync.lstatSync(current);
+            if (stat.isSymbolicLink()) {
+                if (params.allowRootChildSymlink && path.dirname(current) === walk.root) {
+                    continue;
+                }
+                throw new Error(formatUnsafePath(params, current));
+            }
+            if ((params.requireDirectories || index < walk.segments.length - 1) && !stat.isDirectory()) {
+                throw new FsSafeError("not-file", `${params.messagePrefix ?? "Path"} must traverse directories: ${current}`);
+            }
+        }
+        catch (err) {
+            if (err.code === "ENOENT" && params.allowMissing !== false) {
+                return;
+            }
+            throw err;
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+import { type FileIdentityStat } from "./file-identity.js";
+export type TempPathIdentityReceipt = FileIdentityStat;
+export type TempPathRegistration = (() => void) & {
+    setIdentity(identity: FileIdentityStat): void;
+};
+export declare function registerTempPathForExit(tempPath: string, options?: {
+    recursive?: boolean;
+    identity?: FileIdentityStat;
+    singleLinkFile?: boolean;
+    cleanupSync?: () => unknown;
+}): TempPathRegistration;
+export declare function __cleanupRegisteredTempPathsForTest(): void;
+export declare function __cleanupRegisteredTempPathForTest(tempPath: string): void;
+//# sourceMappingURL=temp-cleanup.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"temp-cleanup.d.ts","sourceRoot":"","sources":["../src/temp-cleanup.ts"],"names":[],"mappings":"AACA,OAAO,EAA8B,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEvF,MAAM,MAAM,uBAAuB,GAAG,gBAAgB,CAAC;AAEvD,MAAM,MAAM,oBAAoB,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG;IAChD,WAAW,CAAC,QAAQ,EAAE,gBAAgB,GAAG,IAAI,CAAC;CAC/C,CAAC;AAkDF,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE;IACR,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,OAAO,CAAC;CAC7B,GACA,oBAAoB,CA2BtB;AAED,wBAAgB,mCAAmC,IAAI,IAAI,CAE1D;AAED,wBAAgB,kCAAkC,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAUzE"}

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

@@ -0,0 +1,87 @@
+import fsSync from "node:fs";
+import { sameFileIdentityForCleanup } from "./file-identity.js";
+const tempCleanupEntries = new Map();
+let cleanupRegistered = false;
+function pathStillMatchesReceipt(entry) {
+    if (!entry.identity) {
+        return false;
+    }
+    try {
+        const current = fsSync.lstatSync(entry.path, { bigint: true });
+        return (!entry.singleLinkFile || (current.isFile() && current.nlink === 1n)) &&
+            sameFileIdentityForCleanup(current, entry.identity);
+    }
+    catch (error) {
+        return !entry.singleLinkFile && error.code === "ENOENT";
+    }
+}
+function removeRegisteredPathSync(entry) {
+    if (entry.singleLinkFile)
+        fsSync.unlinkSync(entry.path);
+    else
+        fsSync.rmSync(entry.path, { force: true, recursive: entry.recursive });
+}
+function cleanupEntrySync(entry) {
+    if (entry.cleanupSync) {
+        entry.cleanupSync();
+    }
+    else if (pathStillMatchesReceipt(entry)) {
+        removeRegisteredPathSync(entry);
+    }
+}
+function cleanupRegisteredTempPathsSync() {
+    for (const entry of tempCleanupEntries.values()) {
+        try {
+            cleanupEntrySync(entry);
+        }
+        catch {
+            // Process-exit cleanup is best-effort.
+        }
+    }
+    tempCleanupEntries.clear();
+}
+export function registerTempPathForExit(tempPath, options) {
+    if (!cleanupRegistered) {
+        cleanupRegistered = true;
+        process.once("exit", cleanupRegisteredTempPathsSync);
+    }
+    const entry = {
+        path: tempPath,
+        recursive: options?.recursive === true,
+        identity: options?.identity,
+        singleLinkFile: options?.singleLinkFile,
+        cleanupSync: options?.cleanupSync,
+    };
+    if (!entry.identity && !entry.cleanupSync) {
+        try {
+            entry.identity = fsSync.lstatSync(tempPath, { bigint: true });
+        }
+        catch {
+            // Callers that register before creation set the identity after opening.
+        }
+    }
+    tempCleanupEntries.set(tempPath, entry);
+    const unregister = (() => {
+        if (tempCleanupEntries.get(tempPath) === entry)
+            tempCleanupEntries.delete(tempPath);
+    });
+    unregister.setIdentity = (identity) => {
+        entry.identity = identity;
+    };
+    return unregister;
+}
+export function __cleanupRegisteredTempPathsForTest() {
+    cleanupRegisteredTempPathsSync();
+}
+export function __cleanupRegisteredTempPathForTest(tempPath) {
+    const entry = tempCleanupEntries.get(tempPath);
+    if (!entry) {
+        return;
+    }
+    try {
+        cleanupEntrySync(entry);
+    }
+    finally {
+        tempCleanupEntries.delete(tempPath);
+    }
+}

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

@@ -0,0 +1,28 @@
+export type TempFile = {
+    dir: string;
+    path: string;
+    file(fileName?: string): string;
+    cleanup: () => Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+};
+export declare function sanitizeTempFileName(fileName: string): string;
+export declare function buildRandomTempFilePath(params: {
+    rootDir?: string;
+    prefix: string;
+    extension?: string;
+    now?: number;
+    uuid?: string;
+}): string;
+export declare function tempFile(params: {
+    rootDir?: string;
+    prefix: string;
+    fileName?: string;
+    onCleanupError?: (error: unknown) => void;
+}): Promise<TempFile>;
+export declare function withTempFile<T>(params: {
+    rootDir?: string;
+    prefix: string;
+    fileName?: string;
+    onCleanupError?: (error: unknown) => void;
+}, fn: (tmpPath: string) => Promise<T>): Promise<T>;
+//# sourceMappingURL=temp-target.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"temp-target.d.ts","sourceRoot":"","sources":["../src/temp-target.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,QAAQ,GAAG;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAChC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxC,CAAC;AA8DF,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAI7D;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE;IAC9C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,GAAG,MAAM,CAaT;AAsCD,wBAAsB,QAAQ,CAAC,MAAM,EAAE;IACrC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAC3C,GAAG,OAAO,CAAC,QAAQ,CAAC,CAwBpB;AAED,wBAAsB,YAAY,CAAC,CAAC,EAClC,MAAM,EAAE;IACN,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAC3C,EACD,EAAE,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,GAClC,OAAO,CAAC,CAAC,CAAC,CAOZ"}

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

@@ -0,0 +1,137 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { sameFileIdentityForCleanup } from "./file-identity.js";
+import { assertSafePathSegment, sanitizeSafePathSegment, trimHyphenEdges } from "./safe-path-segment.js";
+import { resolveSecureTempRoot } from "./secure-temp-dir.js";
+import { registerTempPathForExit } from "./temp-cleanup.js";
+const HYPHEN_CHAR_CODE = 0x2d;
+const DOT_CHAR_CODE = 0x2e;
+const NUMBER_ZERO_CHAR_CODE = 0x30;
+const NUMBER_NINE_CHAR_CODE = 0x39;
+const UPPERCASE_A_CHAR_CODE = 0x41;
+const UPPERCASE_Z_CHAR_CODE = 0x5a;
+const UNDERSCORE_CHAR_CODE = 0x5f;
+const LOWERCASE_A_CHAR_CODE = 0x61;
+const LOWERCASE_Z_CHAR_CODE = 0x7a;
+function isExtensionCharCode(charCode) {
+    return ((charCode >= NUMBER_ZERO_CHAR_CODE && charCode <= NUMBER_NINE_CHAR_CODE) ||
+        (charCode >= UPPERCASE_A_CHAR_CODE && charCode <= UPPERCASE_Z_CHAR_CODE) ||
+        (charCode >= LOWERCASE_A_CHAR_CODE && charCode <= LOWERCASE_Z_CHAR_CODE) ||
+        charCode === DOT_CHAR_CODE ||
+        charCode === UNDERSCORE_CHAR_CODE ||
+        charCode === HYPHEN_CHAR_CODE);
+}
+function trailingExtensionChars(value) {
+    let start = value.length;
+    while (start > 0 && isExtensionCharCode(value.charCodeAt(start - 1))) {
+        start -= 1;
+    }
+    return start === value.length ? "" : value.slice(start);
+}
+function trimLeadingExtensionPunctuation(value) {
+    let start = 0;
+    while (start < value.length) {
+        const charCode = value.charCodeAt(start);
+        if (charCode !== DOT_CHAR_CODE &&
+            charCode !== UNDERSCORE_CHAR_CODE &&
+            charCode !== HYPHEN_CHAR_CODE) {
+            break;
+        }
+        start += 1;
+    }
+    return start === 0 ? value : value.slice(start);
+}
+function sanitizePrefix(prefix) {
+    const normalized = trimHyphenEdges(prefix.replace(/[^a-zA-Z0-9_-]+/g, "-"));
+    return normalized || "tmp";
+}
+function sanitizeExtension(extension) {
+    if (!extension) {
+        return "";
+    }
+    const normalized = extension.startsWith(".") ? extension : `.${extension}`;
+    const suffix = trailingExtensionChars(normalized);
+    const token = trimLeadingExtensionPunctuation(suffix);
+    return token ? `.${token}` : "";
+}
+export function sanitizeTempFileName(fileName) {
+    return sanitizeSafePathSegment(path.basename(fileName), "download.bin", {
+        allowDotPrefix: true,
+    });
+}
+export function buildRandomTempFilePath(params) {
+    const rootDir = resolveTempRoot(params.rootDir);
+    const prefix = sanitizePrefix(params.prefix);
+    const extension = sanitizeExtension(params.extension);
+    const nowCandidate = params.now;
+    const now = typeof nowCandidate === "number" && Number.isFinite(nowCandidate)
+        ? Math.trunc(nowCandidate)
+        : Date.now();
+    const uuid = params.uuid
+        ? assertSafePathSegment(params.uuid.trim(), { label: "temp uuid" })
+        : crypto.randomUUID();
+    return path.join(rootDir, `${prefix}-${now}-${uuid}${extension}`);
+}
+function isNodeErrorWithCode(err, code) {
+    return (typeof err === "object" &&
+        err !== null &&
+        "code" in err &&
+        err.code === code);
+}
+async function cleanupTempDir(dir, identity, onCleanupError) {
+    try {
+        const current = await fs.lstat(dir, { bigint: true }).catch((error) => {
+            if (isNodeErrorWithCode(error, "ENOENT")) {
+                return undefined;
+            }
+            throw error;
+        });
+        if (!current || !sameFileIdentityForCleanup(current, identity)) {
+            return;
+        }
+        await fs.rm(dir, { recursive: true, force: true });
+    }
+    catch (err) {
+        if (!isNodeErrorWithCode(err, "ENOENT")) {
+            onCleanupError?.(err);
+        }
+    }
+}
+function resolveTempRoot(rootDir) {
+    return path.resolve(rootDir ?? resolveSecureTempRoot({ fallbackPrefix: "fs-safe" }));
+}
+export async function tempFile(params) {
+    const rootDir = resolveTempRoot(params.rootDir);
+    const prefix = `${sanitizePrefix(params.prefix)}-`;
+    const dir = await fs.mkdtemp(path.join(rootDir, prefix));
+    // Windows file indexes can exceed Number.MAX_SAFE_INTEGER. Cleanup receipts
+    // must retain the exact identity or adjacent directories can compare equal.
+    const identity = await fs.lstat(dir, { bigint: true });
+    const unregisterTempDir = registerTempPathForExit(dir, { recursive: true, identity });
+    const file = (fileName) => path.join(dir, sanitizeTempFileName(fileName ?? params.fileName ?? "download.bin"));
+    const cleanup = async () => {
+        try {
+            await cleanupTempDir(dir, identity, params.onCleanupError);
+        }
+        finally {
+            unregisterTempDir();
+        }
+    };
+    return {
+        dir,
+        path: file(),
+        file,
+        cleanup,
+        [Symbol.asyncDispose]: cleanup,
+    };
+}
+export async function withTempFile(params, fn) {
+    const target = await tempFile(params);
+    try {
+        return await fn(target.path);
+    }
+    finally {
+        await target.cleanup();
+    }
+}

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

@@ -0,0 +1,23 @@
+import { type FileIdentityStat } from "./file-identity.js";
+import { type NativeBinding } from "./native.js";
+import { openStagedDirectory } from "./staged-directory.js";
+export type TempWorkspaceCleanupResult = "removed" | "missing" | "identity-mismatch" | "indeterminate";
+export type TempWorkspaceCleanupSafety = "compatible" | "require-bounded";
+type RetainedDirectory = ReturnType<typeof openStagedDirectory>;
+export declare class TempWorkspaceCleanupCapability {
+    #private;
+    readonly binding: NativeBinding | undefined;
+    readonly parent: RetainedDirectory | undefined;
+    constructor(root: string, safety: TempWorkspaceCleanupSafety);
+    get canRemoveOwnedTree(): boolean;
+    assertCurrent(): void;
+    close(): void;
+}
+export declare class TempWorkspaceCleanupOwner {
+    #private;
+    constructor(dir: string, identity: FileIdentityStat, capability: TempWorkspaceCleanupCapability);
+    cleanup(): Promise<TempWorkspaceCleanupResult>;
+    cleanupSync(): TempWorkspaceCleanupResult;
+}
+export {};
+//# sourceMappingURL=temp-workspace-owner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"temp-workspace-owner.d.ts","sourceRoot":"","sources":["../src/temp-workspace-owner.ts"],"names":[],"mappings":"AAMA,OAAO,EAA8B,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEvF,OAAO,EAAoB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAEnE,OAAO,EAAgC,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAG1F,MAAM,MAAM,0BAA0B,GAAG,SAAS,GAAG,SAAS,GAAG,mBAAmB,GAAG,eAAe,CAAC;AACvG,MAAM,MAAM,0BAA0B,GAAG,YAAY,GAAG,iBAAiB,CAAC;AAE1E,KAAK,iBAAiB,GAAG,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAoBhE,qBAAa,8BAA8B;;IACzC,QAAQ,CAAC,OAAO,EAAE,aAAa,GAAG,SAAS,CAAC;IAC5C,QAAQ,CAAC,MAAM,EAAE,iBAAiB,GAAG,SAAS,CAAC;IAI/C,YAAY,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,0BAA0B,EAiC3D;IAED,IAAI,kBAAkB,IAAI,OAAO,CAEhC;IAED,aAAa,IAAI,IAAI,CASpB;IAED,KAAK,IAAI,IAAI,CAIZ;CACF;AAED,qBAAa,yBAAyB;;IAWpC,YAAY,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,gBAAgB,EAAE,UAAU,EAAE,8BAA8B,EAe9F;IAuLD,OAAO,IAAI,OAAO,CAAC,0BAA0B,CAAC,CAM7C;IAED,WAAW,IAAI,0BAA0B,CAexC;CACF"}