@openclaw/openshell-sandbox 2026.9.2 → 2026.9.4

package/node_modules/@openclaw/fs-safe/dist/secret-read-async.js

@@ -0,0 +1,73 @@
+import fsSync from "node:fs";
+import fs from "node:fs/promises";
+import { readFileHandleBounded } from "./bounded-read.js";
+import { assertNoUnsafeDeviceReadPath } from "./device-path.js";
+import { FsSafeError } from "./errors.js";
+import { resolveReadOpenFlags } from "./read-open-flags.js";
+import { inspectFileIdentity } from "./strict-file-identity.js";
+import { assertSecretFilePreview, resolveSecretReadPolicy, secretPathErrorCode, secretReadError, trimSecretFileContent, } from "./secret-read-policy.js";
+export async function readSecretFile(filePath, label, options = {}) {
+    const { resolvedPath, maxBytes } = resolveSecretReadPolicy(filePath, label, options);
+    async function inspectInput(symlinkMessage) {
+        const stat = options.rejectSymlink
+            ? await fs.lstat(resolvedPath, { bigint: true })
+            : await fs.stat(resolvedPath, { bigint: true });
+        if (options.rejectSymlink && stat.isSymbolicLink()) {
+            throw new FsSafeError("symlink", symlinkMessage);
+        }
+        return stat;
+    }
+    let previewStat;
+    try {
+        assertNoUnsafeDeviceReadPath(resolvedPath);
+        previewStat = await inspectFileIdentity(() => inspectInput(`${label} file at ${resolvedPath} must not be a symlink.`));
+    }
+    catch (error) {
+        throw secretReadError(error instanceof FsSafeError ? error.code : secretPathErrorCode(error), "inspect", label, resolvedPath, error);
+    }
+    assertSecretFilePreview(previewStat, label, resolvedPath, maxBytes, options.rejectHardlinks !== false);
+    let handle;
+    let raw;
+    try {
+        const realPath = await fs.realpath(resolvedPath);
+        assertNoUnsafeDeviceReadPath(realPath);
+        handle = await fs.open(realPath, resolveReadOpenFlags());
+        const openedHandle = handle;
+        const openedStat = await inspectFileIdentity(async () => {
+            const stat = await openedHandle.stat({ bigint: true });
+            if (!stat.isFile() || (options.rejectHardlinks !== false && stat.nlink > 1n)) {
+                throw new FsSafeError("path-mismatch", "security validation failed");
+            }
+            return stat;
+        }, previewStat);
+        await inspectFileIdentity(async () => {
+            const stat = await fs.lstat(realPath, { bigint: true });
+            if (!stat.isFile())
+                throw new FsSafeError("path-mismatch", "security validation failed");
+            return stat;
+        }, openedStat);
+        await inspectFileIdentity(() => inspectInput("secret path became a symlink"), openedStat);
+        raw = (await readFileHandleBounded(handle, maxBytes)).toString("utf8");
+    }
+    catch (error) {
+        throw secretReadError(error instanceof FsSafeError
+            ? error.code
+            : secretPathErrorCode(error) === "not-found" ? "not-found" : "read-failed", "read", label, resolvedPath, error);
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+    return trimSecretFileContent(raw, label, resolvedPath);
+}
+export async function tryReadSecretFile(filePath, label, options = {}) {
+    if (!filePath?.trim())
+        return undefined;
+    try {
+        return await readSecretFile(filePath, label, options);
+    }
+    catch (error) {
+        if (error instanceof FsSafeError && error.code === "not-found")
+            return undefined;
+        throw error;
+    }
+}

package/node_modules/@openclaw/fs-safe/dist/secret-read-policy.d.ts

@@ -0,0 +1,17 @@
+import type { BigIntStats } from "node:fs";
+import { FsSafeError, type FsSafeErrorCode } from "./errors.js";
+export declare const DEFAULT_SECRET_FILE_MAX_BYTES: number;
+export type SecretFileReadOptions = {
+    maxBytes?: number;
+    rejectSymlink?: boolean;
+    rejectHardlinks?: boolean;
+};
+export declare function secretPathErrorCode(error: unknown): FsSafeErrorCode;
+export declare function secretReadError(code: FsSafeErrorCode, action: "inspect" | "read", label: string, resolvedPath: string, error: unknown): FsSafeError;
+export declare function assertSecretFilePreview(stat: BigIntStats, label: string, resolvedPath: string, maxBytes: number, rejectHardlinks: boolean): void;
+export declare function trimSecretFileContent(raw: string, label: string, resolvedPath: string): string;
+export declare function resolveSecretReadPolicy(filePath: string, label: string, options: SecretFileReadOptions): {
+    resolvedPath: string;
+    maxBytes: number;
+};
+//# sourceMappingURL=secret-read-policy.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/secret-read-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secret-read-policy.d.ts","sourceRoot":"","sources":["../src/secret-read-policy.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,EAAE,WAAW,EAAE,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAEhE,eAAO,MAAM,6BAA6B,QAAY,CAAC;AAEvD,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAGnE;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,eAAe,EACrB,MAAM,EAAE,SAAS,GAAG,MAAM,EAC1B,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,OAAO,GACb,WAAW,CAGb;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,EAChB,eAAe,EAAE,OAAO,GACvB,IAAI,CAUN;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAM9F;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,qBAAqB,GAAG;IACxG,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;CAClB,CASA"}

package/node_modules/@openclaw/fs-safe/dist/secret-read-policy.js

@@ -0,0 +1,40 @@
+import { normalizeMaxBytes } from "./byte-budget.js";
+import { resolveHomeRelativePath } from "./home-dir.js";
+import { FsSafeError } from "./errors.js";
+export const DEFAULT_SECRET_FILE_MAX_BYTES = 16 * 1024;
+export function secretPathErrorCode(error) {
+    const code = error.code;
+    return code === "ENOENT" || code === "ENOTDIR" ? "not-found" : "invalid-path";
+}
+export function secretReadError(code, action, label, resolvedPath, error) {
+    const cause = error instanceof Error ? error : new Error(String(error));
+    return new FsSafeError(code, `Failed to ${action} ${label} file at ${resolvedPath}: ${String(cause)}`, { cause });
+}
+export function assertSecretFilePreview(stat, label, resolvedPath, maxBytes, rejectHardlinks) {
+    if (!stat.isFile()) {
+        throw new FsSafeError("not-file", `${label} file at ${resolvedPath} must be a regular file.`, { cause: undefined });
+    }
+    if (rejectHardlinks && stat.nlink > 1n) {
+        throw new FsSafeError("hardlink", `${label} file at ${resolvedPath} must not be hardlinked.`, { cause: undefined });
+    }
+    if (stat.size > maxBytes) {
+        throw new FsSafeError("too-large", `${label} file at ${resolvedPath} exceeds ${maxBytes} bytes.`, { cause: undefined });
+    }
+}
+export function trimSecretFileContent(raw, label, resolvedPath) {
+    const secret = raw.trim();
+    if (!secret) {
+        throw new FsSafeError("invalid-path", `${label} file at ${resolvedPath} is empty.`, { cause: undefined });
+    }
+    return secret;
+}
+export function resolveSecretReadPolicy(filePath, label, options) {
+    const resolvedPath = resolveHomeRelativePath(filePath.trim());
+    if (!resolvedPath) {
+        throw new FsSafeError("invalid-path", `${label} file path is empty.`, { cause: undefined });
+    }
+    const maxBytes = normalizeMaxBytes(options.maxBytes, {
+        defaultValue: DEFAULT_SECRET_FILE_MAX_BYTES,
+    });
+    return { resolvedPath, maxBytes };
+}

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

@@ -0,0 +1,4 @@
+export { createSecretFileAtomic, PRIVATE_SECRET_DIR_MODE, PRIVATE_SECRET_FILE_MODE, readSecretFileSync, tryReadSecretFileSync, writeSecretFileAtomic, } from "./secret-file.js";
+export { DEFAULT_SECRET_FILE_MAX_BYTES, type SecretFileReadOptions } from "./secret-read-policy.js";
+export { readSecretFile, tryReadSecretFile } from "./secret-read-async.js";
+//# sourceMappingURL=secret.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"secret.d.ts","sourceRoot":"","sources":["../src/secret.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,uBAAuB,EACvB,wBAAwB,EACxB,kBAAkB,EAClB,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,6BAA6B,EAAE,KAAK,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AACpG,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC"}

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

@@ -0,0 +1,3 @@
+export { createSecretFileAtomic, PRIVATE_SECRET_DIR_MODE, PRIVATE_SECRET_FILE_MODE, readSecretFileSync, tryReadSecretFileSync, writeSecretFileAtomic, } from "./secret-file.js";
+export { DEFAULT_SECRET_FILE_MAX_BYTES } from "./secret-read-policy.js";
+export { readSecretFile, tryReadSecretFile } from "./secret-read-async.js";

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

@@ -0,0 +1,32 @@
+import type { Stats } from "node:fs";
+import { type PermissionCheck, type PermissionCheckOptions } from "./permissions.js";
+export type SecureFileReadOptions = {
+    filePath: string;
+    label?: string;
+    trust?: SecureFileTrustOptions;
+    permissions?: SecureFilePermissionOptions;
+    inject?: SecureFileInjectOptions;
+    io?: SecureFileIoOptions;
+};
+export type SecureFileTrustOptions = {
+    trustedDirs?: string[];
+    allowSymlink?: boolean;
+    allowNetworkPath?: boolean;
+};
+export type SecureFilePermissionOptions = {
+    allowInsecure?: boolean;
+    allowReadableByOthers?: boolean;
+};
+export type SecureFileInjectOptions = PermissionCheckOptions;
+export type SecureFileIoOptions = {
+    maxBytes?: number;
+    timeoutMs?: number;
+};
+export type SecureFileReadResult = {
+    buffer: Buffer;
+    realPath: string;
+    stat: Stats;
+    permissions?: PermissionCheck;
+};
+export declare function readSecureFile(options: SecureFileReadOptions): Promise<SecureFileReadResult>;
+//# sourceMappingURL=secure-file.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"secure-file.d.ts","sourceRoot":"","sources":["../src/secure-file.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAarC,OAAO,EAOL,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC5B,MAAM,kBAAkB,CAAC;AAG1B,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,sBAAsB,CAAC;IAC/B,WAAW,CAAC,EAAE,2BAA2B,CAAC;IAC1C,MAAM,CAAC,EAAE,uBAAuB,CAAC;IACjC,EAAE,CAAC,EAAE,mBAAmB,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG;IACxC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,sBAAsB,CAAC;AAE7D,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,KAAK,CAAC;IACZ,WAAW,CAAC,EAAE,eAAe,CAAC;CAC/B,CAAC;AA4LF,wBAAsB,cAAc,CAClC,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,oBAAoB,CAAC,CAe/B"}

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

@@ -0,0 +1,182 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { readFileHandleBounded } from "./bounded-read.js";
+import { normalizeMaxBytes } from "./byte-budget.js";
+import { assertNoUnsafeDeviceReadPath } from "./device-path.js";
+import { FsSafeError } from "./errors.js";
+import { isWindowsDriveLetterPath, isWindowsNetworkPath } from "./local-file-access.js";
+import { isPathInside, isSymlinkOpenError } from "./path.js";
+import { formatPermissionErrorDetail } from "./permission-exec.js";
+import { resolveReadOpenFlags } from "./read-open-flags.js";
+import { inspectPathPermissions, isGroupReadable, isGroupWritable, isWorldReadable, isWorldWritable, modeBits, } from "./permissions.js";
+import { inspectFileIdentity } from "./strict-file-identity.js";
+function isAbsolutePathname(value) {
+    return (path.isAbsolute(value) ||
+        (process.platform === "win32" &&
+            (isWindowsDriveLetterPath(value, "win32") || isWindowsNetworkPath(value, "win32"))));
+}
+function label(options) {
+    return options.label ?? "Secure file";
+}
+async function openSecureHandle(options, maxBytes) {
+    assertNoUnsafeDeviceReadPath(options.filePath);
+    if (isWindowsNetworkPath(options.filePath, "win32") && !options.trust?.allowNetworkPath) {
+        throw new FsSafeError("invalid-path", `${label(options)} must be a local absolute path.`);
+    }
+    if (!isAbsolutePathname(options.filePath)) {
+        throw new FsSafeError("invalid-path", `${label(options)} must be an absolute path.`);
+    }
+    const preStat = await fs.lstat(options.filePath).catch((err) => {
+        throw new FsSafeError("not-found", `${label(options)} is not readable: ${options.filePath}`, {
+            cause: err,
+        });
+    });
+    if (preStat.isSymbolicLink()) {
+        if (!options.trust?.allowSymlink) {
+            throw new FsSafeError("symlink", `${label(options)} must not be a symlink: ${options.filePath}`);
+        }
+    }
+    else if (!preStat.isFile()) {
+        throw new FsSafeError("not-file", `${label(options)} must be a file: ${options.filePath}`);
+    }
+    let handle;
+    try {
+        handle = await fs.open(options.filePath, resolveReadOpenFlags({
+            followSymlinks: options.trust?.allowSymlink === true,
+        }));
+    }
+    catch (err) {
+        if (isSymlinkOpenError(err)) {
+            throw new FsSafeError("symlink", `${label(options)} symlink open blocked`, { cause: err });
+        }
+        throw err;
+    }
+    try {
+        const openedStat = await handle.stat();
+        if (!openedStat.isFile()) {
+            throw new FsSafeError("not-file", `${label(options)} must be a file: ${options.filePath}`);
+        }
+        const openedIdentity = await inspectFileIdentity(() => handle.stat({ bigint: true }));
+        await inspectFileIdentity(async () => {
+            const pathStat = options.trust?.allowSymlink
+                ? await fs.stat(options.filePath, { bigint: true })
+                : await fs.lstat(options.filePath, { bigint: true });
+            if (!options.trust?.allowSymlink && pathStat.isSymbolicLink()) {
+                throw new FsSafeError("symlink", `${label(options)} must not be a symlink: ${options.filePath}`);
+            }
+            return pathStat;
+        }, openedIdentity);
+        const realPath = await fs.realpath(options.filePath);
+        await inspectFileIdentity(() => fs.stat(realPath, { bigint: true }), openedIdentity);
+        if (maxBytes !== undefined && openedStat.size > maxBytes) {
+            throw new FsSafeError("too-large", `${label(options)} exceeded maxBytes (${maxBytes}).`);
+        }
+        return { handle, pathStat: openedStat, realPath };
+    }
+    catch (err) {
+        await handle.close().catch(() => undefined);
+        throw err;
+    }
+}
+async function assertTrustedDirs(options, realPath) {
+    if (!options.trust?.trustedDirs || options.trust.trustedDirs.length === 0) {
+        return;
+    }
+    const trusted = await Promise.all(options.trust.trustedDirs.map(async (dir) => {
+        const resolved = path.resolve(dir);
+        return await fs.realpath(resolved).catch(() => resolved);
+    }));
+    if (!trusted.some((dir) => isPathInside(dir, realPath))) {
+        throw new FsSafeError("outside-workspace", `${label(options)} is outside trustedDirs: ${realPath}`);
+    }
+}
+function inspectOpenedPermissions(stat, platform) {
+    const bits = modeBits(typeof stat.mode === "number" ? stat.mode : null);
+    return {
+        ok: true,
+        isSymlink: false,
+        isDir: stat.isDirectory(),
+        mode: typeof stat.mode === "number" ? stat.mode : null,
+        bits,
+        source: platform === "win32" ? "unknown" : "posix",
+        worldWritable: isWorldWritable(bits),
+        groupWritable: isGroupWritable(bits),
+        worldReadable: isWorldReadable(bits),
+        groupReadable: isGroupReadable(bits),
+    };
+}
+async function assertSecurePermissions(options, stat, realPath) {
+    if (options.permissions?.allowInsecure) {
+        return undefined;
+    }
+    const platform = options.inject?.platform ?? process.platform;
+    const permissions = platform === "win32"
+        ? await inspectPathPermissions(realPath, options.inject)
+        : inspectOpenedPermissions(stat, platform);
+    const reason = permissions.error ? `: ${formatPermissionErrorDetail(permissions.error)}` : "";
+    const diagnostics = {
+        ...(permissions.errorCause !== undefined ? { cause: permissions.errorCause } : {}),
+        ...(permissions.ownerError || permissions.errorDetail ? {
+            details: {
+                ...(permissions.ownerError ? { ownerError: formatPermissionErrorDetail(permissions.ownerError) } : {}),
+                ...permissions.errorDetail,
+            },
+        } : {}),
+    };
+    if (!permissions.ok) {
+        throw new FsSafeError("permission-unverified", `${label(options)} permissions could not be verified: ${realPath}${reason}`, diagnostics);
+    }
+    if (platform === "win32" && permissions.source === "unknown") {
+        throw new FsSafeError("permission-unverified", `${label(options)} ACL verification unavailable on Windows for ${realPath}${reason || "."}`, diagnostics);
+    }
+    if (platform === "win32" && permissions.ownerTrusted !== true) {
+        throw new FsSafeError(permissions.ownerTrusted === false ? "not-owned" : "permission-unverified", `${label(options)} owner could not be trusted on Windows: ${realPath}`);
+    }
+    const writableByOthers = permissions.worldWritable || permissions.groupWritable;
+    const readableByOthers = permissions.worldReadable || permissions.groupReadable;
+    if (writableByOthers || (!options.permissions?.allowReadableByOthers && readableByOthers)) {
+        throw new FsSafeError("insecure-permissions", `${label(options)} permissions are too open: ${realPath}`);
+    }
+    if (platform !== "win32" && typeof process.getuid === "function" && stat.uid != null) {
+        const uid = process.getuid();
+        if (stat.uid !== uid) {
+            throw new FsSafeError("not-owned", `${label(options)} must be owned by the current user (uid=${uid}): ${realPath}`);
+        }
+    }
+    return permissions;
+}
+async function readHandleWithTimeout(handle, timeoutMs, maxBytes) {
+    const read = () => maxBytes === undefined ? handle.readFile() : readFileHandleBounded(handle, maxBytes);
+    if (timeoutMs === undefined || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+        return await read();
+    }
+    let timeout;
+    try {
+        return await Promise.race([
+            read(),
+            new Promise((_resolve, reject) => {
+                timeout = setTimeout(() => {
+                    void handle.close().catch(() => undefined);
+                    reject(new FsSafeError("timeout", `secure file read timed out after ${timeoutMs}ms`));
+                }, timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+    }
+}
+export async function readSecureFile(options) {
+    const maxBytes = normalizeMaxBytes(options.io?.maxBytes);
+    const opened = await openSecureHandle(options, maxBytes);
+    try {
+        await assertTrustedDirs(options, opened.realPath);
+        const permissions = await assertSecurePermissions(options, opened.pathStat, opened.realPath);
+        const buffer = await readHandleWithTimeout(opened.handle, options.io?.timeoutMs, maxBytes);
+        return { buffer, realPath: opened.realPath, stat: opened.pathStat, permissions };
+    }
+    finally {
+        await opened.handle.close().catch(() => undefined);
+    }
+}

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

@@ -0,0 +1,27 @@
+type SecureDirStat = {
+    isDirectory(): boolean;
+    isSymbolicLink(): boolean;
+    mode?: number;
+    uid?: number;
+};
+export type ResolveSecureTempRootOptions = {
+    accessSync?: (path: string, mode?: number) => void;
+    chmodSync?: (path: string, mode: number) => void;
+    fallbackPrefix: string;
+    getuid?: () => number | undefined;
+    lstatSync?: (path: string) => SecureDirStat;
+    mkdirSync?: (path: string, opts: {
+        recursive: boolean;
+        mode?: number;
+    }) => void;
+    platform?: NodeJS.Platform;
+    preferredDir?: string;
+    skipPreferredOnWindows?: boolean;
+    tmpdir?: () => string;
+    unsafeFallbackLabel?: string;
+    warn?: (message: string) => void;
+    warningPrefix?: string;
+};
+export declare function resolveSecureTempRoot(options: ResolveSecureTempRootOptions): string;
+export {};
+//# sourceMappingURL=secure-temp-dir.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"secure-temp-dir.d.ts","sourceRoot":"","sources":["../src/secure-temp-dir.ts"],"names":[],"mappings":"AAOA,KAAK,aAAa,GAAG;IACnB,WAAW,IAAI,OAAO,CAAC;IACvB,cAAc,IAAI,OAAO,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACzC,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACnD,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACjD,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IAClC,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,aAAa,CAAC;IAC5C,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IAChF,QAAQ,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC;IACtB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAWF,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,4BAA4B,GAAG,MAAM,CA8JnF"}

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

@@ -0,0 +1,160 @@
+import fs from "node:fs";
+import { tmpdir as getOsTmpDir } from "node:os";
+import path from "node:path";
+import { assertSafePathSegment } from "./safe-path-segment.js";
+function isNodeErrorWithCode(err, code) {
+    return (typeof err === "object" &&
+        err !== null &&
+        "code" in err &&
+        err.code === code);
+}
+export function resolveSecureTempRoot(options) {
+    const fallbackPrefix = assertSafePathSegment(options.fallbackPrefix, {
+        allowDotPrefix: true,
+        label: "fallback temp prefix",
+    });
+    const TMP_DIR_ACCESS_MODE = fs.constants.W_OK | fs.constants.X_OK;
+    const accessSync = options.accessSync ?? fs.accessSync;
+    const chmodSync = options.chmodSync ?? fs.chmodSync;
+    const lstatSync = options.lstatSync ?? fs.lstatSync;
+    const mkdirSync = options.mkdirSync ?? fs.mkdirSync;
+    const warn = options.warn ?? ((message) => console.warn(message));
+    const warningPrefix = options.warningPrefix ?? "[fs-safe]";
+    const unsafeFallbackLabel = options.unsafeFallbackLabel ?? "secure temp dir";
+    const getuid = options.getuid ??
+        (() => {
+            try {
+                return typeof process.getuid === "function" ? process.getuid() : undefined;
+            }
+            catch {
+                return undefined;
+            }
+        });
+    const tmpdir = typeof options.tmpdir === "function" ? options.tmpdir : getOsTmpDir;
+    const platform = options.platform ?? process.platform;
+    const uid = getuid();
+    const isSecureDirForUser = (st) => {
+        if (uid === undefined) {
+            return true;
+        }
+        if (typeof st.uid === "number" && st.uid !== uid) {
+            return false;
+        }
+        if (typeof st.mode === "number" && (st.mode & 0o022) !== 0) {
+            return false;
+        }
+        return true;
+    };
+    const fallback = () => {
+        const base = tmpdir();
+        const suffix = uid === undefined ? fallbackPrefix : `${fallbackPrefix}-${uid}`;
+        const joiner = platform === "win32" ? path.win32.join : path.join;
+        return joiner(base, suffix);
+    };
+    const isTrustedTmpDir = (st) => {
+        return st.isDirectory() && !st.isSymbolicLink() && isSecureDirForUser(st);
+    };
+    const resolveDirState = (candidatePath) => {
+        try {
+            const candidate = lstatSync(candidatePath);
+            if (!isTrustedTmpDir(candidate)) {
+                return "invalid";
+            }
+            accessSync(candidatePath, TMP_DIR_ACCESS_MODE);
+            return "available";
+        }
+        catch (err) {
+            if (isNodeErrorWithCode(err, "ENOENT")) {
+                return "missing";
+            }
+            return "invalid";
+        }
+    };
+    const tryRepairWritableBits = (candidatePath) => {
+        try {
+            const st = lstatSync(candidatePath);
+            if (!st.isDirectory() || st.isSymbolicLink()) {
+                return false;
+            }
+            if (uid !== undefined && typeof st.uid === "number" && st.uid !== uid) {
+                return false;
+            }
+            if (typeof st.mode !== "number") {
+                return false;
+            }
+            if ((st.mode & 0o022) === 0) {
+                return resolveDirState(candidatePath) === "available";
+            }
+            try {
+                chmodSync(candidatePath, 0o700);
+            }
+            catch (chmodErr) {
+                if (isNodeErrorWithCode(chmodErr, "EPERM") ||
+                    isNodeErrorWithCode(chmodErr, "EACCES") ||
+                    isNodeErrorWithCode(chmodErr, "ENOENT")) {
+                    return resolveDirState(candidatePath) === "available";
+                }
+                throw chmodErr;
+            }
+            warn(`${warningPrefix} tightened permissions on temp dir: ${candidatePath}`);
+            return resolveDirState(candidatePath) === "available";
+        }
+        catch {
+            return false;
+        }
+    };
+    const ensureTrustedFallbackDir = () => {
+        const fallbackPath = fallback();
+        const state = resolveDirState(fallbackPath);
+        if (state === "available") {
+            return fallbackPath;
+        }
+        if (state === "invalid") {
+            if (tryRepairWritableBits(fallbackPath)) {
+                return fallbackPath;
+            }
+            throw new Error(`Unsafe fallback ${unsafeFallbackLabel}: ${fallbackPath}`);
+        }
+        try {
+            mkdirSync(fallbackPath, { recursive: true, mode: 0o700 });
+            chmodSync(fallbackPath, 0o700);
+        }
+        catch {
+            throw new Error(`Unable to create fallback ${unsafeFallbackLabel}: ${fallbackPath}`);
+        }
+        if (resolveDirState(fallbackPath) !== "available" && !tryRepairWritableBits(fallbackPath)) {
+            throw new Error(`Unsafe fallback ${unsafeFallbackLabel}: ${fallbackPath}`);
+        }
+        return fallbackPath;
+    };
+    if (options.skipPreferredOnWindows === true && platform === "win32") {
+        return ensureTrustedFallbackDir();
+    }
+    if (!options.preferredDir) {
+        return ensureTrustedFallbackDir();
+    }
+    const existingPreferredState = resolveDirState(options.preferredDir);
+    if (existingPreferredState === "available") {
+        return options.preferredDir;
+    }
+    if (existingPreferredState === "invalid") {
+        if (tryRepairWritableBits(options.preferredDir)) {
+            return options.preferredDir;
+        }
+        return ensureTrustedFallbackDir();
+    }
+    try {
+        const preferredParentDir = path.dirname(options.preferredDir);
+        accessSync(preferredParentDir, TMP_DIR_ACCESS_MODE);
+        mkdirSync(options.preferredDir, { recursive: true, mode: 0o700 });
+        chmodSync(options.preferredDir, 0o700);
+        if (resolveDirState(options.preferredDir) !== "available" &&
+            !tryRepairWritableBits(options.preferredDir)) {
+            return ensureTrustedFallbackDir();
+        }
+        return options.preferredDir;
+    }
+    catch {
+        return ensureTrustedFallbackDir();
+    }
+}

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

@@ -0,0 +1,15 @@
+export declare function writeCallbackSibling<T>(params: {
+    tempPath: string;
+    write: (tempPath: string) => Promise<T>;
+    resolveFinalPath: (result: T) => string;
+    mode?: number;
+    /** Preserve the caller's historical best-effort mode behavior. */
+    ignoreModeError?: boolean;
+    maxBytes?: number;
+    syncTempFile: boolean;
+    syncParentDir: boolean;
+}): Promise<{
+    filePath: string;
+    result: T;
+}>;
+//# sourceMappingURL=sibling-staged-file.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sibling-staged-file.d.ts","sourceRoot":"","sources":["../src/sibling-staged-file.ts"],"names":[],"mappings":"AAmCA,wBAAsB,oBAAoB,CAAC,CAAC,EAAE,MAAM,EAAE;IACpD,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;IACxC,gBAAgB,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,MAAM,CAAC;IACxC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kEAAkE;IAClE,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;IACtB,aAAa,EAAE,OAAO,CAAC;CACxB,GAAG,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,CAAC,CAAA;CAAE,CAAC,CAyG3C"}