@openclaw/feishu 2026.9.8 → 2026.10.1-beta.2

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

@@ -1,13 +1,13 @@
 import syncFs, {} from "node:fs";
-import fs, {} from "node:fs/promises";
+import fs from "node:fs/promises";
 import path from "node:path";
 import { createAsyncDirectoryGuard } from "./directory-guard.js";
-import { hasErrorCode, removeOwnedPath } from "./file-cleanup.js";
+import { hasErrorCode } from "./file-cleanup.js";
 import { resolveReadOpenFlags } from "./read-open-flags.js";
 import { FsSafeError } from "./errors.js";
 import { sameFileIdentityForCleanup, sha256Hex } from "./file-identity.js";
 import { withAsyncDirectoryGuards } from "./guarded-mutation.js";
-import { inspectFileIdentity, inspectFileIdentitySync } from "./strict-file-identity.js";
+import { inspectAtomicIdentity, wait } from "./atomic-io.js";
 import { registerTempPathForExit } from "./temp-cleanup.js";
 const PUBLISHED_READ_FLAGS = resolveReadOpenFlags();
 function describeFailure(error) {
@@ -66,49 +66,16 @@ function closeFailure(closeError, params, cleanupFailure) {
                 : closeError,
     };
 }
-async function cleanupOwnedPath(params) {
-    try {
-        await removeOwnedPath(params);
-        return true;
-    }
-    catch (cleanupError) {
-        if (params.throwOnCleanupError) {
-            throw cleanupFailure(params.originalFailure, cleanupError);
-        }
-        return false;
-    }
-}
-function cleanupOwnedPathSync(params) {
-    if (!params.identity)
-        return true;
-    try {
-        const current = params.fsModule.lstatSync(params.pathname, { bigint: true });
-        if (current.isSymbolicLink() ||
-            !current.isFile() ||
-            current.nlink !== 1n ||
-            !sameFileIdentityForCleanup(current, params.identity)) {
-            return true;
-        }
-        params.fsModule.unlinkSync(params.pathname);
-        return true;
-    }
-    catch (cleanupError) {
-        if (hasErrorCode(cleanupError, "ENOENT"))
-            return true;
-        if (params.throwOnCleanupError) {
-            throw cleanupFailure(params.originalFailure, cleanupError);
-        }
-        return false;
-    }
-}
-class AtomicTempOwner {
+export class AtomicTempOwner {
     pathname;
+    io;
     resource;
     recordedIdentity;
     exists = false;
     unregister;
-    constructor(pathname) {
+    constructor(pathname, io) {
         this.pathname = pathname;
+        this.io = io;
         this.unregister = registerTempPathForExit(pathname, { singleLinkFile: true });
     }
     start() {
@@ -133,26 +100,20 @@ class AtomicTempOwner {
         this.resource = undefined;
         return resource;
     }
-}
-export class AsyncAtomicTempOwner extends AtomicTempOwner {
     adopt(temp) {
-        this.resource = temp.handle;
+        this.resource = temp.file;
         this.onIdentity(temp.identity);
     }
-    async assertCurrent(fsModule, pathname = this.pathname) {
-        const opened = await inspectFileIdentity(async () => {
-            const stat = fsModule === fs ? syncFs.fstatSync(this.resource.fd, { bigint: true })
-                : await this.resource.stat({ bigint: true });
-            assertOwnedFile(stat, pathname, false);
-            return stat;
-        }, this.identity);
+    inspectOwned(read, pathname, pathnameEntry, expected) {
+        return inspectAtomicIdentity(this.io, read, expected, false, stat => assertOwnedFile(stat, pathname, pathnameEntry));
+    }
+    *assertCurrent(pathname = this.pathname) {
+        const openedInspection = this.inspectOwned(() => this.resource.statExact(), pathname, false, this.identity);
+        const opened = (this.io.asynchronous ? (yield openedInspection) : openedInspection);
         try {
-            await inspectFileIdentity(async () => {
-                const stat = fsModule === fs ? syncFs.lstatSync(pathname, { bigint: true })
-                    : await fsModule.lstat(pathname, { bigint: true });
-                assertOwnedFile(stat, pathname, true);
-                return stat;
-            }, opened);
+            const currentInspection = this.inspectOwned(() => this.io.lstatExact(pathname), pathname, true, opened);
+            if (this.io.asynchronous)
+                yield currentInspection;
         }
         catch (error) {
             if (hasErrorCode(error, "ENOENT")) {
@@ -161,10 +122,10 @@ export class AsyncAtomicTempOwner extends AtomicTempOwner {
             throw error;
         }
     }
-    async assertPublished(fsModule, pathname, expectedHash, onVerified) {
+    *assertPublished(pathname, expectedHash, onVerified) {
         let identityCurrent = false;
         try {
-            await this.assertCurrent(fsModule, pathname);
+            yield* this.assertCurrent(pathname);
             identityCurrent = true;
         }
         catch (error) {
@@ -179,7 +140,7 @@ export class AsyncAtomicTempOwner extends AtomicTempOwner {
         let published;
         try {
             try {
-                published = await fsModule.open(pathname, PUBLISHED_READ_FLAGS);
+                published = yield* this.io.open(pathname, PUBLISHED_READ_FLAGS);
             }
             catch (error) {
                 if (hasErrorCode(error, "ELOOP")) {
@@ -189,163 +150,63 @@ export class AsyncAtomicTempOwner extends AtomicTempOwner {
                 }
                 throw error;
             }
-            const identity = await inspectFileIdentity(async () => {
-                const stat = fsModule === fs ? syncFs.fstatSync(published.fd, { bigint: true })
-                    : await published.stat({ bigint: true });
-                assertOwnedFile(stat, pathname, false);
-                return stat;
-            });
-            await inspectFileIdentity(async () => {
-                const stat = fsModule === fs ? syncFs.lstatSync(pathname, { bigint: true })
-                    : await fsModule.lstat(pathname, { bigint: true });
-                assertOwnedFile(stat, pathname, true);
-                return stat;
-            }, identity);
-            if (sha256Hex(await published.readFile()) !== expectedHash) {
+            const openedInspection = this.inspectOwned(() => published.statExact(), pathname, false);
+            const identity = (this.io.asynchronous ? (yield openedInspection) : openedInspection);
+            const currentInspection = this.inspectOwned(() => this.io.lstatExact(pathname), pathname, true, identity);
+            if (this.io.asynchronous)
+                yield currentInspection;
+            if (sha256Hex(yield* published.readFile()) !== expectedHash) {
                 throw new FsSafeError("path-mismatch", `Atomic replace published content changed: ${pathname}`);
             }
             onVerified?.(identity);
-            const previousHandle = this.takeResource();
-            await previousHandle?.close();
+            const previous = this.takeResource();
+            const closing = previous?.close();
+            if (previous && this.io.asynchronous)
+                yield closing;
             this.resource = published;
             this.recordedIdentity = identity;
             published = undefined;
         }
         finally {
             try {
-                await published?.close();
+                const closing = published?.close();
+                if (published && this.io.asynchronous)
+                    yield closing;
             }
             catch {
-                // Preserve the selected verification or previous-handle close failure.
-            }
-        }
-    }
-    async finish(params) {
-        let deferredFailure;
-        let cleanupComplete = !this.exists;
-        if (this.exists) {
-            try {
-                cleanupComplete = await cleanupOwnedPath({
-                    fsModule: params.fsModule,
-                    pathname: this.pathname,
-                    identity: this.recordedIdentity,
-                    originalFailure: params.originalFailure,
-                    throwOnCleanupError: params.throwOnCleanupError,
-                });
-            }
-            catch (error) {
-                deferredFailure = { error };
+                // Preserve the selected verification or previous-resource close failure.
             }
         }
-        if (cleanupComplete)
-            this.unregister();
-        const handle = this.takeResource();
-        try {
-            await handle?.close();
-        }
-        catch (closeError) {
-            deferredFailure = closeFailure(closeError, params, deferredFailure);
-        }
-        if (deferredFailure)
-            throw deferredFailure.error;
     }
-}
-export class SyncAtomicTempOwner extends AtomicTempOwner {
-    adopt(temp) {
-        this.resource = temp.fd;
-        this.onIdentity(temp.identity);
-    }
-    assertCurrent(fsModule, pathname = this.pathname) {
-        const opened = inspectFileIdentitySync(() => {
-            const stat = fsModule.fstatSync(this.resource, { bigint: true });
-            assertOwnedFile(stat, pathname, false);
-            return stat;
-        }, this.identity);
-        try {
-            inspectFileIdentitySync(() => {
-                const stat = fsModule.lstatSync(pathname, { bigint: true });
-                assertOwnedFile(stat, pathname, true);
-                return stat;
-            }, opened);
-        }
-        catch (error) {
-            if (hasErrorCode(error, "ENOENT")) {
-                throw missingOwnedFile(pathname, error);
-            }
-            throw error;
-        }
-    }
-    assertPublished(fsModule, pathname, expectedHash, onVerified) {
-        let identityCurrent = false;
-        try {
-            this.assertCurrent(fsModule, pathname);
-            identityCurrent = true;
-        }
-        catch (error) {
-            if (!(error instanceof FsSafeError) || !hasErrorCode(error, "path-mismatch") || !expectedHash) {
-                throw error;
-            }
-        }
-        if (identityCurrent) {
-            onVerified?.(this.identity);
-            return;
-        }
-        let publishedFd;
+    *cleanupOwnedPath(params) {
+        const identity = this.recordedIdentity;
+        if (!identity)
+            return true;
         try {
-            try {
-                publishedFd = fsModule.openSync(pathname, PUBLISHED_READ_FLAGS);
+            const observation = this.io.lstatExact(this.pathname);
+            const current = this.io.asyncFs && this.io.asyncFs !== fs
+                ? yield* wait(observation) : observation;
+            if (!current.isSymbolicLink() && current.isFile() && current.nlink === 1n &&
+                sameFileIdentityForCleanup(current, identity)) {
+                yield* this.io.unlink(this.pathname);
             }
-            catch (error) {
-                if (hasErrorCode(error, "ELOOP")) {
-                    throw new FsSafeError("symlink", `Atomic replace published file became a symlink: ${pathname}`, {
-                        cause: error,
-                    });
-                }
-                throw error;
-            }
-            const identity = inspectFileIdentitySync(() => {
-                const stat = fsModule.fstatSync(publishedFd, { bigint: true });
-                assertOwnedFile(stat, pathname, false);
-                return stat;
-            });
-            inspectFileIdentitySync(() => {
-                const stat = fsModule.lstatSync(pathname, { bigint: true });
-                assertOwnedFile(stat, pathname, true);
-                return stat;
-            }, identity);
-            if (sha256Hex(fsModule.readFileSync(publishedFd)) !== expectedHash) {
-                throw new FsSafeError("path-mismatch", `Atomic replace published content changed: ${pathname}`);
-            }
-            onVerified?.(identity);
-            const previousFd = this.takeResource();
-            fsModule.closeSync(previousFd);
-            this.resource = publishedFd;
-            this.recordedIdentity = identity;
-            publishedFd = undefined;
+            return true;
         }
-        finally {
-            if (publishedFd !== undefined) {
-                try {
-                    fsModule.closeSync(publishedFd);
-                }
-                catch {
-                    // Best-effort close after a rejected content verification.
-                }
+        catch (cleanupError) {
+            if (hasErrorCode(cleanupError, "ENOENT"))
+                return true;
+            if (params.throwOnCleanupError) {
+                throw cleanupFailure(params.originalFailure, cleanupError);
             }
+            return false;
         }
     }
-    finish(params) {
+    *finish(params) {
         let deferredFailure;
         let cleanupComplete = !this.exists;
         if (this.exists) {
             try {
-                cleanupComplete = cleanupOwnedPathSync({
-                    fsModule: params.fsModule,
-                    pathname: this.pathname,
-                    identity: this.recordedIdentity,
-                    originalFailure: params.originalFailure,
-                    throwOnCleanupError: params.throwOnCleanupError,
-                });
+                cleanupComplete = yield* this.cleanupOwnedPath(params);
             }
             catch (error) {
                 deferredFailure = { error };
@@ -353,14 +214,14 @@ export class SyncAtomicTempOwner extends AtomicTempOwner {
         }
         if (cleanupComplete)
             this.unregister();
-        const fd = this.takeResource();
-        if (fd !== undefined) {
-            try {
-                params.fsModule.closeSync(fd);
-            }
-            catch (closeError) {
-                deferredFailure = closeFailure(closeError, params, deferredFailure);
-            }
+        const file = this.takeResource();
+        try {
+            const closing = file?.close();
+            if (file && this.io.asynchronous)
+                yield closing;
+        }
+        catch (closeError) {
+            deferredFailure = closeFailure(closeError, params, deferredFailure);
         }
         if (deferredFailure)
             throw deferredFailure.error;

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

@@ -4,14 +4,9 @@ import type { RenameIdentityPolicy } from "./pinned-write-types.js";
 import type { AtomicMutationOptions } from "./replace-file-mutation.js";
 import type { ReplaceFileCopyFallbackRestorePolicy, ReplaceFileDestinationHardlinkPolicy } from "./replace-file-copy-fallback.js";
 export type ReplaceFileAtomicFileSystem = {
-    promises: Pick<typeof fs, "mkdir" | "writeFile" | "rename" | "copyFile" | "unlink" | "rm" | "open" | "stat" | "lstat"> & {
-        /** @deprecated Accepted for adapter compatibility but never called. */
-        chmod?: typeof fs.chmod;
-    };
+    promises: Pick<typeof fs, "mkdir" | "writeFile" | "rename" | "copyFile" | "unlink" | "rm" | "open" | "stat" | "lstat">;
 };
 export type ReplaceFileAtomicSyncFileSystem = Pick<typeof syncFs, "mkdirSync" | "readFileSync" | "writeFileSync" | "renameSync" | "copyFileSync" | "unlinkSync" | "rmSync" | "openSync" | "fsyncSync" | "closeSync" | "fstatSync" | "statSync" | "lstatSync" | "ftruncateSync" | "readSync" | "writeSync"> & {
-    /** @deprecated Accepted for adapter compatibility but never called. */
-    chmodSync?: typeof syncFs.chmodSync;
     fchmodSync?: typeof syncFs.fchmodSync;
 };
 export type ReplaceFileAtomicBaseOptions = AtomicMutationOptions & {