@openclaw/feishu 2026.9.8 → 2026.10.1-beta.2

package/node_modules/@openclaw/fs-safe/dist/replace-file-descriptor.js

@@ -1,44 +1,29 @@
-import { syncFileBestEffort, syncFileBestEffortSync } from "./file-sync.js";
 import syncFs, {} from "node:fs";
-import fs, {} from "node:fs/promises";
+import fs from "node:fs/promises";
 import { FsSafeError } from "./errors.js";
 import { inspectFileIdentity, inspectFileIdentitySync } from "./strict-file-identity.js";
 import { ownDirectoryMode } from "./directory-mode-node.js";
-export async function syncDirectoryBestEffort(fsModule, dirPath) {
-    let handle;
+import { inspectAtomicIdentity, wait } from "./atomic-io.js";
+function parentCloseFailure(primary, closeError) {
+    return primary ? new AggregateError([primary.error, closeError], "Atomic parent preparation and close failed") : closeError;
+}
+export function* syncDirectoryBestEffort(io, dirPath) {
+    let file;
     try {
-        handle = await fsModule.open(dirPath, "r");
-        await handle.sync();
+        file = yield* io.open(dirPath, "r");
+        yield* file.sync();
     }
     catch {
-        // Best-effort on platforms/filesystems that do not support directory fsync.
+        // Directory synchronization and close remain best-effort.
     }
     finally {
         try {
-            await handle?.close();
+            const closing = file?.close();
+            if (file && io.asynchronous)
+                yield closing;
         }
         catch {
-            // Best-effort close also covers synchronous adapter throws.
-        }
-    }
-}
-export function syncDirectoryBestEffortSync(fsModule, dirPath) {
-    let fd;
-    try {
-        fd = fsModule.openSync(dirPath, "r");
-        fsModule.fsyncSync(fd);
-    }
-    catch {
-        // Best-effort on platforms/filesystems that do not support directory fsync.
-    }
-    finally {
-        if (fd !== undefined) {
-            try {
-                fsModule.closeSync(fd);
-            }
-            catch {
-                // Best-effort close after directory fsync.
-            }
+            // Preserve the operation's best-effort contract.
         }
     }
 }
@@ -54,7 +39,7 @@ function assertDirectory(identity, dirPath) {
     }
     return identity;
 }
-export async function pinDirectoryForMode(params) {
+async function pinDirectoryForMode(params) {
     // Node does not enforce POSIX directory modes on Windows, and its directory
     // descriptors are not consistently openable. mkdir(mode) remains the only
     // bounded behavior there; never fall back to a pathname chmod.
@@ -84,81 +69,91 @@ export async function pinDirectoryForMode(params) {
         return owner;
     }
     catch (error) {
-        await handle.close();
+        try {
+            await handle.close();
+        }
+        catch (closeError) {
+            throw parentCloseFailure({ error }, closeError);
+        }
         throw error;
     }
 }
-export async function applyDirectoryMode(params) {
-    const owner = await pinDirectoryForMode(params);
-    try {
-        await owner?.apply(params.mode);
-    }
-    finally {
-        await owner?.close();
-    }
-}
-export function applyDirectoryModeSync(params) {
-    if (process.platform === "win32") {
+export function* applyDirectoryMode(io, params) {
+    if (io.asynchronous) {
+        const owner = yield* wait(pinDirectoryForMode({
+            ...params,
+            fsModule: io.asyncFs,
+        }));
+        let primary;
+        try {
+            if (owner)
+                yield* wait(owner.apply(params.mode));
+        }
+        catch (error) {
+            primary = { error };
+            throw error;
+        }
+        finally {
+            try {
+                if (owner)
+                    yield* wait(owner.close());
+            }
+            catch (closeError) {
+                throw parentCloseFailure(primary, closeError);
+            }
+        }
         return;
     }
-    const expected = inspectFileIdentitySync(() => assertDirectory(params.fsModule.lstatSync(params.dirPath, { bigint: true }), params.dirPath));
-    const fd = params.fsModule.openSync(params.dirPath, directoryOpenFlags());
-    try {
-        inspectFileIdentitySync(() => assertDirectory(params.fsModule.fstatSync(fd, { bigint: true }), params.dirPath), expected);
-        // chmod ignores file-type bits; mask so raw stat modes are tolerated.
-        params.mutation?.assert();
-        params.fchmodSync?.(fd, params.mode & 0o7777);
-    }
-    finally {
-        params.fsModule.closeSync(fd);
-    }
-}
-export async function writeTempFile(params) {
-    params.mutation?.assert();
-    const handle = await params.fsModule.open(params.tempPath, "wx", params.mode);
+    if (process.platform === "win32")
+        return;
+    const admit = (stat) => assertDirectory(stat, params.dirPath);
+    const expected = inspectAtomicIdentity(io, () => io.lstatExact(params.dirPath), undefined, false, admit);
+    const file = yield* io.open(params.dirPath, directoryOpenFlags());
+    let primary;
     try {
-        // Custom adapters retain their async-only metadata contract.
-        const inspect = () => params.fsModule === fs
-            ? syncFs.fstatSync(handle.fd, { bigint: true }) : handle.stat({ bigint: true });
-        const identity = await inspectFileIdentity(inspect);
-        params.onIdentity?.(identity);
+        inspectAtomicIdentity(io, () => file.statExact(), expected, false, admit);
         params.mutation?.assert();
-        await params.fsModule.writeFile(handle, params.content);
-        await handle.chmod(params.mode);
-        if (params.sync) {
-            await syncFileBestEffort(handle);
-        }
-        await inspectFileIdentity(inspect, identity);
-        return { handle, identity };
+        file.chmod(params.mode & 0o7777);
     }
     catch (error) {
+        primary = { error };
+        throw error;
+    }
+    finally {
         try {
-            await handle.close();
+            file.close();
         }
         catch (closeError) {
-            throw new AggregateError([error, closeError], "Atomic temp write and close failed");
+            throw parentCloseFailure(primary, closeError);
         }
-        throw error;
     }
 }
-export function writeTempFileSync(params) {
+export function* writeTempFile(io, params) {
     params.mutation?.assert();
-    const fd = params.fsModule.openSync(params.tempPath, "wx", params.mode);
+    const file = yield* io.open(params.tempPath, "wx", params.mode);
     try {
-        const identity = inspectFileIdentitySync(() => params.fsModule.fstatSync(fd, { bigint: true }));
+        const openedInspection = inspectAtomicIdentity(io, () => file.statExact());
+        const identity = (io.asynchronous ? (yield openedInspection) : openedInspection);
         params.onIdentity?.(identity);
         params.mutation?.assert();
-        params.fsModule.writeFileSync(fd, params.content);
-        params.fchmodSync?.(fd, params.mode);
-        if (params.sync) {
-            syncFileBestEffortSync(fd, params.fsModule);
-        }
-        inspectFileIdentitySync(() => params.fsModule.fstatSync(fd, { bigint: true }), identity);
-        return { fd, identity };
+        const writing = file.writeFile(params.content, true);
+        if (io.asynchronous)
+            yield writing;
+        const chmod = file.chmod(params.mode);
+        if (io.asynchronous)
+            yield chmod;
+        if (params.sync)
+            yield* file.syncBestEffort();
+        const currentInspection = inspectAtomicIdentity(io, () => file.statExact(), identity);
+        if (io.asynchronous)
+            yield currentInspection;
+        return { file, identity };
     }
     catch (error) {
         try {
-            params.fsModule.closeSync(fd);
+            const closing = file.close();
+            if (io.asynchronous)
+                yield closing;
         }
         catch (closeError) {
             throw new AggregateError([error, closeError], "Atomic temp write and close failed");

package/node_modules/@openclaw/fs-safe/dist/replace-file-destination.d.ts

@@ -1,21 +1,19 @@
-import fsSync from "node:fs";
-import fs, { type FileHandle } from "node:fs/promises";
+import type { BigIntStats } from "node:fs";
+import { type AtomicFile, type AtomicIo, type Procedure } from "./atomic-io.js";
 import type { AtomicMutation } from "./replace-file-mutation.js";
-/** Borrow the writer's descriptor; never adopt an identity from a later pathname open. */
-export declare function captureAtomicDestination(fsModule: Pick<typeof fs, "lstat">, handle: FileHandle, pathname: string, mutation: AtomicMutation, rejectHardlinks: boolean): Promise<{
-    verify: () => Promise<void>;
-    writing: () => void;
-    beforeWrite: () => Promise<void>;
-    beforeRestore: () => Promise<void>;
-    verifyRestore: () => Promise<void>;
-    assertBeforeMutation: () => void;
-    published: () => void;
-}>;
-export declare function captureAtomicDestinationSync(fsModule: Pick<typeof fsSync, "lstatSync" | "fstatSync">, fd: number, pathname: string, mutation: AtomicMutation, rejectHardlinks: boolean): {
-    verify: () => void;
-    writing: () => void;
-    beforeWrite: () => void;
-    beforeRestore: () => void;
-    verifyRestore: () => void;
-    published: () => void;
-};
+/** Borrows the writer's descriptor; no later pathname open can replace it. */
+export declare class AtomicDestination {
+    #private;
+    readonly io: AtomicIo;
+    readonly file: AtomicFile;
+    readonly pathname: string;
+    readonly mutation: AtomicMutation;
+    readonly rejectHardlinks: boolean;
+    readonly identity: BigIntStats;
+    constructor(io: AtomicIo, file: AtomicFile, pathname: string, mutation: AtomicMutation, rejectHardlinks: boolean, identity: BigIntStats);
+    verify(restore?: boolean): Procedure<void>;
+    beforeWrite(restore: boolean): Procedure<void>;
+    writing(): void;
+    published(): void;
+}
+export declare function captureAtomicDestination(io: AtomicIo, file: AtomicFile, pathname: string, mutation: AtomicMutation, rejectHardlinks: boolean): Procedure<AtomicDestination>;

package/node_modules/@openclaw/fs-safe/dist/replace-file-destination.js

@@ -1,8 +1,6 @@
-import fsSync, {} from "node:fs";
-import fs, {} from "node:fs/promises";
+import { inspectAtomicIdentity } from "./atomic-io.js";
 import { hasErrorCode } from "./file-cleanup.js";
 import { FsSafeError } from "./errors.js";
-import { inspectFileIdentity, inspectFileIdentitySync } from "./strict-file-identity.js";
 function regular(stat, pathname, rejectHardlinks) {
     if (stat.isSymbolicLink() || !stat.isFile()) {
         throw new FsSafeError("path-mismatch", `Atomic replace destination changed: ${pathname}`);
@@ -12,112 +10,80 @@ function regular(stat, pathname, rejectHardlinks) {
     }
     return stat;
 }
-/** Borrow the writer's descriptor; never adopt an identity from a later pathname open. */
-export async function captureAtomicDestination(fsModule, handle, pathname, mutation, rejectHardlinks) {
-    const inspect = () => fsModule === fs
-        ? fsSync.fstatSync(handle.fd, { bigint: true }) : handle.stat({ bigint: true });
-    const identity = await inspectFileIdentity(inspect);
-    regular(identity, pathname, rejectHardlinks);
-    let writing = false;
-    let restoreDescriptorOnly = false;
-    const verifyDescriptor = async () => {
-        await inspectFileIdentity(async () => regular(await inspect(), pathname, rejectHardlinks), identity);
-    };
-    const verify = async () => {
+/** Borrows the writer's descriptor; no later pathname open can replace it. */
+export class AtomicDestination {
+    io;
+    file;
+    pathname;
+    mutation;
+    rejectHardlinks;
+    identity;
+    #writing = false;
+    #restoreDescriptorOnly = false;
+    constructor(io, file, pathname, mutation, rejectHardlinks, identity) {
+        this.io = io;
+        this.file = file;
+        this.pathname = pathname;
+        this.mutation = mutation;
+        this.rejectHardlinks = rejectHardlinks;
+        this.identity = identity;
+    }
+    *verify(restore = false) {
         let metadataFailure = false;
-        const observe = async (read) => {
+        const descriptorOnly = restore && this.#restoreDescriptorOnly;
+        const owner = this;
+        function readFailure(error) {
+            metadataFailure = hasErrorCode(error, "EIO");
+            throw error;
+        }
+        function read(pathname) {
             try {
-                return await read();
+                const stat = pathname
+                    ? owner.io.lstatExact(owner.pathname, false) : owner.file.statExact();
+                return owner.io.asynchronous ? Promise.resolve(stat).catch(readFailure) : stat;
             }
             catch (error) {
-                metadataFailure = hasErrorCode(error, "EIO");
-                throw error;
+                return readFailure(error);
             }
-        };
-        try {
-            await inspectFileIdentity(async () => regular(await observe(inspect), pathname, rejectHardlinks), identity);
-            await inspectFileIdentity(async () => regular(await observe(() => fsModule.lstat(pathname, { bigint: true })), pathname, rejectHardlinks), identity);
         }
-        catch (error) {
-            if (writing && metadataFailure) {
-                // A metadata observation failed, but the already-owned descriptor can
-                // still restore its bytes after fresh exact descriptor verification.
-                restoreDescriptorOnly = true;
-                throw error;
-            }
-            mutation.refuse(error);
-        }
-    };
-    const verifyRestore = async () => {
-        if (!restoreDescriptorOnly)
-            return await verify();
+        const admit = (stat) => regular(stat, owner.pathname, owner.rejectHardlinks);
         try {
-            await verifyDescriptor();
-        }
-        catch (error) {
-            mutation.refuse(error);
-        }
-    };
-    return {
-        verify,
-        writing: () => { writing = true; mutation.destination("writing", pathname, identity); },
-        beforeWrite: async () => {
-            mutation.assert();
-            await verify();
-        },
-        beforeRestore: async () => { mutation.assert(); await verifyRestore(); },
-        verifyRestore,
-        assertBeforeMutation: () => mutation.assert(),
-        published: () => mutation.destination("published", pathname, identity),
-    };
-}
-export function captureAtomicDestinationSync(fsModule, fd, pathname, mutation, rejectHardlinks) {
-    const identity = inspectFileIdentitySync(() => fsModule.fstatSync(fd, { bigint: true }));
-    regular(identity, pathname, rejectHardlinks);
-    let writing = false;
-    let restoreDescriptorOnly = false;
-    const verify = () => {
-        let metadataFailure = false;
-        const observe = (read) => {
-            try {
-                return read();
-            }
-            catch (error) {
-                metadataFailure = hasErrorCode(error, "EIO");
-                throw error;
+            const descriptorInspection = inspectAtomicIdentity(this.io, () => read(false), this.identity, false, admit);
+            if (this.io.asynchronous)
+                yield descriptorInspection;
+            if (!descriptorOnly) {
+                const pathnameInspection = inspectAtomicIdentity(this.io, () => read(true), this.identity, false, admit);
+                if (this.io.asynchronous)
+                    yield pathnameInspection;
             }
-        };
-        try {
-            inspectFileIdentitySync(() => regular(observe(() => fsModule.fstatSync(fd, { bigint: true })), pathname, rejectHardlinks), identity);
-            inspectFileIdentitySync(() => regular(observe(() => fsModule.lstatSync(pathname, { bigint: true })), pathname, rejectHardlinks), identity);
         }
         catch (error) {
-            if (writing && metadataFailure) {
-                restoreDescriptorOnly = true;
+            if (!descriptorOnly && this.#writing && metadataFailure) {
+                // Restore through the retained descriptor after a fresh exact check.
+                this.#restoreDescriptorOnly = true;
                 throw error;
             }
-            mutation.refuse(error);
-        }
-    };
-    const verifyRestore = () => {
-        if (!restoreDescriptorOnly)
-            return verify();
-        try {
-            inspectFileIdentitySync(() => regular(fsModule.fstatSync(fd, { bigint: true }), pathname, rejectHardlinks), identity);
+            this.mutation.refuse(error);
         }
-        catch (error) {
-            mutation.refuse(error);
-        }
-    };
-    return {
-        verify,
-        writing: () => { writing = true; mutation.destination("writing", pathname, identity); },
-        beforeWrite: () => {
-            mutation.assert();
-            verify();
-        },
-        beforeRestore: () => { mutation.assert(); verifyRestore(); },
-        verifyRestore,
-        published: () => mutation.destination("published", pathname, identity),
-    };
+    }
+    *beforeWrite(restore) {
+        this.mutation.assert();
+        yield* this.verify(restore);
+        // Async identity observations may revoke authority before dispatch resumes.
+        if (this.io.asynchronous)
+            this.mutation.assert();
+    }
+    writing() {
+        this.#writing = true;
+        this.mutation.destination("writing", this.pathname, this.identity);
+    }
+    published() {
+        this.mutation.destination("published", this.pathname, this.identity);
+    }
+}
+export function* captureAtomicDestination(io, file, pathname, mutation, rejectHardlinks) {
+    const inspection = inspectAtomicIdentity(io, () => file.statExact());
+    const identity = (io.asynchronous ? (yield inspection) : inspection);
+    regular(identity, pathname, rejectHardlinks);
+    return new AtomicDestination(io, file, pathname, mutation, rejectHardlinks, identity);
 }

package/node_modules/@openclaw/fs-safe/dist/replace-file-temp-owner.d.ts

@@ -1,49 +1,32 @@
-import syncFs, { type BigIntStats } from "node:fs";
-import fs, { type FileHandle } from "node:fs/promises";
-import { type TempPathRegistration } from "./temp-cleanup.js";
-type AsyncOwnerFileSystem = Pick<typeof fs, "lstat" | "open" | "unlink">;
-type SyncOwnerFileSystem = Pick<typeof syncFs, "closeSync" | "fstatSync" | "lstatSync" | "openSync" | "readFileSync" | "unlinkSync">;
+import { type BigIntStats } from "node:fs";
+import { type AtomicFile, type AtomicIo, type Procedure } from "./atomic-io.js";
 export type AtomicTempFailure = Readonly<{
     error: unknown;
 }>;
 export declare function removePathIfIdentityUnchanged(targetPath: string, identity: Pick<BigIntStats, "dev" | "ino">): Promise<void>;
-declare class AtomicTempOwner<Resource> {
+export declare class AtomicTempOwner {
     readonly pathname: string;
-    protected resource: Resource | undefined;
-    protected recordedIdentity: BigIntStats | undefined;
-    protected exists: boolean;
-    protected unregister: TempPathRegistration;
-    constructor(pathname: string);
+    private readonly io;
+    private resource;
+    private recordedIdentity;
+    private exists;
+    private readonly unregister;
+    constructor(pathname: string, io: AtomicIo);
     start(): void;
     readonly onIdentity: (identity: BigIntStats) => void;
     get identity(): BigIntStats;
     markRenamed(): void;
-    protected takeResource(): Resource | undefined;
-}
-export declare class AsyncAtomicTempOwner extends AtomicTempOwner<FileHandle> {
+    private takeResource;
     adopt(temp: {
-        handle: FileHandle;
+        file: AtomicFile;
         identity: BigIntStats;
     }): void;
-    assertCurrent(fsModule: AsyncOwnerFileSystem, pathname?: string): Promise<void>;
-    assertPublished(fsModule: AsyncOwnerFileSystem, pathname: string, expectedHash?: string, onVerified?: (identity: BigIntStats) => void): Promise<void>;
+    private inspectOwned;
+    assertCurrent(pathname?: string): Procedure<void>;
+    assertPublished(pathname: string, expectedHash?: string, onVerified?: (identity: BigIntStats) => void): Procedure<void>;
+    private cleanupOwnedPath;
     finish(params: {
-        fsModule: AsyncOwnerFileSystem;
         originalFailure?: AtomicTempFailure;
         throwOnCleanupError: boolean;
-    }): Promise<void>;
-}
-export declare class SyncAtomicTempOwner extends AtomicTempOwner<number> {
-    adopt(temp: {
-        fd: number;
-        identity: BigIntStats;
-    }): void;
-    assertCurrent(fsModule: SyncOwnerFileSystem, pathname?: string): void;
-    assertPublished(fsModule: SyncOwnerFileSystem, pathname: string, expectedHash?: string, onVerified?: (identity: BigIntStats) => void): void;
-    finish(params: {
-        fsModule: SyncOwnerFileSystem;
-        originalFailure?: AtomicTempFailure;
-        throwOnCleanupError: boolean;
-    }): void;
+    }): Procedure<void>;
 }
-export {};