@openclaw/fs-safe 0.1.0

package/dist/pinned-write.js

@@ -0,0 +1,198 @@
+import fsSync from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { FsSafeError } from "./errors.js";
+import { canFallbackFromPythonError, getFsSafePythonConfig } from "./pinned-python-config.js";
+import { assertPinnedPythonOperationAvailable, runPinnedPythonOperation, validatePinnedOperationPayload, } from "./pinned-python.js";
+function byteLength(input, encoding) {
+    return typeof input === "string"
+        ? Buffer.byteLength(input, encoding ?? "utf8")
+        : input.byteLength;
+}
+function assertSafeBasename(basename) {
+    if (!basename ||
+        basename === "." ||
+        basename === ".." ||
+        basename.includes("/") ||
+        basename.includes("\0")) {
+        throw new FsSafeError("invalid-path", "invalid target path");
+    }
+}
+function assertWithinMaxBytes(bytes, maxBytes) {
+    if (maxBytes !== undefined && bytes > maxBytes) {
+        throw new FsSafeError("too-large", `file exceeds limit of ${maxBytes} bytes (got at least ${bytes})`);
+    }
+}
+function createMaxBytesTransform(maxBytes) {
+    if (maxBytes === undefined) {
+        return undefined;
+    }
+    let bytes = 0;
+    return new Transform({
+        transform(chunk, _encoding, callback) {
+            bytes += chunk.byteLength;
+            if (bytes > maxBytes) {
+                callback(new FsSafeError("too-large", `file exceeds limit of ${maxBytes} bytes (got at least ${bytes})`));
+                return;
+            }
+            callback(null, chunk);
+        },
+    });
+}
+async function pipelineWithMaxBytes(stream, destination, maxBytes) {
+    const limiter = createMaxBytesTransform(maxBytes);
+    if (limiter) {
+        await pipeline(stream, limiter, destination);
+        return;
+    }
+    await pipeline(stream, destination);
+}
+async function inputToBase64(input, maxBytes) {
+    if (input.kind === "buffer") {
+        assertWithinMaxBytes(byteLength(input.data, input.encoding), maxBytes);
+        return (typeof input.data === "string"
+            ? Buffer.from(input.data, input.encoding ?? "utf8")
+            : input.data).toString("base64");
+    }
+    const chunks = [];
+    let bytes = 0;
+    for await (const chunk of input.stream) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        bytes += buffer.byteLength;
+        assertWithinMaxBytes(bytes, maxBytes);
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks, bytes).toString("base64");
+}
+export async function runPinnedWriteHelper(params) {
+    if (getFsSafePythonConfig().mode === "off") {
+        return await runPinnedWriteFallback(params);
+    }
+    assertSafeBasename(params.basename);
+    validatePinnedOperationPayload({
+        relativeParentPath: params.relativeParentPath,
+    });
+    if (params.input.kind === "stream") {
+        try {
+            assertPinnedPythonOperationAvailable();
+        }
+        catch (error) {
+            if (canFallbackFromPythonError(error)) {
+                return await runPinnedWriteFallback(params);
+            }
+            throw error;
+        }
+    }
+    const payload = {
+        base64: await inputToBase64(params.input, params.maxBytes),
+        basename: params.basename,
+        maxBytes: params.maxBytes ?? -1,
+        mkdir: params.mkdir,
+        mode: params.mode || 0o600,
+        overwrite: params.overwrite !== false,
+        relativeParentPath: params.relativeParentPath,
+    };
+    try {
+        return await runPinnedPythonOperation({
+            operation: "write",
+            rootPath: params.rootPath,
+            payload,
+        });
+    }
+    catch (error) {
+        if (canFallbackFromPythonError(error)) {
+            return await runPinnedWriteFallback(params);
+        }
+        throw error;
+    }
+}
+export async function runPinnedCopyHelper(params) {
+    assertSafeBasename(params.basename);
+    validatePinnedOperationPayload({
+        relativeParentPath: params.relativeParentPath,
+    });
+    return await runPinnedPythonOperation({
+        operation: "copy",
+        rootPath: params.rootPath,
+        payload: {
+            basename: params.basename,
+            maxBytes: params.maxBytes ?? -1,
+            mkdir: params.mkdir,
+            mode: params.mode || 0o600,
+            overwrite: params.overwrite !== false,
+            relativeParentPath: params.relativeParentPath,
+            sourceDev: params.sourceIdentity.dev,
+            sourceIno: params.sourceIdentity.ino,
+            sourcePath: params.sourcePath,
+        },
+    });
+}
+async function runPinnedWriteFallback(params) {
+    const parentPath = params.relativeParentPath
+        ? path.join(params.rootPath, ...params.relativeParentPath.split("/"))
+        : params.rootPath;
+    if (params.mkdir) {
+        await fs.mkdir(parentPath, { recursive: true });
+    }
+    const targetPath = path.join(parentPath, params.basename);
+    if (params.overwrite === false) {
+        const handle = await fs.open(targetPath, fsSync.constants.O_WRONLY | fsSync.constants.O_CREAT | fsSync.constants.O_EXCL, params.mode);
+        let created = true;
+        try {
+            if (params.input.kind === "buffer") {
+                assertWithinMaxBytes(byteLength(params.input.data, params.input.encoding), params.maxBytes);
+                if (typeof params.input.data === "string") {
+                    await handle.writeFile(params.input.data, params.input.encoding ?? "utf8");
+                }
+                else {
+                    await handle.writeFile(params.input.data);
+                }
+            }
+            else {
+                await pipelineWithMaxBytes(params.input.stream, handle.createWriteStream(), params.maxBytes);
+            }
+            const stat = await handle.stat();
+            created = false;
+            return { dev: stat.dev, ino: stat.ino };
+        }
+        finally {
+            await handle.close().catch(() => undefined);
+            if (created) {
+                await fs.rm(targetPath, { force: true }).catch(() => undefined);
+            }
+        }
+    }
+    const tempPath = path.join(parentPath, `.${params.basename}.fallback.tmp`);
+    try {
+        if (params.input.kind === "buffer") {
+            assertWithinMaxBytes(byteLength(params.input.data, params.input.encoding), params.maxBytes);
+            if (typeof params.input.data === "string") {
+                await fs.writeFile(tempPath, params.input.data, {
+                    encoding: params.input.encoding ?? "utf8",
+                    mode: params.mode,
+                });
+            }
+            else {
+                await fs.writeFile(tempPath, params.input.data, { mode: params.mode });
+            }
+        }
+        else {
+            const handle = await fs.open(tempPath, "w", params.mode);
+            try {
+                await pipelineWithMaxBytes(params.input.stream, handle.createWriteStream(), params.maxBytes);
+            }
+            finally {
+                await handle.close().catch(() => { });
+            }
+        }
+        await fs.rename(tempPath, targetPath);
+    }
+    catch (error) {
+        await fs.rm(tempPath, { force: true }).catch(() => undefined);
+        throw error;
+    }
+    const stat = await fs.stat(targetPath);
+    return { dev: stat.dev, ino: stat.ino };
+}

package/dist/private-file-store.d.ts

@@ -0,0 +1,60 @@
+import { type FileStore } from "./file-store.js";
+export type PrivateStateStoreOptions = {
+    rootDir: string;
+};
+export type PrivateStateStore = Omit<FileStore, "readText" | "readJson" | "writeText" | "writeJson"> & {
+    readText(relativePath: string, options?: {
+        maxBytes?: number;
+    }): Promise<string | null>;
+    readJson<T = unknown>(relativePath: string, options?: {
+        maxBytes?: number;
+    }): Promise<T | null>;
+    writeText(relativePath: string, content: string | Uint8Array): Promise<string>;
+    writeJson(relativePath: string, value: unknown, options?: {
+        trailingNewline?: boolean;
+    }): Promise<string>;
+};
+export declare function writePrivateTextAtomic(params: {
+    rootDir: string;
+    filePath: string;
+    content: string | Uint8Array;
+}): Promise<void>;
+export declare function readPrivateText(params: {
+    rootDir: string;
+    filePath: string;
+    maxBytes?: number;
+}): Promise<string | null>;
+export declare function readPrivateTextSync(params: {
+    rootDir: string;
+    filePath: string;
+    maxBytes?: number;
+}): string | null;
+export declare function readPrivateJson<T = unknown>(params: {
+    rootDir: string;
+    filePath: string;
+    maxBytes?: number;
+}): Promise<T | null>;
+export declare function readPrivateJsonSync<T = unknown>(params: {
+    rootDir: string;
+    filePath: string;
+    maxBytes?: number;
+}): T | null;
+export declare function writePrivateTextAtomicSync(params: {
+    rootDir: string;
+    filePath: string;
+    content: string | Uint8Array;
+}): void;
+export declare function writePrivateJsonAtomic(params: {
+    rootDir: string;
+    filePath: string;
+    value: unknown;
+    trailingNewline?: boolean;
+}): Promise<void>;
+export declare function writePrivateJsonAtomicSync(params: {
+    rootDir: string;
+    filePath: string;
+    value: unknown;
+    trailingNewline?: boolean;
+}): void;
+export declare function privateStateStore(options: PrivateStateStoreOptions): PrivateStateStore;
+//# sourceMappingURL=private-file-store.d.ts.map

package/dist/private-file-store.d.ts.map

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

package/dist/private-file-store.js

@@ -0,0 +1,233 @@
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import fs from "node:fs";
+import { FsSafeError } from "./errors.js";
+import { fileStore } from "./file-store.js";
+import { isPathInside } from "./path.js";
+import { readRegularFileSync } from "./regular-file.js";
+import { root } from "./root.js";
+import { writeSecretFileAtomic } from "./secret-file.js";
+function resolvePrivateStorePath(rootDir, relativePath) {
+    const root = path.resolve(rootDir);
+    const raw = relativePath.trim();
+    if (!raw || path.isAbsolute(raw) || raw.includes("\0")) {
+        throw new Error("Private file path must be a relative path.");
+    }
+    const resolved = path.resolve(root, raw);
+    const rel = path.relative(root, resolved);
+    if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) {
+        throw new Error("Private file path must stay under the private store root.");
+    }
+    return resolved;
+}
+export async function writePrivateTextAtomic(params) {
+    await writeSecretFileAtomic(params);
+}
+export async function readPrivateText(params) {
+    const rootDir = path.resolve(params.rootDir);
+    const filePath = path.resolve(params.filePath);
+    const relative = path.relative(rootDir, filePath);
+    if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error("Private file path must stay under the private store root.");
+    }
+    try {
+        const storeRoot = await root(rootDir, { hardlinks: "reject", maxBytes: params.maxBytes });
+        const result = await storeRoot.read(relative);
+        return result.buffer.toString("utf8");
+    }
+    catch (err) {
+        if (err instanceof FsSafeError && err.code === "not-found") {
+            return null;
+        }
+        throw err;
+    }
+}
+function assertPrivateReadPathSync(params) {
+    const rootDir = path.resolve(params.rootDir);
+    const filePath = path.resolve(params.filePath);
+    const relative = path.relative(rootDir, filePath);
+    if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error("Private file path must stay under the private store root.");
+    }
+    const rootStat = fs.lstatSync(rootDir);
+    if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) {
+        throw new Error(`Private file root must be a directory: ${rootDir}`);
+    }
+    const rootReal = fs.realpathSync(rootDir);
+    const fileReal = fs.realpathSync(filePath);
+    if (!isPathInside(rootReal, fileReal)) {
+        throw new Error("Private file path must stay under the private store root.");
+    }
+}
+export function readPrivateTextSync(params) {
+    try {
+        assertPrivateReadPathSync(params);
+        const result = readRegularFileSync({
+            filePath: path.resolve(params.filePath),
+            maxBytes: params.maxBytes,
+        });
+        if (result.stat.nlink > 1) {
+            throw new Error(`Private file target must not be hardlinked: ${params.filePath}`);
+        }
+        return result.buffer.toString("utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return null;
+        }
+        throw err;
+    }
+}
+export async function readPrivateJson(params) {
+    const raw = await readPrivateText(params);
+    return raw === null ? null : JSON.parse(raw);
+}
+export function readPrivateJsonSync(params) {
+    const raw = readPrivateTextSync(params);
+    return raw === null ? null : JSON.parse(raw);
+}
+function ensurePrivateDirectorySync(rootDir, targetDir) {
+    const root = path.resolve(rootDir);
+    const target = path.resolve(targetDir);
+    const relative = path.relative(root, target);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error("Private file directory must stay under the private store root.");
+    }
+    let current = root;
+    fs.mkdirSync(current, { recursive: true, mode: 0o700 });
+    const rootStat = fs.lstatSync(current);
+    if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) {
+        throw new Error(`Private file root must be a directory: ${current}`);
+    }
+    for (const segment of relative.split(path.sep).filter(Boolean)) {
+        current = path.join(current, segment);
+        try {
+            const stat = fs.lstatSync(current);
+            if (stat.isSymbolicLink() || !stat.isDirectory()) {
+                throw new Error(`Private file directory component must be a directory: ${current}`);
+            }
+        }
+        catch (err) {
+            if (err.code !== "ENOENT") {
+                throw err;
+            }
+            fs.mkdirSync(current, { mode: 0o700 });
+        }
+        try {
+            fs.chmodSync(current, 0o700);
+        }
+        catch {
+            // Best-effort on platforms that do not enforce POSIX modes.
+        }
+    }
+}
+export function writePrivateTextAtomicSync(params) {
+    const root = path.resolve(params.rootDir);
+    const filePath = path.resolve(params.filePath);
+    const relative = path.relative(root, filePath);
+    if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error("Private file path must stay under the private store root.");
+    }
+    ensurePrivateDirectorySync(root, path.dirname(filePath));
+    try {
+        const stat = fs.lstatSync(filePath);
+        if (stat.isSymbolicLink() || !stat.isFile()) {
+            throw new Error(`Private file target must be a regular file: ${filePath}`);
+        }
+    }
+    catch (err) {
+        if (err.code !== "ENOENT") {
+            throw err;
+        }
+    }
+    const tempPath = path.join(path.dirname(filePath), `.tmp-${process.pid}-${randomUUID()}`);
+    let created = false;
+    try {
+        fs.writeFileSync(tempPath, params.content, { mode: 0o600, flag: "wx" });
+        created = true;
+        try {
+            fs.chmodSync(tempPath, 0o600);
+        }
+        catch {
+            // Best-effort on platforms that do not enforce POSIX modes.
+        }
+        fs.renameSync(tempPath, filePath);
+        created = false;
+        try {
+            fs.chmodSync(filePath, 0o600);
+        }
+        catch {
+            // Best-effort on platforms that do not enforce POSIX modes.
+        }
+    }
+    finally {
+        if (created) {
+            try {
+                fs.unlinkSync(tempPath);
+            }
+            catch {
+                // The temp file is best-effort cleanup after write failure.
+            }
+        }
+    }
+}
+export async function writePrivateJsonAtomic(params) {
+    const json = JSON.stringify(params.value, null, 2);
+    await writeSecretFileAtomic({
+        rootDir: params.rootDir,
+        filePath: params.filePath,
+        content: params.trailingNewline && !json.endsWith("\n") ? `${json}\n` : json,
+    });
+}
+export function writePrivateJsonAtomicSync(params) {
+    const json = JSON.stringify(params.value, null, 2);
+    writePrivateTextAtomicSync({
+        rootDir: params.rootDir,
+        filePath: params.filePath,
+        content: params.trailingNewline && !json.endsWith("\n") ? `${json}\n` : json,
+    });
+}
+export function privateStateStore(options) {
+    const rootDir = path.resolve(options.rootDir);
+    const store = fileStore({ rootDir, private: true });
+    return {
+        ...store,
+        rootDir,
+        path: (relativePath) => resolvePrivateStorePath(rootDir, relativePath),
+        readText: async (relativePath, options) => {
+            const safePath = resolvePrivateStorePath(rootDir, relativePath);
+            return await readPrivateText({
+                rootDir,
+                filePath: safePath,
+                maxBytes: options?.maxBytes,
+            });
+        },
+        readJson: async (relativePath, options) => {
+            const safePath = resolvePrivateStorePath(rootDir, relativePath);
+            return await readPrivateJson({
+                rootDir,
+                filePath: safePath,
+                maxBytes: options?.maxBytes,
+            });
+        },
+        writeText: async (relativePath, content) => {
+            const safePath = resolvePrivateStorePath(rootDir, relativePath);
+            await writePrivateTextAtomic({
+                rootDir,
+                filePath: safePath,
+                content,
+            });
+            return safePath;
+        },
+        writeJson: async (relativePath, value, options) => {
+            const safePath = resolvePrivateStorePath(rootDir, relativePath);
+            await writePrivateJsonAtomic({
+                rootDir,
+                filePath: safePath,
+                value,
+                trailingNewline: options?.trailingNewline,
+            });
+            return safePath;
+        },
+    };
+}

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

@@ -0,0 +1,39 @@
+import { type FileStore, type FileStoreSync } from "./file-store.js";
+export type TempWorkspaceOptions = {
+    rootDir: string;
+    prefix: string;
+    dirMode?: number;
+    mode?: number;
+};
+export type TempWorkspace = {
+    dir: string;
+    store: FileStore;
+    path(fileName: string): string;
+    write(fileName: string, data: string | Uint8Array): Promise<string>;
+    writeText(fileName: string, data: string): Promise<string>;
+    writeJson(fileName: string, data: unknown, options?: {
+        trailingNewline?: boolean;
+    }): Promise<string>;
+    copyIn(fileName: string, sourcePath: string): Promise<string>;
+    read(fileName: string): Promise<Buffer>;
+    cleanup(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+};
+export type TempWorkspaceSync = {
+    dir: string;
+    store: FileStoreSync;
+    path(fileName: string): string;
+    write(fileName: string, data: string | Uint8Array): string;
+    writeText(fileName: string, data: string): string;
+    writeJson(fileName: string, data: unknown, options?: {
+        trailingNewline?: boolean;
+    }): string;
+    read(fileName: string): Buffer;
+    cleanup(): void;
+    [Symbol.dispose](): void;
+};
+export declare function tempWorkspace(options: TempWorkspaceOptions): Promise<TempWorkspace>;
+export declare function withTempWorkspace<T>(options: TempWorkspaceOptions, run: (workspace: TempWorkspace) => Promise<T>): Promise<T>;
+export declare function tempWorkspaceSync(options: TempWorkspaceOptions): TempWorkspaceSync;
+export declare function withTempWorkspaceSync<T>(options: TempWorkspaceOptions, run: (workspace: TempWorkspaceSync) => T): T;
+//# sourceMappingURL=private-temp-workspace.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"private-temp-workspace.d.ts","sourceRoot":"","sources":["../src/private-temp-workspace.ts"],"names":[],"mappings":"AAIA,OAAO,EAGL,KAAK,SAAS,EACd,KAAK,aAAa,EACnB,MAAM,iBAAiB,CAAC;AAGzB,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,SAAS,CAAC;IACjB,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAC/B,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACpE,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC3D,SAAS,CACP,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,OAAO,EACb,OAAO,CAAC,EAAE;QAAE,eAAe,CAAC,EAAE,OAAO,CAAA;KAAE,GACtC,OAAO,CAAC,MAAM,CAAC,CAAC;IACnB,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC9D,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACxC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxC,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAC/B,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,CAAC;IAC3D,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAClD,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE;QAAE,eAAe,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,MAAM,CAAC;IAC5F,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAC/B,OAAO,IAAI,IAAI,CAAC;IAChB,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC;CAC1B,CAAC;AAuGF,wBAAsB,aAAa,CACjC,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,aAAa,CAAC,CAExB;AAED,wBAAsB,iBAAiB,CAAC,CAAC,EACvC,OAAO,EAAE,oBAAoB,EAC7B,GAAG,EAAE,CAAC,SAAS,EAAE,aAAa,KAAK,OAAO,CAAC,CAAC,CAAC,GAC5C,OAAO,CAAC,CAAC,CAAC,CAUZ;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,oBAAoB,GAC5B,iBAAiB,CA4DnB;AAED,wBAAgB,qBAAqB,CAAC,CAAC,EACrC,OAAO,EAAE,oBAAoB,EAC7B,GAAG,EAAE,CAAC,SAAS,EAAE,iBAAiB,KAAK,CAAC,GACvC,CAAC,CAUH"}