@openclaw/fs-safe 0.1.1 → 0.2.0

package/dist/boundary-file-read.js

@@ -1,129 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { resolveBoundaryPath, resolveBoundaryPathSync, } from "./boundary-path.js";
-import { openVerifiedFileSync, } from "./safe-open-sync.js";
-export function canUseBoundaryFileOpen(ioFs) {
-    return (typeof ioFs.openSync === "function" &&
-        typeof ioFs.closeSync === "function" &&
-        typeof ioFs.fstatSync === "function" &&
-        typeof ioFs.lstatSync === "function" &&
-        typeof ioFs.realpathSync === "function" &&
-        typeof ioFs.readFileSync === "function" &&
-        typeof ioFs.constants === "object" &&
-        ioFs.constants !== null);
-}
-export function openBoundaryFileSync(params) {
-    const ioFs = params.ioFs ?? fs;
-    const resolved = resolveBoundaryFilePathGeneric({
-        absolutePath: params.absolutePath,
-        resolve: (absolutePath) => resolveBoundaryPathSync({
-            absolutePath,
-            rootPath: params.rootPath,
-            rootCanonicalPath: params.rootRealPath,
-            boundaryLabel: params.boundaryLabel,
-            skipLexicalRootCheck: params.skipLexicalRootCheck,
-        }),
-    });
-    if (resolved instanceof Promise) {
-        return toBoundaryValidationError(new Error("Unexpected async boundary resolution"));
-    }
-    return finalizeBoundaryFileOpen({
-        resolved,
-        maxBytes: params.maxBytes,
-        rejectHardlinks: params.rejectHardlinks,
-        allowedType: params.allowedType,
-        ioFs,
-    });
-}
-export function matchBoundaryFileOpenFailure(failure, handlers) {
-    switch (failure.reason) {
-        case "path":
-            return handlers.path ? handlers.path(failure) : handlers.fallback(failure);
-        case "validation":
-            return handlers.validation ? handlers.validation(failure) : handlers.fallback(failure);
-        case "io":
-            return handlers.io ? handlers.io(failure) : handlers.fallback(failure);
-    }
-    return handlers.fallback(failure);
-}
-function openBoundaryFileResolved(params) {
-    const opened = openVerifiedFileSync({
-        filePath: params.absolutePath,
-        resolvedPath: params.resolvedPath,
-        rejectHardlinks: params.rejectHardlinks ?? true,
-        maxBytes: params.maxBytes,
-        allowedType: params.allowedType,
-        ioFs: params.ioFs,
-    });
-    if (!opened.ok) {
-        return opened;
-    }
-    return {
-        ok: true,
-        path: opened.path,
-        fd: opened.fd,
-        stat: opened.stat,
-        rootRealPath: params.rootRealPath,
-    };
-}
-function finalizeBoundaryFileOpen(params) {
-    if ("ok" in params.resolved) {
-        return params.resolved;
-    }
-    return openBoundaryFileResolved({
-        absolutePath: params.resolved.absolutePath,
-        resolvedPath: params.resolved.resolvedPath,
-        rootRealPath: params.resolved.rootRealPath,
-        maxBytes: params.maxBytes,
-        rejectHardlinks: params.rejectHardlinks,
-        allowedType: params.allowedType,
-        ioFs: params.ioFs,
-    });
-}
-export async function openBoundaryFile(params) {
-    const ioFs = params.ioFs ?? fs;
-    const maybeResolved = resolveBoundaryFilePathGeneric({
-        absolutePath: params.absolutePath,
-        resolve: (absolutePath) => resolveBoundaryPath({
-            absolutePath,
-            rootPath: params.rootPath,
-            rootCanonicalPath: params.rootRealPath,
-            boundaryLabel: params.boundaryLabel,
-            policy: params.aliasPolicy,
-            skipLexicalRootCheck: params.skipLexicalRootCheck,
-        }),
-    });
-    const resolved = maybeResolved instanceof Promise ? await maybeResolved : maybeResolved;
-    return finalizeBoundaryFileOpen({
-        resolved,
-        maxBytes: params.maxBytes,
-        rejectHardlinks: params.rejectHardlinks,
-        allowedType: params.allowedType,
-        ioFs,
-    });
-}
-function toBoundaryValidationError(error) {
-    return { ok: false, reason: "validation", error };
-}
-function mapResolvedBoundaryPath(absolutePath, resolved) {
-    return {
-        absolutePath,
-        resolvedPath: resolved.canonicalPath,
-        rootRealPath: resolved.rootCanonicalPath,
-    };
-}
-function resolveBoundaryFilePathGeneric(params) {
-    const absolutePath = path.resolve(params.absolutePath);
-    try {
-        const resolved = params.resolve(absolutePath);
-        if (resolved instanceof Promise) {
-            return resolved
-                .then((value) => mapResolvedBoundaryPath(absolutePath, value))
-                .catch((error) => toBoundaryValidationError(error));
-        }
-        return mapResolvedBoundaryPath(absolutePath, resolved);
-    }
-    catch (error) {
-        return toBoundaryValidationError(error);
-    }
-}

package/dist/boundary-path.d.ts

@@ -1,39 +0,0 @@
-type BoundaryPathIntent = "read" | "write" | "create" | "delete" | "stat";
-export type BoundaryPathAliasPolicy = {
-    allowFinalSymlinkForUnlink?: boolean;
-    allowFinalHardlinkForUnlink?: boolean;
-};
-export declare const BOUNDARY_PATH_ALIAS_POLICIES: {
-    readonly strict: Readonly<{
-        allowFinalSymlinkForUnlink: false;
-        allowFinalHardlinkForUnlink: false;
-    }>;
-    readonly unlinkTarget: Readonly<{
-        allowFinalSymlinkForUnlink: true;
-        allowFinalHardlinkForUnlink: true;
-    }>;
-};
-type ResolveBoundaryPathParams = {
-    absolutePath: string;
-    rootPath: string;
-    boundaryLabel: string;
-    intent?: BoundaryPathIntent;
-    policy?: BoundaryPathAliasPolicy;
-    skipLexicalRootCheck?: boolean;
-    rootCanonicalPath?: string;
-};
-type ResolvedBoundaryPathKind = "missing" | "file" | "directory" | "symlink" | "other";
-export type ResolvedBoundaryPath = {
-    absolutePath: string;
-    canonicalPath: string;
-    rootPath: string;
-    rootCanonicalPath: string;
-    relativePath: string;
-    exists: boolean;
-    kind: ResolvedBoundaryPathKind;
-};
-export declare function resolveBoundaryPath(params: ResolveBoundaryPathParams): Promise<ResolvedBoundaryPath>;
-export declare function resolveBoundaryPathSync(params: ResolveBoundaryPathParams): ResolvedBoundaryPath;
-export declare function resolvePathViaExistingAncestorSync(targetPath: string): string;
-export {};
-//# sourceMappingURL=boundary-path.d.ts.map

package/dist/boundary-path.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"boundary-path.d.ts","sourceRoot":"","sources":["../src/boundary-path.ts"],"names":[],"mappings":"AAMA,KAAK,kBAAkB,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE1E,MAAM,MAAM,uBAAuB,GAAG;IACpC,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACvC,CAAC;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;CAS/B,CAAC;AAEX,KAAK,yBAAyB,GAAG;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,kBAAkB,CAAC;IAC5B,MAAM,CAAC,EAAE,uBAAuB,CAAC;IACjC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,KAAK,wBAAwB,GAAG,SAAS,GAAG,MAAM,GAAG,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC;AAEvF,MAAM,MAAM,oBAAoB,GAAG;IACjC,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,wBAAwB,CAAC;CAChC,CAAC;AAEF,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,yBAAyB,GAChC,OAAO,CAAC,oBAAoB,CAAC,CA+B/B;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,yBAAyB,GAAG,oBAAoB,CA+B/F;AAmkBD,wBAAgB,kCAAkC,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CA6B7E"}