@openclaw/fs-safe 0.2.4 → 0.2.5

package/dist/secure-temp-workspace.d.ts

@@ -1,25 +0,0 @@
-export type SecureTempWorkspaceOptions = {
-    rootDir: string;
-    prefix: string;
-    dirMode?: number;
-    fileMode?: number;
-};
-export type SecureTempWorkspace = {
-    dir: string;
-    path(fileName: string): string;
-    writePrivate(fileName: string, data: string | Uint8Array): Promise<string>;
-    read(fileName: string): Promise<Buffer>;
-    cleanup(): Promise<void>;
-};
-export type SecureTempWorkspaceSync = {
-    dir: string;
-    path(fileName: string): string;
-    writePrivate(fileName: string, data: string | Uint8Array): string;
-    read(fileName: string): Buffer;
-    cleanup(): void;
-};
-export declare function createSecureTempWorkspace(options: SecureTempWorkspaceOptions): Promise<SecureTempWorkspace>;
-export declare function withSecureTempWorkspace<T>(options: SecureTempWorkspaceOptions, run: (workspace: SecureTempWorkspace) => Promise<T>): Promise<T>;
-export declare function createSecureTempWorkspaceSync(options: SecureTempWorkspaceOptions): SecureTempWorkspaceSync;
-export declare function withSecureTempWorkspaceSync<T>(options: SecureTempWorkspaceOptions, run: (workspace: SecureTempWorkspaceSync) => T): T;
-//# sourceMappingURL=secure-temp-workspace.d.ts.map

package/dist/secure-temp-workspace.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"secure-temp-workspace.d.ts","sourceRoot":"","sources":["../src/secure-temp-workspace.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,0BAA0B,GAAG;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAC/B,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC3E,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACxC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAC/B,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,CAAC;IAClE,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAC/B,OAAO,IAAI,IAAI,CAAC;CACjB,CAAC;AAgDF,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,mBAAmB,CAAC,CA0B9B;AAED,wBAAsB,uBAAuB,CAAC,CAAC,EAC7C,OAAO,EAAE,0BAA0B,EACnC,GAAG,EAAE,CAAC,SAAS,EAAE,mBAAmB,KAAK,OAAO,CAAC,CAAC,CAAC,GAClD,OAAO,CAAC,CAAC,CAAC,CAUZ;AAED,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,0BAA0B,GAClC,uBAAuB,CAsCzB;AAED,wBAAgB,2BAA2B,CAAC,CAAC,EAC3C,OAAO,EAAE,0BAA0B,EACnC,GAAG,EAAE,CAAC,SAAS,EAAE,uBAAuB,KAAK,CAAC,GAC7C,CAAC,CAUH"}

package/dist/secure-temp-workspace.js

@@ -1,136 +0,0 @@
-import { randomUUID } from "node:crypto";
-import fsSync from "node:fs";
-import fs from "node:fs/promises";
-import path from "node:path";
-function sanitizeTempPrefix(prefix) {
-    const sanitized = prefix.trim().replace(/[^a-zA-Z0-9._-]/g, "-");
-    if (!sanitized || sanitized === "." || sanitized === "..") {
-        return "fs-safe-";
-    }
-    return sanitized.endsWith("-") ? sanitized : `${sanitized}-`;
-}
-function resolveWorkspaceLeaf(dir, fileName) {
-    const raw = fileName.trim();
-    if (!raw ||
-        raw === "." ||
-        raw === ".." ||
-        raw.includes("\0") ||
-        raw.includes("/") ||
-        raw.includes("\\") ||
-        path.basename(raw) !== raw) {
-        throw new Error(`Invalid temp workspace file name: ${JSON.stringify(fileName)}`);
-    }
-    return path.join(dir, raw);
-}
-async function ensurePrivateDirectory(dir, mode) {
-    await fs.mkdir(dir, { recursive: true, mode });
-    const stat = await fs.lstat(dir);
-    if (stat.isSymbolicLink() || !stat.isDirectory()) {
-        throw new Error(`Temp root must be a directory: ${dir}`);
-    }
-    await fs.chmod(dir, mode).catch(() => undefined);
-}
-function ensurePrivateDirectorySync(dir, mode) {
-    fsSync.mkdirSync(dir, { recursive: true, mode });
-    const stat = fsSync.lstatSync(dir);
-    if (stat.isSymbolicLink() || !stat.isDirectory()) {
-        throw new Error(`Temp root must be a directory: ${dir}`);
-    }
-    try {
-        fsSync.chmodSync(dir, mode);
-    }
-    catch {
-        // Best-effort on platforms that do not enforce POSIX modes.
-    }
-}
-export async function createSecureTempWorkspace(options) {
-    const dirMode = options.dirMode ?? 0o700;
-    const fileMode = options.fileMode ?? 0o600;
-    const root = path.resolve(options.rootDir);
-    await ensurePrivateDirectory(root, dirMode);
-    const dir = await fs.mkdtemp(path.join(root, sanitizeTempPrefix(options.prefix)));
-    await fs.chmod(dir, dirMode).catch(() => undefined);
-    const stat = await fs.lstat(dir);
-    if (stat.isSymbolicLink() || !stat.isDirectory()) {
-        throw new Error(`Temp workspace must be a directory: ${dir}`);
-    }
-    return {
-        dir,
-        path: (fileName) => resolveWorkspaceLeaf(dir, fileName),
-        writePrivate: async (fileName, data) => {
-            const filePath = resolveWorkspaceLeaf(dir, fileName);
-            await fs.writeFile(filePath, data, { mode: fileMode, flag: "wx" });
-            await fs.chmod(filePath, fileMode).catch(() => undefined);
-            return filePath;
-        },
-        read: async (fileName) => await fs.readFile(resolveWorkspaceLeaf(dir, fileName)),
-        cleanup: async () => {
-            await fs.rm(dir, { recursive: true, force: true }).catch(() => undefined);
-        },
-    };
-}
-export async function withSecureTempWorkspace(options, run) {
-    const workspace = await createSecureTempWorkspace({
-        ...options,
-        prefix: `${sanitizeTempPrefix(options.prefix)}${randomUUID()}-`,
-    });
-    try {
-        return await run(workspace);
-    }
-    finally {
-        await workspace.cleanup();
-    }
-}
-export function createSecureTempWorkspaceSync(options) {
-    const dirMode = options.dirMode ?? 0o700;
-    const fileMode = options.fileMode ?? 0o600;
-    const root = path.resolve(options.rootDir);
-    ensurePrivateDirectorySync(root, dirMode);
-    const dir = fsSync.mkdtempSync(path.join(root, sanitizeTempPrefix(options.prefix)));
-    try {
-        fsSync.chmodSync(dir, dirMode);
-    }
-    catch {
-        // Best-effort on platforms that do not enforce POSIX modes.
-    }
-    const stat = fsSync.lstatSync(dir);
-    if (stat.isSymbolicLink() || !stat.isDirectory()) {
-        throw new Error(`Temp workspace must be a directory: ${dir}`);
-    }
-    return {
-        dir,
-        path: (fileName) => resolveWorkspaceLeaf(dir, fileName),
-        writePrivate: (fileName, data) => {
-            const filePath = resolveWorkspaceLeaf(dir, fileName);
-            fsSync.writeFileSync(filePath, data, { mode: fileMode, flag: "wx" });
-            try {
-                fsSync.chmodSync(filePath, fileMode);
-            }
-            catch {
-                // Best-effort on platforms that do not enforce POSIX modes.
-            }
-            return filePath;
-        },
-        read: (fileName) => fsSync.readFileSync(resolveWorkspaceLeaf(dir, fileName)),
-        cleanup: () => {
-            try {
-                fsSync.rmSync(dir, { recursive: true, force: true });
-            }
-            catch {
-                // Best-effort cleanup.
-            }
-        },
-    };
-}
-export function withSecureTempWorkspaceSync(options, run) {
-    const workspace = createSecureTempWorkspaceSync({
-        ...options,
-        prefix: `${sanitizeTempPrefix(options.prefix)}${randomUUID()}-`,
-    });
-    try {
-        return run(workspace);
-    }
-    finally {
-        workspace.cleanup();
-    }
-}

package/dist/sibling-temp-file.d.ts

@@ -1,16 +0,0 @@
-export type WriteSiblingTempFileOptions<T> = {
-    dir: string;
-    writeTemp: (tempPath: string) => Promise<T>;
-    resolveFinalPath: (result: T) => string;
-    tempPrefix?: string;
-    dirMode?: number;
-    fileMode?: number;
-    syncTempFile?: boolean;
-    syncParentDir?: boolean;
-};
-export type WriteSiblingTempFileResult<T> = {
-    filePath: string;
-    result: T;
-};
-export declare function writeSiblingTempFile<T>(options: WriteSiblingTempFileOptions<T>): Promise<WriteSiblingTempFileResult<T>>;
-//# sourceMappingURL=sibling-temp-file.d.ts.map

package/dist/sibling-temp-file.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sibling-temp-file.d.ts","sourceRoot":"","sources":["../src/sibling-temp-file.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,2BAA2B,CAAC,CAAC,IAAI;IAC3C,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;IAC5C,gBAAgB,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,MAAM,CAAC;IACxC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,0BAA0B,CAAC,CAAC,IAAI;IAC1C,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,CAAC,CAAC;CACX,CAAC;AAuCF,wBAAsB,oBAAoB,CAAC,CAAC,EAC1C,OAAO,EAAE,2BAA2B,CAAC,CAAC,CAAC,GACtC,OAAO,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC,CA+BxC"}

package/dist/sibling-temp-file.js

@@ -1,73 +0,0 @@
-import { randomUUID } from "node:crypto";
-import fs from "node:fs/promises";
-import path from "node:path";
-function buildTempPath(dir, tempPrefix) {
-    return path.join(dir, `${tempPrefix ?? ".fs-safe-stream"}.${process.pid}.${randomUUID()}.tmp`);
-}
-async function syncFileBestEffort(filePath) {
-    const handle = await fs.open(filePath, "r+");
-    try {
-        await handle.sync();
-    }
-    catch (error) {
-        if (error.code !== "EPERM") {
-            throw error;
-        }
-    }
-    finally {
-        await handle.close();
-    }
-}
-async function syncDirectoryBestEffort(dirPath) {
-    let handle;
-    try {
-        handle = await fs.open(dirPath, "r");
-        await handle.sync();
-    }
-    catch {
-        // Best-effort on platforms/filesystems that do not support directory fsync.
-    }
-    finally {
-        await handle?.close().catch(() => undefined);
-    }
-}
-function assertFinalPathIsSibling(dir, filePath) {
-    const resolvedDir = path.resolve(dir);
-    const resolvedFile = path.resolve(filePath);
-    if (path.dirname(resolvedFile) !== resolvedDir) {
-        throw new Error("Final path must be in the sibling temp directory.");
-    }
-}
-export async function writeSiblingTempFile(options) {
-    const dir = path.resolve(options.dir);
-    await fs.mkdir(dir, { recursive: true, mode: options.dirMode ?? 0o700 });
-    await fs.chmod(dir, options.dirMode ?? 0o700).catch(() => undefined);
-    const tempPath = buildTempPath(dir, options.tempPrefix);
-    let tempExists = false;
-    try {
-        tempExists = true;
-        const result = await options.writeTemp(tempPath);
-        if (options.fileMode !== undefined) {
-            await fs.chmod(tempPath, options.fileMode).catch(() => undefined);
-        }
-        if (options.syncTempFile) {
-            await syncFileBestEffort(tempPath);
-        }
-        const filePath = path.resolve(options.resolveFinalPath(result));
-        assertFinalPathIsSibling(dir, filePath);
-        await fs.rename(tempPath, filePath);
-        tempExists = false;
-        if (options.fileMode !== undefined) {
-            await fs.chmod(filePath, options.fileMode).catch(() => undefined);
-        }
-        if (options.syncParentDir) {
-            await syncDirectoryBestEffort(dir);
-        }
-        return { filePath, result };
-    }
-    finally {
-        if (tempExists) {
-            await fs.rm(tempPath, { force: true }).catch(() => undefined);
-        }
-    }
-}

package/dist/sibling-temp-write.d.ts

@@ -1,8 +0,0 @@
-export declare function writeViaSiblingTempPath(params: {
-    rootDir: string;
-    targetPath: string;
-    writeTemp: (tempPath: string) => Promise<void>;
-    fallbackFileName?: string;
-    tempPrefix?: string;
-}): Promise<void>;
-//# sourceMappingURL=sibling-temp-write.d.ts.map

package/dist/sibling-temp-write.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sibling-temp-write.d.ts","sourceRoot":"","sources":["../src/sibling-temp-write.ts"],"names":[],"mappings":"AAmBA,wBAAsB,uBAAuB,CAAC,MAAM,EAAE;IACpD,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GAAG,OAAO,CAAC,IAAI,CAAC,CA8BhB"}

package/dist/sibling-temp-write.js

@@ -1,40 +0,0 @@
-import crypto from "node:crypto";
-import fs from "node:fs/promises";
-import path from "node:path";
-import { sanitizeUntrustedFileName } from "./filename.js";
-import { safeRoot } from "./safe-root.js";
-function buildSiblingTempPath(params) {
-    const id = crypto.randomUUID();
-    const safeTail = sanitizeUntrustedFileName(path.basename(params.targetPath), params.fallbackFileName);
-    return path.join(path.dirname(params.targetPath), `${params.tempPrefix}${id}-${safeTail}.part`);
-}
-export async function writeViaSiblingTempPath(params) {
-    const rootDir = await fs
-        .realpath(path.resolve(params.rootDir))
-        .catch(() => path.resolve(params.rootDir));
-    const requestedTargetPath = path.resolve(params.targetPath);
-    const targetPath = await fs
-        .realpath(path.dirname(requestedTargetPath))
-        .then((realDir) => path.join(realDir, path.basename(requestedTargetPath)))
-        .catch(() => requestedTargetPath);
-    const relativeTargetPath = path.relative(rootDir, targetPath);
-    if (!relativeTargetPath ||
-        relativeTargetPath === ".." ||
-        relativeTargetPath.startsWith(`..${path.sep}`) ||
-        path.isAbsolute(relativeTargetPath)) {
-        throw new Error("Target path is outside the allowed root");
-    }
-    const tempPath = buildSiblingTempPath({
-        targetPath,
-        fallbackFileName: params.fallbackFileName ?? "output.bin",
-        tempPrefix: params.tempPrefix ?? ".fs-safe-output-",
-    });
-    try {
-        await params.writeTemp(tempPath);
-        const root = await safeRoot(rootDir);
-        await root.copyFileFrom(tempPath, relativeTargetPath, { mkdir: false });
-    }
-    finally {
-        await fs.rm(tempPath, { force: true }).catch(() => { });
-    }
-}