@openclaw/fs-safe 0.15.0 → 0.16.0

package/dist/native-pinned-write-windows.js

@@ -2,11 +2,20 @@ import { syncFileBestEffortSync } from "./file-sync.js";
 import { randomUUID } from "node:crypto";
 import fsSync, {} from "node:fs";
 import path from "node:path";
+import { createFileHandle } from "./create.js";
+import { hasPreservedCreationArtifacts } from "./creation-file-state.js";
+import { assertSyncDirectoryGuard } from "./directory-guard.js";
 import { FsSafeError } from "./errors.js";
-import { nativeOpenFlags, removeNativeCreatedFileIfStillPinned, writeNativeInput, } from "./native-operations.js";
+import { nativeOpenFlags, removeNativeCreatedFileIfStillPinned, } from "./native-operations.js";
+import { writePinnedInput } from "./pinned-write-input.js";
 import { captureNativeFdClose } from "./native-binding.js";
 import { inspectFileIdentitySync } from "./strict-file-identity.js";
 import { assertFinalSymlinkRejected } from "./root-symlink-policy.js";
+import { classifyNativeRenameFailure } from "./native-rename-outcome.js";
+import { cleanupPinnedFilePath } from "./file-cleanup.js";
+import { createStagedFileReceipt, settleStagedFile } from "./staged-file-settlement.js";
+import { exactIdentityMatches } from "./staged-directory.js";
+import { inspectNativeDirectoryObservation } from "./native-directory-observation.js";
 function closeWriteFd(closeFd, fd) {
     if (fd === undefined)
         return;
@@ -17,39 +26,129 @@ function closeWriteFd(closeFd, fd) {
         return { error };
     }
 }
+function readParentIdentity(parentFd, guard) {
+    const stat = inspectFileIdentitySync(() => fsSync.fstatSync(parentFd, { bigint: true }));
+    if (!stat.isDirectory() || !exactIdentityMatches(guard.stat, stat)) {
+        throw new FsSafeError("path-mismatch", "native write parent identity changed");
+    }
+    return stat;
+}
+function assertNamedParentCurrent(binding, guard, identity) {
+    if (typeof binding.observeDirectory === "function") {
+        try {
+            const observed = inspectNativeDirectoryObservation(binding, guard.dir, identity);
+            if (observed.realPath !== guard.realPath) {
+                throw new FsSafeError("path-mismatch", "native write parent pathname changed");
+            }
+            return;
+        }
+        catch (error) {
+            if (error?.code !== "OBSERVATION_UNAVAILABLE")
+                throw error;
+        }
+    }
+    assertSyncDirectoryGuard({ ...guard, stat: identity });
+}
 export async function runPinnedWriteWindows(binding, params, root, parentFd, parentGuard) {
     const closeFd = captureNativeFdClose(binding);
     const parentPath = parentGuard.realPath;
     let tempFd;
+    let privateHandle;
     let targetFd;
+    let publicationProbeFd;
     let tempIdentity;
     let tempName = "";
     let renamed = false;
     let completed = false;
+    const completeCreate = params.overwrite === false && params.input.kind !== "file" && params.input.stageBeforePublish === true;
+    let receipt;
+    let publication = Object.freeze({ status: "not-published" });
+    let phase = "prepare";
+    let failure;
+    const closeTemp = async () => {
+        const handle = privateHandle;
+        const fd = tempFd;
+        privateHandle = undefined;
+        tempFd = undefined;
+        if (handle)
+            await handle.close();
+        else if (fd !== undefined)
+            closeFd(fd);
+    };
     try {
         tempName = `.fs-safe-${randomUUID()}.tmp`;
         params.assertBeforeMutation?.();
-        tempFd = binding.openBeneath(parentFd, tempName, nativeOpenFlags(fsSync.constants.O_WRONLY | fsSync.constants.O_CREAT | fsSync.constants.O_EXCL)).fd;
+        if (params.private) {
+            const parentIdentity = fsSync.fstatSync(parentFd, { bigint: true });
+            privateHandle = await createFileHandle(path.join(parentPath, tempName), {
+                private: true,
+                mode: 0o600,
+                assertBeforeMutation: params.assertBeforeMutation,
+            }, {
+                expectedParentIdentity: {
+                    dev: parentIdentity.dev, ino: parentIdentity.ino, realPath: parentPath,
+                },
+            });
+            tempFd = privateHandle.fd;
+        }
+        else {
+            tempFd = binding.openBeneath(parentFd, tempName, nativeOpenFlags(fsSync.constants.O_WRONLY | fsSync.constants.O_CREAT | fsSync.constants.O_EXCL)).fd;
+        }
         const verificationIdentity = inspectFileIdentitySync(() => fsSync.fstatSync(tempFd, { bigint: true }));
         tempIdentity = verificationIdentity;
         // Creation is requested at 0600 in the binding, but a restrictive umask
         // can remove owner access. Keep the unpublished inode private and
         // reopenable until the published name has been identity-fenced.
         fsSync.fchmodSync(tempFd, 0o600);
-        await writeNativeInput(tempFd, params.input, params.maxBytes, params.assertBeforeMutation);
-        if (params.sync !== false)
-            syncFileBestEffortSync(tempFd);
+        await writePinnedInput(tempFd, params.input, params.maxBytes, params.assertBeforeMutation);
+        if (params.sync !== false) {
+            if (params.strictFileSync)
+                fsSync.fsyncSync(tempFd);
+            else
+                syncFileBestEffortSync(tempFd);
+        }
         if (params.input.kind === "file")
             await params.input.verifySource();
+        if (completeCreate) {
+            const parentIdentity = readParentIdentity(parentFd, parentGuard);
+            receipt = createStagedFileReceipt(Object.freeze({
+                path: parentGuard.dir,
+                realPath: parentGuard.realPath,
+                identity: Object.freeze({ dev: parentIdentity.dev, ino: parentIdentity.ino }),
+            }), tempName, fsSync.fstatSync(tempFd, { bigint: true }));
+        }
+        phase = "publish";
         assertFinalSymlinkRejected(path.join(parentPath, params.basename), params.rejectFinalSymlink);
         params.assertBeforeMutation?.();
-        if (params.overwrite === false) {
-            binding.renameNoReplace(parentFd, tempName, parentFd, params.basename);
+        if (params.assertBeforeMutation) {
+            // Callbacks can replace names synchronously. Fence the named parent and
+            // stage against retained descriptors before the rename can expose bytes.
+            assertNamedParentCurrent(binding, parentGuard, readParentIdentity(parentFd, parentGuard));
+            publicationProbeFd = binding.openBeneath(parentFd, tempName, nativeOpenFlags(fsSync.constants.O_RDONLY)).fd;
+            const named = inspectFileIdentitySync(() => fsSync.fstatSync(publicationProbeFd, { bigint: true }), verificationIdentity);
+            const retained = inspectFileIdentitySync(() => fsSync.fstatSync(tempFd, { bigint: true }), verificationIdentity);
+            if (!named.isFile() || !retained.isFile() || named.nlink !== 1n || retained.nlink !== 1n) {
+                throw new FsSafeError("path-mismatch", "native write stage changed before publication");
+            }
+            assertFinalSymlinkRejected(path.join(parentPath, params.basename), params.rejectFinalSymlink);
         }
-        else {
-            binding.renameReplace(parentFd, tempName, parentFd, params.basename);
+        try {
+            if (params.overwrite === false) {
+                binding.renameNoReplace(parentFd, tempName, parentFd, params.basename);
+            }
+            else {
+                binding.renameReplace(parentFd, tempName, parentFd, params.basename);
+            }
+        }
+        catch (error) {
+            if (completeCreate && classifyNativeRenameFailure(error) === "indeterminate") {
+                publication = Object.freeze({ status: "indeterminate", basename: params.basename, overwrite: false });
+            }
+            throw error;
         }
         renamed = true;
+        if (receipt)
+            publication = Object.freeze({ status: "published", staged: receipt, basename: params.basename, overwrite: false });
         params.onPublished?.(verificationIdentity);
         targetFd = binding.openBeneath(parentFd, params.basename, nativeOpenFlags(fsSync.constants.O_RDONLY)).fd;
         const targetStat = inspectFileIdentitySync(() => fsSync.fstatSync(targetFd, { bigint: true }), verificationIdentity);
@@ -62,15 +161,21 @@ export async function runPinnedWriteWindows(binding, params, root, parentFd, par
         // verifiable and so broader modes are never exposed before that fence.
         try {
             fsSync.fchmodSync(targetFd, params.mode);
-            if (params.sync !== false)
-                syncFileBestEffortSync(targetFd);
+            // Windows FlushFileBuffers needs write access; the verification reopen is read-only.
+            if (params.sync !== false) {
+                if (params.strictFileSync)
+                    fsSync.fsyncSync(tempFd);
+                else
+                    syncFileBestEffortSync(tempFd);
+            }
         }
         catch (error) {
-            closeWriteFd(closeFd, targetFd);
-            targetFd = undefined;
+            if (!completeCreate) {
+                closeWriteFd(closeFd, targetFd);
+                targetFd = undefined;
+            }
             // Staged copies and streamed creates preserve publication for caller recovery.
-            if (params.input.kind === "buffer" ||
-                (params.input.kind === "stream" && !params.input.stageBeforePublish)) {
+            if (params.input.kind !== "file" && !params.input.stageBeforePublish) {
                 removeNativeCreatedFileIfStillPinned({
                     parentPath,
                     parentFd,
@@ -87,21 +192,61 @@ export async function runPinnedWriteWindows(binding, params, root, parentFd, par
         completed = true;
         return { dev: targetIdentity.dev, ino: targetIdentity.ino };
     }
+    catch (error) {
+        failure = { error };
+        throw error;
+    }
     finally {
-        const targetCloseFailure = closeWriteFd(closeFd, targetFd);
-        const tempCloseFailure = closeWriteFd(closeFd, tempFd);
-        if (!renamed) {
-            removeNativeCreatedFileIfStillPinned({
-                parentPath,
-                parentFd,
-                basename: tempName,
-                created: tempIdentity,
+        const preservedPreparation = params.private && tempFd === undefined && hasPreservedCreationArtifacts(failure?.error);
+        if (completeCreate || preservedPreparation) {
+            await settleStagedFile({
+                temporaryBasename: tempName, publication, phase, failure,
+                cleanup: async () => {
+                    if (preservedPreparation)
+                        return "preserved";
+                    if (publication.status === "indeterminate")
+                        return "preserved";
+                    if (renamed || tempFd === undefined)
+                        return "not-needed";
+                    return await cleanupPinnedFilePath({
+                        pathname: path.join(parentPath, tempName), handle: { fd: tempFd },
+                        identity: tempIdentity, parentGuard, throwOnCleanupError: true,
+                    });
+                },
+                close: [
+                    () => { if (targetFd !== undefined)
+                        closeFd(targetFd); },
+                    () => { if (publicationProbeFd !== undefined)
+                        closeFd(publicationProbeFd); },
+                    closeTemp,
+                    () => closeFd(parentFd),
+                    () => root.close(),
+                ],
             });
         }
-        const parentCloseFailure = closeWriteFd(closeFd, parentFd);
-        await root.close().catch(() => undefined);
-        const closeFailure = targetCloseFailure ?? tempCloseFailure ?? parentCloseFailure;
-        if (completed && closeFailure)
-            throw closeFailure.error;
+        else {
+            const targetCloseFailure = closeWriteFd(closeFd, targetFd);
+            const probeCloseFailure = closeWriteFd(closeFd, publicationProbeFd);
+            let tempCloseFailure;
+            try {
+                await closeTemp();
+            }
+            catch (error) {
+                tempCloseFailure = { error };
+            }
+            if (!renamed) {
+                removeNativeCreatedFileIfStillPinned({
+                    parentPath,
+                    parentFd,
+                    basename: tempName,
+                    created: tempIdentity,
+                });
+            }
+            const parentCloseFailure = closeWriteFd(closeFd, parentFd);
+            await root.close().catch(() => undefined);
+            const closeFailure = targetCloseFailure ?? probeCloseFailure ?? tempCloseFailure ?? parentCloseFailure;
+            if (completed && closeFailure)
+                throw closeFailure.error;
+        }
     }
 }

package/dist/native-pinned-write.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"native-pinned-write.d.ts","sourceRoot":"","sources":["../src/native-pinned-write.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAK3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD,OAAO,KAAK,EAIV,iBAAiB,EAClB,MAAM,mBAAmB,CAAC;AA8W3B,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA6FvH"}
+{"version":3,"file":"native-pinned-write.d.ts","sourceRoot":"","sources":["../src/native-pinned-write.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAK3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD,OAAO,KAAK,EAIV,iBAAiB,EAClB,MAAM,mBAAmB,CAAC;AA8W3B,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA8GvH"}

package/dist/native-pinned-write.js

@@ -368,15 +368,18 @@ export async function runPinnedWriteNative(binding, params) {
             assertNativeStaging(binding);
         }
         const directoryFlags = fsSync.constants.O_RDONLY | (fsSync.constants.O_DIRECTORY ?? 0);
+        const completeCreate = params.overwrite === false && params.input.kind !== "file" && params.input.stageBeforePublish === true;
         const rootAdmission = await openNativeRootAdmission(binding, {
             rootPath: params.rootPath,
             rootIdentity: params.rootIdentity,
             operation: "native write",
+            reportCloseErrors: completeCreate,
         });
         const root = rootAdmission.root;
         const posixRoot = __addDisposableResource(env_2, windows ? undefined : root, true);
         let parentFd;
         let windowsOwnsDirectories = false;
+        let admissionFailure;
         // Until stage construction takes ownership, even admission failures must close
         // the raw POSIX parent. Disposal preserves both admission and close failures.
         const parentGuard = __addDisposableResource(env_2, {
@@ -435,8 +438,13 @@ export async function runPinnedWriteNative(binding, params) {
             parentFd = undefined;
             return await writeNativeStage(binding, ownedParent, closeFd, directory, params, verificationGuard);
         }
+        catch (error) {
+            admissionFailure = { error };
+            throw error;
+        }
         finally {
             if (windows && !windowsOwnsDirectories) {
+                const closeErrors = [];
                 if (parentFd !== undefined) {
                     // Match the Windows leaf cleanup contract: an admission or identity
                     // failure remains primary, while every owned directory is still given
@@ -445,11 +453,19 @@ export async function runPinnedWriteNative(binding, params) {
                     try {
                         closeFd(parentFd);
                     }
-                    catch {
-                        // Best effort while propagating the operation failure.
+                    catch (error) {
+                        closeErrors.push(error);
                     }
                 }
-                await root.close().catch(() => undefined);
+                try {
+                    await root.close();
+                }
+                catch (error) {
+                    closeErrors.push(error);
+                }
+                if (completeCreate && closeErrors.length > 0) {
+                    throw new AggregateError([...(admissionFailure ? [admissionFailure.error] : []), ...closeErrors], "native create admission and close failed");
+                }
             }
         }
     }

package/dist/native-policy-parent-windows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"native-policy-parent-windows.d.ts","sourceRoot":"","sources":["../src/native-policy-parent-windows.ts"],"names":[],"mappings":"AAAA,OAAe,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAEnD,OAAO,EAGL,KAAK,mBAAmB,EACzB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAA6B,KAAK,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACnG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAKjD,OAAO,KAAK,EAAE,iBAAiB,EAAkG,MAAM,mBAAmB,CAAC;AAC3J,OAAO,EAA4B,KAAK,4BAA4B,EAAE,MAAM,kCAAkC,CAAC;AAI/G,KAAK,YAAY,GAAG;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,mBAAmB,CAAC,WAAW,CAAC,CAAC;IACxC,WAAW,EAAE,4BAA4B,CAAC;CAC3C,CAAC;AAqBF,wBAAsB,+BAA+B,CACnD,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,iBAAiB,EACzB,aAAa,EAAE,mBAAmB,GACjC,OAAO,CAAC,YAAY,CAAC,CA2KvB"}
+{"version":3,"file":"native-policy-parent-windows.d.ts","sourceRoot":"","sources":["../src/native-policy-parent-windows.ts"],"names":[],"mappings":"AAAA,OAAe,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAEnD,OAAO,EAGL,KAAK,mBAAmB,EACzB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAA6B,KAAK,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACnG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAKjD,OAAO,KAAK,EAAE,iBAAiB,EAAkG,MAAM,mBAAmB,CAAC;AAC3J,OAAO,EAA4B,KAAK,4BAA4B,EAAE,MAAM,kCAAkC,CAAC;AAK/G,KAAK,YAAY,GAAG;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,mBAAmB,CAAC,WAAW,CAAC,CAAC;IACxC,WAAW,EAAE,4BAA4B,CAAC;CAC3C,CAAC;AA4BF,wBAAsB,+BAA+B,CACnD,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,iBAAiB,EACzB,aAAa,EAAE,mBAAmB,GACjC,OAAO,CAAC,YAAY,CAAC,CA+KvB"}

package/dist/native-policy-parent-windows.js

@@ -10,6 +10,7 @@ import { isSymlinkOpenError } from "./path.js";
 import { checkedMutationDirectory } from "./pinned-mutation-observation.js";
 import { canReuseParentWithMutationAssertion } from "./root-write-lock-binding.js";
 import { inspectFileIdentitySync } from "./strict-file-identity.js";
+import { createSuppressedError } from "./suppressed-error.js";
 function assertParentCurrent(parent) {
     const current = inspectFileIdentitySync(() => fsSync.fstatSync(parent.fd, { bigint: true }), parent.guard.stat);
     assertDirectoryIdentitySync(parent.guard.dir, {
@@ -19,14 +20,17 @@ function assertParentCurrent(parent) {
     });
     return current;
 }
-function closeAfterFailure(closeFd, fd) {
+function closeAfterFailure(closeFd, fd, failure, report = false) {
     if (fd === undefined)
         return;
     try {
         closeFd(fd);
     }
-    catch {
-        // Windows retains the operation failure while attempting every owned close.
+    catch (error) {
+        if (report)
+            throw failure
+                ? createSuppressedError(error, failure.error, "native parent admission and close failed")
+                : error;
     }
 }
 export async function capturePolicyAwareWindowsParent(binding, params, rootAdmission) {
@@ -87,7 +91,7 @@ export async function capturePolicyAwareWindowsParent(binding, params, rootAdmis
             return complete;
         }
         catch (error) {
-            closeAfterFailure(closeFd, complete.fd);
+            closeAfterFailure(closeFd, complete.fd, { error }, rootAdmission.reportCloseErrors);
             throw error;
         }
     }
@@ -102,6 +106,7 @@ export async function capturePolicyAwareWindowsParent(binding, params, rootAdmis
         }),
     };
     let ownedFd;
+    let failure;
     const initialTarget = joinPathSegmentRoute(params.rootPath, route, 0, params.basename);
     if (canReuseParentWithMutationAssertion(params.assertBeforeMutation, params.rootPath, initialTarget)) {
         session = params.mutationAdmission?.beginNativeParentWalk?.() ??
@@ -178,7 +183,7 @@ export async function capturePolicyAwareWindowsParent(binding, params, rootAdmis
                 }
             }
             catch (error) {
-                closeAfterFailure(closeFd, child.fd);
+                closeAfterFailure(closeFd, child.fd, { error }, rootAdmission.reportCloseErrors);
                 throw error;
             }
             const previousFd = ownedFd;
@@ -193,8 +198,12 @@ export async function capturePolicyAwareWindowsParent(binding, params, rootAdmis
         ownedFd = undefined;
         return current;
     }
+    catch (error) {
+        failure = { error };
+        throw error;
+    }
     finally {
         session?.dispose();
-        closeAfterFailure(closeFd, ownedFd);
+        closeAfterFailure(closeFd, ownedFd, failure, rootAdmission.reportCloseErrors);
     }
 }

package/dist/native-staged-file.d.ts

@@ -6,10 +6,11 @@ import type { PinnedWriteInput, PinnedWriteParams } from "./pinned-write.js";
 import type { PublishedFileReceipt, StagedFile, StagedFileCleanupReceipt, StagedFileReceipt } from "./staged-file-types.js";
 export type NativeStagingBinding = NativeBinding & Required<Pick<NativeBinding, "createStagedFile" | "stagedFileMatches" | "removeStagedFile">>;
 export declare function assertNativeStaging(binding: NativeBinding): asserts binding is NativeStagingBinding;
+type StagedPermissionPolicy = "private-creation" | "mode-only";
 declare class NativeStagedFile implements StagedFile {
     #private;
-    constructor(binding: NativeStagingBinding, parentFd: number, closeParentFd: (fd: number) => void, directory: StagedFileReceipt["directory"], portableNames: boolean, publishedMode: number, sync: boolean, assertBeforeMutation?: () => void, name?: string);
-    static create(binding: NativeStagingBinding, parentFd: number, closeParentFd: (fd: number) => void, directory: StagedFileReceipt["directory"], input: PinnedWriteInput, mode: number, maxBytes?: number, portableNames?: boolean, sync?: boolean, assertBeforeMutation?: () => void, exclusiveBasename?: string): Promise<NativeStagedFile>;
+    constructor(binding: NativeStagingBinding, parentFd: number, closeParentFd: (fd: number) => void, directory: StagedFileReceipt["directory"], portableNames: boolean, publishedMode: number, sync: boolean, assertBeforeMutation?: () => void, name?: string, strictFileSync?: boolean, permissionPolicy?: StagedPermissionPolicy);
+    static create(binding: NativeStagingBinding, parentFd: number, closeParentFd: (fd: number) => void, directory: StagedFileReceipt["directory"], input: PinnedWriteInput, mode: number, maxBytes?: number, portableNames?: boolean, sync?: boolean, assertBeforeMutation?: () => void, exclusiveBasename?: string, strictFileSync?: boolean, permissionPolicy?: StagedPermissionPolicy): Promise<NativeStagedFile>;
     static write(binding: NativeStagingBinding, parentFd: number, closeParentFd: (fd: number) => void, directory: StagedFileReceipt["directory"], params: PinnedWriteParams, parentGuard: AnyAsyncDirectoryGuard): Promise<FileIdentityStat>;
     get receipt(): StagedFileReceipt;
     assertCurrent(): Promise<void>;

package/dist/native-staged-file.d.ts.map

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