@openclaw/fs-safe 0.15.0 → 0.17.0

package/dist/create-owned-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-owned-file.d.ts","sourceRoot":"","sources":["../src/create-owned-file.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,KAAK,IAAI,IAAI,CAAC;IACd,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC;CAC1B,CAAC;AAEF,6EAA6E;AAC7E,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,MAAM,EACV,OAAO,GAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAmB,GAC3C,uBAAuB,CAYzB"}

package/dist/create-owned-file.js

@@ -0,0 +1,16 @@
+import fs from "node:fs";
+/** Capture the descriptor's creator-owned closer before it can be reused. */
+export function ownFileDescriptorSync(fd, closeFd = fs.closeSync) {
+    let open = true;
+    const owner = {
+        fd,
+        close() {
+            if (!open)
+                return;
+            open = false;
+            closeFd(fd);
+        },
+        [Symbol.dispose]() { owner.close(); },
+    };
+    return Object.freeze(owner);
+}

package/dist/create.d.ts

@@ -0,0 +1,4 @@
+export { createDirectory, createDirectorySync, createDirectoryWithAdmission, createDirectorySyncWithAdmission, type CreateDirectoryOptions, type CreationAdmission, } from "./create-directory.js";
+export { createFileSync, createFileHandle, type CreateFileOptions } from "./create-file.js";
+export type { OwnedFileDescriptorSync } from "./create-owned-file.js";
+//# sourceMappingURL=create.d.ts.map

package/dist/create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../src/create.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EAAE,mBAAmB,EACpC,4BAA4B,EAAE,gCAAgC,EAC9D,KAAK,sBAAsB,EAAE,KAAK,iBAAiB,GACpD,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,KAAK,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC5F,YAAY,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/create.js

@@ -0,0 +1,2 @@
+export { createDirectory, createDirectorySync, createDirectoryWithAdmission, createDirectorySyncWithAdmission, } from "./create-directory.js";
+export { createFileSync, createFileHandle } from "./create-file.js";

package/dist/creation-darwin.d.ts

@@ -0,0 +1,6 @@
+import { type BigIntStats } from "node:fs";
+export declare function assertDarwinPrivateCreationAvailable(): void;
+export declare function assertDarwinPrivateDirectoryMode(mode: number): void;
+export declare function assertDarwinCreationAcl(fd: number, inheritanceTarget?: "file" | "directory"): void;
+export declare function assertDarwinCreationDirectoryAcl(pathname: string, expected: BigIntStats, inheritanceTarget?: "file" | "directory"): void;
+//# sourceMappingURL=creation-darwin.d.ts.map

package/dist/creation-darwin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"creation-darwin.d.ts","sourceRoot":"","sources":["../src/creation-darwin.ts"],"names":[],"mappings":"AAAA,OAAW,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAe/C,wBAAgB,oCAAoC,IAAI,IAAI,CAE3D;AAED,wBAAgB,gCAAgC,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAInE;AAED,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAYlG;AAED,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,iBAAiB,CAAC,EAAE,MAAM,GAAG,WAAW,GAChF,IAAI,CAqBN"}

package/dist/creation-darwin.js

@@ -0,0 +1,70 @@
+import fs, {} from "node:fs";
+import { inspectDirectoryIdentitySync } from "./directory-guard.js";
+import { nodeDarwinDirectoryMetadataFlags, nodeDirectorySearchOnlyFlags } from "./directory-mode-node.js";
+import { FsSafeError } from "./errors.js";
+import { getNativeBinding } from "./native.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
+function inspector() {
+    const native = getNativeBinding();
+    if (typeof native?.inspectDarwinAcl !== "function") {
+        throw new FsSafeError("helper-unavailable", "private Darwin creation requires native descriptor ACL inspection");
+    }
+    return native.inspectDarwinAcl.bind(native);
+}
+export function assertDarwinPrivateCreationAvailable() {
+    if (process.platform === "darwin")
+        inspector();
+}
+export function assertDarwinPrivateDirectoryMode(mode) {
+    if (process.platform === "darwin" && ((mode & ~process.umask()) & 0o500) === 0) {
+        throw new FsSafeError("helper-unavailable", "private Darwin directory ACL inspection requires owner read or search permission");
+    }
+}
+export function assertDarwinCreationAcl(fd, inheritanceTarget) {
+    if (process.platform !== "darwin")
+        return;
+    const inspect = inspector();
+    const state = inspect(fd, inheritanceTarget)?.state;
+    if (state === "present") {
+        throw new FsSafeError("insecure-permissions", inheritanceTarget
+            ? "private creation parent has inheritable Darwin ACL entries"
+            : "private creation object has Darwin ACL entries");
+    }
+    if (state !== "absent" && state !== "empty") {
+        throw new FsSafeError("helper-unavailable", "native Darwin ACL inspection returned incomplete facts");
+    }
+}
+export function assertDarwinCreationDirectoryAcl(pathname, expected, inheritanceTarget) {
+    if (process.platform !== "darwin")
+        return;
+    assertDarwinPrivateCreationAvailable();
+    let fd;
+    try {
+        fd = fs.openSync(pathname, nodeDarwinDirectoryMetadataFlags());
+    }
+    catch (error) {
+        if (error.code !== "EACCES")
+            throw error;
+        const search = nodeDirectorySearchOnlyFlags();
+        if (!search)
+            throw error;
+        try {
+            fd = fs.openSync(pathname, search.flags | fs.constants.O_DIRECTORY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+        }
+        catch (cause) {
+            if (cause.code !== "EACCES")
+                throw cause;
+            throw new FsSafeError("helper-unavailable", "private Darwin directory ACL inspection requires owner read or search permission", { cause });
+        }
+    }
+    try {
+        const opened = inspectFileIdentitySync(() => fs.fstatSync(fd, { bigint: true }), expected);
+        if (!opened.isDirectory())
+            throw new FsSafeError("path-mismatch", "ACL target is not the admitted directory");
+        assertDarwinCreationAcl(fd, inheritanceTarget);
+        inspectDirectoryIdentitySync(pathname, expected);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}

package/dist/creation-file-state.d.ts

@@ -0,0 +1,19 @@
+import { type BigIntStats } from "node:fs";
+import { FsSafeError } from "./errors.js";
+export type CreationPublicationStatus = "not-published" | "published" | "indeterminate";
+export declare function assertCreationFile(fd: number, pathname: string, expected?: BigIntStats): BigIntStats;
+export declare function assertPrivateCreationFile(stat: BigIntStats, fd: number): void;
+export declare function removeRecordedCreationFileSync(pathname: string, identity: BigIntStats, assertParent: () => void): void;
+export declare function removeRecordedCreationFile(pathname: string, identity: BigIntStats, assertParent: () => void): Promise<void>;
+export declare function creationPublicationAfterFailure(error: unknown, recorded: CreationPublicationStatus): CreationPublicationStatus;
+export declare function hasPreservedCreationArtifacts(error: unknown): boolean;
+export declare function rethrowPrivateStageCreationFailure(error: unknown, path: string, stageDirectory: string): never;
+export declare function privateFileSettlementFailure(params: {
+    primary: unknown;
+    cleanup: readonly unknown[];
+    publication: CreationPublicationStatus;
+    path: string;
+    stageDirectory: string;
+    preserved?: boolean;
+}): FsSafeError;
+//# sourceMappingURL=creation-file-state.d.ts.map

package/dist/creation-file-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"creation-file-state.d.ts","sourceRoot":"","sources":["../src/creation-file-state.ts"],"names":[],"mappings":"AAAA,OAAW,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAE/C,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAM1C,MAAM,MAAM,yBAAyB,GAAG,eAAe,GAAG,WAAW,GAAG,eAAe,CAAC;AAExF,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,WAAW,GAAG,WAAW,CAOpG;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAS7E;AAQD,wBAAgB,8BAA8B,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,IAAI,GAAG,IAAI,CAUtH;AAED,wBAAsB,0BAA0B,CAC9C,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,IAAI,GAChE,OAAO,CAAC,IAAI,CAAC,CAaf;AAED,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,yBAAyB,GAClD,yBAAyB,CAO3B;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAMrE;AAED,wBAAgB,kCAAkC,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,KAAK,CAuB9G;AAED,wBAAgB,4BAA4B,CAAC,MAAM,EAAE;IACnD,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,SAAS,OAAO,EAAE,CAAC;IAC5B,WAAW,EAAE,yBAAyB,CAAC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,GAAG,WAAW,CAUd"}

package/dist/creation-file-state.js

@@ -0,0 +1,118 @@
+import fs, {} from "node:fs";
+import fsAsync from "node:fs/promises";
+import { FsSafeError } from "./errors.js";
+import { sameFileIdentityForCleanup } from "./file-identity.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
+import { hasUnsettledWindowsSecurityCommand } from "./windows-security-command.js";
+import { assertDarwinCreationAcl } from "./creation-darwin.js";
+export function assertCreationFile(fd, pathname, expected) {
+    const opened = inspectFileIdentitySync(() => fs.fstatSync(fd, { bigint: true }), expected);
+    const named = inspectFileIdentitySync(() => fs.lstatSync(pathname, { bigint: true }), opened);
+    if (!opened.isFile() || !named.isFile() || named.isSymbolicLink() || opened.nlink !== 1n || named.nlink !== 1n) {
+        throw new FsSafeError("path-mismatch", "created file is not the expected single-linked regular file");
+    }
+    return opened;
+}
+export function assertPrivateCreationFile(stat, fd) {
+    if (process.platform === "win32")
+        return;
+    if (typeof process.getuid !== "function" || stat.uid !== BigInt(process.getuid())) {
+        throw new FsSafeError("not-owned", "created private file must belong to the current user");
+    }
+    if ((stat.mode & 3647n) !== 0n) {
+        throw new FsSafeError("insecure-permissions", "created private file is not owner-only");
+    }
+    assertDarwinCreationAcl(fd);
+}
+function assertRecordedFile(current, identity) {
+    if (!current.isFile() || current.isSymbolicLink() || !sameFileIdentityForCleanup(current, identity)) {
+        throw new FsSafeError("path-mismatch", "created file cleanup preserved a replacement");
+    }
+}
+export function removeRecordedCreationFileSync(pathname, identity, assertParent) {
+    assertParent();
+    let current;
+    try {
+        current = fs.lstatSync(pathname, { bigint: true });
+    }
+    catch (error) {
+        if (error?.code === "ENOENT")
+            return;
+        throw error;
+    }
+    assertRecordedFile(current, identity);
+    fs.unlinkSync(pathname);
+}
+export async function removeRecordedCreationFile(pathname, identity, assertParent) {
+    assertParent();
+    let current;
+    try {
+        current = await fsAsync.lstat(pathname, { bigint: true });
+    }
+    catch (error) {
+        if (error?.code === "ENOENT")
+            return;
+        throw error;
+    }
+    assertParent();
+    assertRecordedFile(current, identity);
+    // Recheck after the awaited observation before dispatching the unlink.
+    assertRecordedFile(fs.lstatSync(pathname, { bigint: true }), identity);
+    await fsAsync.unlink(pathname);
+}
+export function creationPublicationAfterFailure(error, recorded) {
+    if (error instanceof FsSafeError) {
+        const publication = error.details?.publication;
+        if (publication && typeof publication === "object" && "status" in publication &&
+            publication.status === "indeterminate")
+            return "indeterminate";
+    }
+    return recorded;
+}
+export function hasPreservedCreationArtifacts(error) {
+    if (!(error instanceof FsSafeError))
+        return false;
+    if (error.details?.cleanup === "preserved" || error.details?.cleanup === "failed")
+        return true;
+    const publication = error.details?.publication;
+    return publication !== null && typeof publication === "object" && "status" in publication &&
+        (publication.status === "published" || publication.status === "indeterminate");
+}
+export function rethrowPrivateStageCreationFailure(error, path, stageDirectory) {
+    if (error instanceof FsSafeError && error.code === "already-exists") {
+        throw new FsSafeError("helper-failed", "private file staging path already exists", {
+            cause: error, details: { publication: { status: "not-published" }, path, stageDirectory },
+        });
+    }
+    const publication = error instanceof FsSafeError ? error.details?.publication : undefined;
+    const created = error instanceof FsSafeError && error.details?.path === stageDirectory &&
+        publication !== null && typeof publication === "object" && "status" in publication &&
+        publication.status === "published";
+    let unconfirmed = hasUnsettledWindowsSecurityCommand(error);
+    if (error !== null && (typeof error === "object" || typeof error === "function")) {
+        try {
+            const outcome = Object.getOwnPropertyDescriptor(error, "creationOutcome");
+            unconfirmed ||= Boolean(outcome && "value" in outcome && outcome.value === "unconfirmed");
+        }
+        catch {
+            unconfirmed = true;
+        }
+    }
+    if (created || unconfirmed) {
+        throw privateFileSettlementFailure({
+            primary: error, cleanup: [], publication: "not-published", path, stageDirectory, preserved: true,
+        });
+    }
+    throw error;
+}
+export function privateFileSettlementFailure(params) {
+    return new FsSafeError("helper-failed", "file creation or staging settlement failed", {
+        cause: params.cleanup.length
+            ? new AggregateError([params.primary, ...params.cleanup], "file creation and cleanup failed")
+            : params.primary,
+        details: {
+            publication: { status: params.publication }, path: params.path, stageDirectory: params.stageDirectory,
+            cleanup: params.preserved || params.publication === "indeterminate" ? "preserved" : params.cleanup.length ? "failed" : "removed",
+        },
+    });
+}

package/dist/creation-path.d.ts

@@ -0,0 +1,21 @@
+import { type BigIntStats } from "node:fs";
+import { type AsyncDirectoryGuard, type AnyAsyncDirectoryGuard } from "./directory-guard.js";
+export type CreationParentIdentity = Readonly<{
+    dev: bigint;
+    ino: bigint;
+    realPath?: string;
+}>;
+export type CreationPath = {
+    target: string;
+    parent: AsyncDirectoryGuard<BigIntStats>;
+    assertParent(): void;
+};
+export declare function creationAdmissionFromParent(parent: AnyAsyncDirectoryGuard): {
+    expectedParentIdentity: CreationParentIdentity;
+};
+export declare function prepareCreationPath(input: string, expectedParent?: CreationParentIdentity): CreationPath;
+export declare function creationCollision(error: unknown): unknown;
+/** Remove only the recorded empty stage; never traverse a replaced directory. */
+export declare function removeCreationDirectory(directory: string, identity: BigIntStats, assertParent: () => void): void;
+export declare function removeCreationDirectoryAsync(directory: string, identity: BigIntStats, assertParent: () => void): Promise<void>;
+//# sourceMappingURL=creation-path.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"creation-path.d.ts","sourceRoot":"","sources":["../src/creation-path.ts"],"names":[],"mappings":"AAAA,OAAW,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAG/C,OAAO,EAGL,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,EAC5B,MAAM,sBAAsB,CAAC;AAM9B,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;IAC5C,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,mBAAmB,CAAC,WAAW,CAAC,CAAC;IACzC,YAAY,IAAI,IAAI,CAAC;CACtB,CAAC;AAEF,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,sBAAsB,GAAG;IAAE,sBAAsB,EAAE,sBAAsB,CAAA;CAAE,CAO9H;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,sBAAsB,GAAG,YAAY,CAuBxG;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAKzD;AAED,iFAAiF;AACjF,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,IAAI,GAAG,IAAI,CAQhH;AAED,wBAAsB,4BAA4B,CAChD,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,IAAI,GACjE,OAAO,CAAC,IAAI,CAAC,CAQf"}

package/dist/creation-path.js

@@ -0,0 +1,71 @@
+import fs, {} from "node:fs";
+import fsAsync from "node:fs/promises";
+import path from "node:path";
+import { assertDirectoryIdentitySync, inspectDirectoryIdentitySync, } from "./directory-guard.js";
+import { FsSafeError } from "./errors.js";
+import { assertNoNulPathInput } from "./path.js";
+import { realpathSync } from "./realpath.js";
+import { assertNoWindowsPathAlias, resolvePathPreservingWindowsRoot } from "./windows-path-alias.js";
+export function creationAdmissionFromParent(parent) {
+    const { dev, ino } = parent.stat;
+    if (typeof dev !== "bigint" || typeof ino !== "bigint") {
+        throw new FsSafeError("path-mismatch", "private creation requires an exact parent identity");
+    }
+    const identity = inspectDirectoryIdentitySync(parent.dir, { dev, ino });
+    return { expectedParentIdentity: { dev: identity.dev, ino: identity.ino, realPath: parent.realPath } };
+}
+export function prepareCreationPath(input, expectedParent) {
+    expectedParent = expectedParent && { dev: expectedParent.dev, ino: expectedParent.ino, realPath: expectedParent.realPath };
+    assertNoNulPathInput(input);
+    assertNoWindowsPathAlias(input, "filesystem");
+    if (process.platform === "win32" && input.replaceAll("/", "\\").split("\\")
+        .some(component => component.endsWith(".") || component.endsWith(" "))) {
+        throw new FsSafeError("invalid-path", "creation path contains an ambiguous Windows component");
+    }
+    const target = resolvePathPreservingWindowsRoot(input);
+    const directory = path.dirname(target);
+    if (target === directory || input.length === 0) {
+        throw new FsSafeError("invalid-path", "creation requires a child name");
+    }
+    if (expectedParent)
+        assertDirectoryIdentitySync(directory, expectedParent);
+    const stat = inspectDirectoryIdentitySync(directory);
+    const realPath = realpathSync.native(directory);
+    const parent = { dir: directory, realPath, stat };
+    const assertParent = () => {
+        assertDirectoryIdentitySync(directory, { dev: stat.dev, ino: stat.ino, realPath });
+        if (expectedParent)
+            assertDirectoryIdentitySync(directory, expectedParent);
+    };
+    assertParent();
+    return { target, parent, assertParent };
+}
+export function creationCollision(error) {
+    if (error?.code === "EEXIST") {
+        return new FsSafeError("already-exists", "creation target already exists", { cause: error });
+    }
+    return error;
+}
+/** Remove only the recorded empty stage; never traverse a replaced directory. */
+export function removeCreationDirectory(directory, identity, assertParent) {
+    assertParent();
+    try {
+        assertDirectoryIdentitySync(directory, identity);
+        fs.rmdirSync(directory);
+    }
+    catch (error) {
+        if (error?.code !== "ENOENT")
+            throw error;
+    }
+}
+export async function removeCreationDirectoryAsync(directory, identity, assertParent) {
+    assertParent();
+    try {
+        assertDirectoryIdentitySync(directory, identity);
+        await fsAsync.rmdir(directory);
+    }
+    catch (error) {
+        if (error?.code !== "ENOENT")
+            throw error;
+    }
+}

package/dist/creation-permissions.d.ts

@@ -0,0 +1,19 @@
+export type CreationPermissions = {
+    private?: boolean;
+    mode?: number;
+};
+export declare function resolveCreationPermissions(options: CreationPermissions, directory: boolean): {
+    private: boolean;
+    mode: number | undefined;
+};
+export declare function assertPrivateFileCreationAvailable(): void;
+/** Full Windows identity, with security validation when requested; no repairs. */
+export declare function inspectCreationDirectorySync(targetPath: string, privatePath: boolean): string;
+export declare function inspectCreationDirectory(targetPath: string, privatePath: boolean): Promise<string>;
+export declare function assertPrivateDirectorySync(targetPath: string): void;
+export declare function assertPrivateDirectory(targetPath: string): Promise<void>;
+export declare function protectCreatedFileSync(fd: number, targetPath: string, parentIdentity: string): string;
+export declare function protectCreatedFile(fd: number, targetPath: string, parentIdentity: string): Promise<string>;
+export declare function verifyCreatedFileSync(fd: number, targetPath: string, identity: string, parentIdentity: string, links?: number): void;
+export declare function verifyCreatedFile(fd: number, targetPath: string, identity: string, parentIdentity: string, links?: number): Promise<void>;
+//# sourceMappingURL=creation-permissions.d.ts.map

package/dist/creation-permissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"creation-permissions.d.ts","sourceRoot":"","sources":["../src/creation-permissions.ts"],"names":[],"mappings":"AAiBA,MAAM,MAAM,mBAAmB,GAAG;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvE,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,mBAAmB,EAC5B,SAAS,EAAE,OAAO,GACjB;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAehD;AAeD,wBAAgB,kCAAkC,IAAI,IAAI,CAOzD;AAOD,kFAAkF;AAClF,wBAAgB,4BAA4B,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,GAAG,MAAM,CAQ7F;AAED,wBAAsB,wBAAwB,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAQxG;AAED,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAQnE;AAED,wBAAsB,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAQ9E;AAED,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM,CAOrG;AAED,wBAAsB,kBAAkB,CAAC,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAOhH;AAED,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,KAAK,SAAI,GAClF,IAAI,CAQN;AAED,wBAAsB,iBAAiB,CACrC,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,KAAK,SAAI,GAClF,OAAO,CAAC,IAAI,CAAC,CAQf"}

package/dist/creation-permissions.js

@@ -0,0 +1,125 @@
+import { inspectDirectoryIdentitySync } from "./directory-guard.js";
+import { FsSafeError } from "./errors.js";
+import { getNativeBinding } from "./native.js";
+import { getFsSafeNativeConfig } from "./native-config.js";
+import { warnNativeFallback } from "./native-fallback-warning.js";
+import { inspectWindowsDirectoryCommand, inspectWindowsDirectoryCommandSync, protectPrivateWindowsFileCommand, protectPrivateWindowsFileCommandSync, verifyPrivateWindowsFileCommand, verifyPrivateWindowsFileCommandSync, } from "./windows-security-command.js";
+import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
+import { assertDarwinCreationDirectoryAcl, assertDarwinPrivateCreationAvailable, assertDarwinPrivateDirectoryMode } from "./creation-darwin.js";
+export function resolveCreationPermissions(options, directory) {
+    const privatePath = options.private;
+    const mode = options.mode;
+    if (privatePath !== undefined && typeof privatePath !== "boolean") {
+        throw new TypeError("private must be a boolean");
+    }
+    if (mode !== undefined && (!Number.isInteger(mode) || mode < 0 || mode > 0o7777)) {
+        throw new RangeError("mode must contain only permission bits");
+    }
+    if (privatePath && mode !== undefined && (mode & 0o7077) !== 0) {
+        throw new FsSafeError("insecure-permissions", "private creation requires owner-only permission bits");
+    }
+    if (privatePath)
+        assertDarwinPrivateCreationAvailable();
+    if (privatePath && directory)
+        assertDarwinPrivateDirectoryMode(mode ?? 0o700);
+    return { private: privatePath === true, mode: mode ?? (privatePath ? directory ? 0o700 : 0o600 : undefined) };
+}
+function assertPrivatePosixDirectory(stat) {
+    if (typeof process.getuid !== "function" || stat.uid !== BigInt(process.getuid())) {
+        throw new FsSafeError("not-owned", "private directory must belong to the current user");
+    }
+    if ((stat.mode & 3647n) !== 0n) {
+        throw new FsSafeError("insecure-permissions", "existing directory is not private");
+    }
+}
+function unavailable() {
+    throw new FsSafeError("helper-unavailable", "private Windows creation requires an up-to-date native helper");
+}
+export function assertPrivateFileCreationAvailable() {
+    const native = getNativeBinding();
+    if (process.platform !== "win32" || getFsSafeNativeConfig().mode !== "require")
+        return;
+    if (typeof native?.createPrivateDirectoryWithParentIdentity !== "function" ||
+        typeof native.inspectWindowsDirectory !== "function" ||
+        typeof native.protectPrivateWindowsFile !== "function" ||
+        typeof native.verifyPrivateWindowsFile !== "function")
+        unavailable();
+}
+function commandFallback() {
+    if (getFsSafeNativeConfig().mode === "require")
+        unavailable();
+    warnNativeFallback("windows-private-creation", "Private Windows creation uses a slower built-in system command.");
+}
+/** Full Windows identity, with security validation when requested; no repairs. */
+export function inspectCreationDirectorySync(targetPath, privatePath) {
+    assertNoWindowsPathAlias(targetPath, "filesystem");
+    const native = getNativeBinding();
+    if (typeof native?.inspectWindowsDirectory === "function") {
+        return native.inspectWindowsDirectory(targetPath, privatePath).identity;
+    }
+    commandFallback();
+    return inspectWindowsDirectoryCommandSync(targetPath, privatePath).identity;
+}
+export async function inspectCreationDirectory(targetPath, privatePath) {
+    assertNoWindowsPathAlias(targetPath, "filesystem");
+    const native = getNativeBinding();
+    if (typeof native?.inspectWindowsDirectory === "function") {
+        return native.inspectWindowsDirectory(targetPath, privatePath).identity;
+    }
+    commandFallback();
+    return (await inspectWindowsDirectoryCommand(targetPath, privatePath)).identity;
+}
+export function assertPrivateDirectorySync(targetPath) {
+    const stat = inspectDirectoryIdentitySync(targetPath);
+    if (process.platform === "win32")
+        inspectCreationDirectorySync(targetPath, true);
+    else {
+        assertPrivatePosixDirectory(stat);
+        assertDarwinCreationDirectoryAcl(targetPath, stat);
+    }
+    inspectDirectoryIdentitySync(targetPath, stat);
+}
+export async function assertPrivateDirectory(targetPath) {
+    const stat = inspectDirectoryIdentitySync(targetPath);
+    if (process.platform === "win32")
+        await inspectCreationDirectory(targetPath, true);
+    else {
+        assertPrivatePosixDirectory(stat);
+        assertDarwinCreationDirectoryAcl(targetPath, stat);
+    }
+    inspectDirectoryIdentitySync(targetPath, stat);
+}
+export function protectCreatedFileSync(fd, targetPath, parentIdentity) {
+    const native = getNativeBinding();
+    if (typeof native?.protectPrivateWindowsFile === "function") {
+        return native.protectPrivateWindowsFile(fd, targetPath, parentIdentity).identity;
+    }
+    commandFallback();
+    return protectPrivateWindowsFileCommandSync(fd, targetPath, parentIdentity).identity;
+}
+export async function protectCreatedFile(fd, targetPath, parentIdentity) {
+    const native = getNativeBinding();
+    if (typeof native?.protectPrivateWindowsFile === "function") {
+        return native.protectPrivateWindowsFile(fd, targetPath, parentIdentity).identity;
+    }
+    commandFallback();
+    return (await protectPrivateWindowsFileCommand(fd, targetPath, parentIdentity)).identity;
+}
+export function verifyCreatedFileSync(fd, targetPath, identity, parentIdentity, links = 1) {
+    const native = getNativeBinding();
+    if (typeof native?.verifyPrivateWindowsFile === "function") {
+        native.verifyPrivateWindowsFile(fd, targetPath, identity, parentIdentity, links);
+        return;
+    }
+    commandFallback();
+    verifyPrivateWindowsFileCommandSync(fd, targetPath, identity, parentIdentity, links);
+}
+export async function verifyCreatedFile(fd, targetPath, identity, parentIdentity, links = 1) {
+    const native = getNativeBinding();
+    if (typeof native?.verifyPrivateWindowsFile === "function") {
+        native.verifyPrivateWindowsFile(fd, targetPath, identity, parentIdentity, links);
+        return;
+    }
+    commandFallback();
+    await verifyPrivateWindowsFileCommand(fd, targetPath, identity, parentIdentity, links);
+}

package/dist/directory-durability.d.ts

@@ -1,15 +1,15 @@
-import { type Stats } from "node:fs";
-import { type FileIdentityStat } from "./file-identity.js";
+import { type BigIntStats, type Stats } from "node:fs";
+import type { FileIdentityStat } from "./file-identity.js";
 export type DirectorySyncOutcome = {
     status: "synced";
 } | {
     status: "unsupported";
     code?: string;
 };
-export type DirectoryReceipt = {
+export type DirectoryReceipt<T extends Stats | BigIntStats = Stats> = {
     path: string;
     realPath: string;
-    identity: Stats;
+    identity: T;
 };
 export type DurableDirectoryReceipt = DirectoryReceipt & {
     parentSync: DirectorySyncOutcome | {
@@ -29,13 +29,13 @@ export type EnsureDurableDirectoryOptions = {
     expectedExistingIdentity?: FileIdentityStat;
     create?: (directoryPath: string) => Promise<void>;
 };
-export declare function pinDirectory(directory: string | DirectoryReceipt, options?: {
+export declare function pinDirectory(directory: string | DirectoryReceipt<Stats | BigIntStats>, options?: {
     label?: string;
 }): Promise<PinnedDirectory>;
-export declare function syncDirectory(directory: string | DirectoryReceipt, options?: {
+export declare function syncDirectory(directory: string | DirectoryReceipt<Stats | BigIntStats>, options?: {
     label?: string;
 }): Promise<DirectorySyncOutcome>;
-export declare function syncDirectorySync(directory: string | DirectoryReceipt, options?: {
+export declare function syncDirectorySync(directory: string | DirectoryReceipt<Stats | BigIntStats>, options?: {
     label?: string;
 }): DirectorySyncOutcome;
 export declare function syncDirectoryBestEffort(directoryPath: string): Promise<void>;

package/dist/directory-durability.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"directory-durability.d.ts","sourceRoot":"","sources":["../src/directory-durability.ts"],"names":[],"mappings":"AAAA,OAAe,EAAE,KAAK,KAAK,EAAE,MAAM,SAAS,CAAC;AAM7C,OAAO,EAAoB,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAI7E,MAAM,MAAM,oBAAoB,GAC5B;IAAE,MAAM,EAAE,QAAQ,CAAA;CAAE,GACpB;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7C,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,KAAK,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,gBAAgB,GAAG;IACvD,UAAU,EAAE,oBAAoB,GAAG;QAAE,MAAM,EAAE,YAAY,CAAA;KAAE,CAAC;CAC7D,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;IACnC,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,IAAI,IAAI,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACtC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG;IAC1C,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,wBAAwB,CAAC,EAAE,gBAAgB,CAAC;IAC5C,MAAM,CAAC,EAAE,CAAC,aAAa,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACnD,CAAC;AAwOF,wBAAsB,YAAY,CAChC,SAAS,EAAE,MAAM,GAAG,gBAAgB,EACpC,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GAC/B,OAAO,CAAC,eAAe,CAAC,CAe1B;AAED,wBAAsB,aAAa,CACjC,SAAS,EAAE,MAAM,GAAG,gBAAgB,EACpC,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GAC/B,OAAO,CAAC,oBAAoB,CAAC,CAqB/B;AAED,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,GAAG,gBAAgB,EACpC,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GAC/B,oBAAoB,CAyCtB;AAED,wBAAsB,uBAAuB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAElF;AAED,wBAAgB,2BAA2B,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAMvE;AAiCD,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,6BAA6B,GACrC,OAAO,CAAC,uBAAuB,CAAC,CA2FlC"}
+{"version":3,"file":"directory-durability.d.ts","sourceRoot":"","sources":["../src/directory-durability.ts"],"names":[],"mappings":"AAAA,OAAe,EAAE,KAAK,WAAW,EAAE,KAAK,KAAK,EAAE,MAAM,SAAS,CAAC;AAM/D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAa3D,MAAM,MAAM,oBAAoB,GAC5B;IAAE,MAAM,EAAE,QAAQ,CAAA;CAAE,GACpB;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7C,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,KAAK,GAAG,WAAW,GAAG,KAAK,IAAI;IACpE,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,CAAC,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,gBAAgB,GAAG;IACvD,UAAU,EAAE,oBAAoB,GAAG;QAAE,MAAM,EAAE,YAAY,CAAA;KAAE,CAAC;CAC7D,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;IACnC,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,IAAI,IAAI,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACtC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG;IAC1C,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,wBAAwB,CAAC,EAAE,gBAAgB,CAAC;IAC5C,MAAM,CAAC,EAAE,CAAC,aAAa,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACnD,CAAC;AAkHF,wBAAsB,YAAY,CAChC,SAAS,EAAE,MAAM,GAAG,gBAAgB,CAAC,KAAK,GAAG,WAAW,CAAC,EACzD,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GAC/B,OAAO,CAAC,eAAe,CAAC,CAe1B;AAED,wBAAsB,aAAa,CACjC,SAAS,EAAE,MAAM,GAAG,gBAAgB,CAAC,KAAK,GAAG,WAAW,CAAC,EACzD,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GAC/B,OAAO,CAAC,oBAAoB,CAAC,CAqB/B;AAED,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,GAAG,gBAAgB,CAAC,KAAK,GAAG,WAAW,CAAC,EACzD,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GAC/B,oBAAoB,CAkCtB;AAED,wBAAsB,uBAAuB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAElF;AAED,wBAAgB,2BAA2B,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAMvE;AAiCD,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,6BAA6B,GACrC,OAAO,CAAC,uBAAuB,CAAC,CA6FlC"}