@openclaw/feishu 2026.9.8 → 2026.10.1-beta.2

package/node_modules/@openclaw/fs-safe/dist/absolute-path.js

@@ -1,7 +1,7 @@
 import fsSync from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { assertAsyncDirectoryGuard, createAsyncDirectoryGuard, } from "./directory-guard.js";
+import { assertDirectoryGuard, captureDirectoryGuard, } from "./directory-guard.js";
 import { FsSafeError } from "./errors.js";
 import { pathExists } from "./fs.js";
 import { realpathSync } from "./realpath.js";
@@ -22,27 +22,35 @@ function ensureDirectoryFailure(code, message, cause) {
         error: new FsSafeError(code, message, { cause }),
     };
 }
-async function assertGuardResult(guard, scopeLabel) {
+function directoryGuardResult(target, scopeLabel) {
     try {
-        await assertAsyncDirectoryGuard(guard);
-        return { ok: true };
+        const guard = typeof target === "string" ? captureDirectoryGuard(target, "native", { bigint: true }) : target;
+        if (typeof target !== "string")
+            assertDirectoryGuard(guard, "native");
+        return { ok: true, guard };
     }
     catch (err) {
-        if (err instanceof FsSafeError) {
-            return await directoryGuardFailure(err, guard.dir, scopeLabel);
+        if (!(err instanceof FsSafeError))
+            throw err;
+        const dir = typeof target === "string" ? target : target.dir;
+        if (err.code !== "not-file") {
+            return { ok: false, code: err.code, error: err };
         }
-        throw err;
-    }
-}
-async function createDirectoryGuardResult(dir, scopeLabel) {
-    try {
-        return { ok: true, guard: await createAsyncDirectoryGuard(dir) };
-    }
-    catch (err) {
-        if (err instanceof FsSafeError) {
-            return await directoryGuardFailure(err, dir, scopeLabel);
+        try {
+            const stat = fsSync.lstatSync(pathForWindowsFilesystem(dir));
+            const failure = classifyExistingDirectorySegment(stat, scopeLabel);
+            if (failure) {
+                return failure;
+            }
         }
-        throw err;
+        catch (lookupErr) {
+            const failure = classifyDirectoryLookupError(lookupErr, scopeLabel);
+            if (failure) {
+                return failure;
+            }
+            throw lookupErr;
+        }
+        return { ok: false, code: err.code, error: err };
     }
 }
 function classifyDirectoryLookupError(err, scopeLabel) {
@@ -64,27 +72,7 @@ function classifyExistingDirectorySegment(stat, scopeLabel) {
     }
     return null;
 }
-async function directoryGuardFailure(err, dir, scopeLabel) {
-    if (err.code !== "not-file") {
-        return { ok: false, code: err.code, error: err };
-    }
-    try {
-        const stat = fsSync.lstatSync(pathForWindowsFilesystem(dir));
-        const failure = classifyExistingDirectorySegment(stat, scopeLabel);
-        if (failure) {
-            return failure;
-        }
-    }
-    catch (lookupErr) {
-        const failure = classifyDirectoryLookupError(lookupErr, scopeLabel);
-        if (failure) {
-            return failure;
-        }
-        throw lookupErr;
-    }
-    return { ok: false, code: err.code, error: err };
-}
-async function resolveTrustedDirectoryPrefix(targetPath, scopeLabel) {
+function resolveTrustedDirectoryPrefix(targetPath, scopeLabel) {
     const root = path.parse(targetPath).root;
     let current = root;
     let currentStat;
@@ -119,7 +107,6 @@ async function resolveTrustedDirectoryPrefix(targetPath, scopeLabel) {
                 return segmentFailure;
             }
             current = next;
-            currentStat = nextStat;
         }
         catch (err) {
             const code = err.code;
@@ -192,7 +179,7 @@ export async function ensureAbsoluteDirectory(dirPath, options = {}) {
         return prefix;
     }
     let current = prefix.ancestorPath;
-    const initialGuard = await createDirectoryGuardResult(prefix.ancestorPath, scopeLabel);
+    const initialGuard = await directoryGuardResult(prefix.ancestorPath, scopeLabel);
     if (!initialGuard.ok) {
         return initialGuard;
     }
@@ -200,25 +187,22 @@ export async function ensureAbsoluteDirectory(dirPath, options = {}) {
     for (const segment of prefix.missingSegments) {
         current = path.join(current, segment);
         while (true) {
-            const guardResult = await assertGuardResult(currentGuard, scopeLabel);
+            const guardResult = await directoryGuardResult(currentGuard, scopeLabel);
             if (!guardResult.ok) {
                 return guardResult;
             }
             try {
                 const stat = fsSync.lstatSync(current);
-                if (stat.isSymbolicLink()) {
-                    return ensureDirectoryFailure("symlink", `directory path traverses a symlink within ${scopeLabel}`);
-                }
-                if (!stat.isDirectory()) {
-                    return ensureDirectoryFailure("not-file", `path must be a real directory within ${scopeLabel}`);
-                }
+                const failure = classifyExistingDirectorySegment(stat, scopeLabel);
+                if (failure)
+                    return failure;
                 break;
             }
             catch (err) {
                 if (err.code !== "ENOENT") {
                     throw err;
                 }
-                const parentStillValid = await assertGuardResult(currentGuard, scopeLabel);
+                const parentStillValid = await directoryGuardResult(currentGuard, scopeLabel);
                 if (!parentStillValid.ok) {
                     return parentStillValid;
                 }
@@ -233,17 +217,17 @@ export async function ensureAbsoluteDirectory(dirPath, options = {}) {
                 }
             }
         }
-        const nextGuard = await createDirectoryGuardResult(current, scopeLabel);
+        const nextGuard = await directoryGuardResult(current, scopeLabel);
         if (!nextGuard.ok) {
             return nextGuard;
         }
-        const previousGuardStillValid = await assertGuardResult(currentGuard, scopeLabel);
+        const previousGuardStillValid = await directoryGuardResult(currentGuard, scopeLabel);
         if (!previousGuardStillValid.ok) {
             return previousGuardStillValid;
         }
         currentGuard = nextGuard.guard;
     }
-    const finalGuardResult = await assertGuardResult(currentGuard, scopeLabel);
+    const finalGuardResult = await directoryGuardResult(currentGuard, scopeLabel);
     if (!finalGuardResult.ok) {
         return finalGuardResult;
     }

package/node_modules/@openclaw/fs-safe/dist/advanced.d.ts

@@ -39,3 +39,5 @@ export { createIcaclsResetCommand, formatIcaclsResetCommand, formatWindowsAclSum
 export type { PermissionCommandFailure } from "./permission-exec.js";
 export { retainFileInDirectory } from "./retained-file.js";
 export type { RetainedFile, RetainedFileAdmission, RetainedFileExpected, RetainedFileIssue, RetainedFileReceipt, RetainedFileResult, RetainFileInDirectoryOptions, } from "./retained-file-types.js";
+export { retainEntryForPublication } from "./entry-publication.js";
+export type { PublicationIdentity, PublicationParent, RetainEntryForPublicationOptions, EntryPublicationReceipt, EntryPublicationIssue, EntryPublicationResult, RetainedEntryPublication, } from "./entry-publication-types.js";

package/node_modules/@openclaw/fs-safe/dist/advanced.js

@@ -38,3 +38,4 @@ export { buildRandomTempFilePath, sanitizeTempFileName, tempFile, withTempFile,
 export { writeSiblingTempFile, writeViaSiblingTempPath, } from "./sibling-temp.js";
 export { createIcaclsResetCommand, formatIcaclsResetCommand, formatWindowsAclSummary, inspectWindowsAcl, parseIcaclsOutput, resolveWindowsUserPrincipal, summarizeWindowsAcl, } from "./permissions-windows.js";
 export { retainFileInDirectory } from "./retained-file.js";
+export { retainEntryForPublication } from "./entry-publication.js";

package/node_modules/@openclaw/fs-safe/dist/archive-input.js

@@ -6,6 +6,7 @@ import { FsSafeError } from "./errors.js";
 import { inspectFileIdentity } from "./strict-file-identity.js";
 import { resolveReadOpenFlags } from "./read-open-flags.js";
 import { tempFile } from "./temp-target.js";
+import { assertExclusiveCreateLeaf } from "./exclusive-create.js";
 import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
 async function closeFileHandle(handle) {
     if (handle)
@@ -64,6 +65,7 @@ export async function stageArchiveFileForExtraction(params) {
             (process.platform !== "win32" && "O_NOFOLLOW" in fsConstants
                 ? fsConstants.O_NOFOLLOW
                 : 0);
+        assertExclusiveCreateLeaf(staged.path);
         output = await fs.open(staged.path, flags, 0o600);
         const buffer = Buffer.allocUnsafe(Math.min(512 * 1024, Math.max(64 * 1024, Number(opened.size)), params.limits.maxArchiveBytes + 1));
         let written = 0;

package/node_modules/@openclaw/fs-safe/dist/archive-staging.d.ts

@@ -3,6 +3,7 @@ import { type AsyncDirectoryGuard } from "./directory-guard.js";
 import { type ExtractionDeadline } from "./archive-deadline.js";
 import { ArchiveSecurityError } from "./archive-errors.js";
 export type ArchiveDirectoryGuard = AsyncDirectoryGuard<BigIntStats>;
+export declare function createArchiveSymlinkTraversalError(originalPath: string): ArchiveSecurityError;
 export declare function createDirectoryIdentityGuard(dir: string): Promise<ArchiveDirectoryGuard>;
 export declare function assertDirectoryIdentityGuard(guard: ArchiveDirectoryGuard): Promise<void>;
 export declare function prepareArchiveDestinationGuard(destDir: string): Promise<ArchiveDirectoryGuard>;
@@ -28,5 +29,4 @@ export declare function withStagedArchiveDestination<T>(params: {
     stagingDirPrefix?: string;
     run: (stagingDir: string) => Promise<T>;
 }): Promise<T>;
-export declare function createArchiveSymlinkTraversalError(originalPath: string): ArchiveSecurityError;
 export {};

package/node_modules/@openclaw/fs-safe/dist/archive-staging.js

@@ -14,14 +14,14 @@ import { mkdirPathComponentsWithGuards } from "./guarded-mkdir.js";
 import { expandRelativePathWithHome } from "./root-context.js";
 import { resolveRootPath } from "./root-path.js";
 import { inspectFileIdentitySync } from "./strict-file-identity.js";
-import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
+import { assertNoWindowsPathAlias, isForeignWindowsShareOrDevicePath } from "./windows-path-alias.js";
 import { realpathSync } from "./realpath.js";
 const ERROR_ARCHIVE_ENTRY_TRAVERSES_SYMLINK = "archive entry traverses symlink in destination";
 const ARCHIVE_STAGING_MODE = 0o700;
 function checkExtractionDeadline(deadline) {
     deadline?.check();
 }
-function symlinkTraversalError(originalPath) {
+export function createArchiveSymlinkTraversalError(originalPath) {
     return new ArchiveSecurityError("destination-symlink-traversal", `${ERROR_ARCHIVE_ENTRY_TRAVERSES_SYMLINK}: ${formatErrorDetail(originalPath)}`);
 }
 export async function createDirectoryIdentityGuard(dir) {
@@ -106,7 +106,7 @@ async function assertNoSymlinkTraversal(params) {
             throw err;
         }
         if (stat.isSymbolicLink()) {
-            throw symlinkTraversalError(params.originalPath);
+            throw createArchiveSymlinkTraversalError(params.originalPath);
         }
     }
 }
@@ -128,7 +128,7 @@ export async function assertResolvedInsideDestination(params) {
     }
     assertNoWindowsPathAlias(resolved);
     if (!isPathInside(destinationRealDir, resolved)) {
-        throw symlinkTraversalError(originalPath);
+        throw createArchiveSymlinkTraversalError(originalPath);
     }
 }
 async function mkdirArchiveOutput(params) {
@@ -139,7 +139,7 @@ async function mkdirArchiveOutput(params) {
     }
     catch (error) {
         if (error instanceof FsSafeError) {
-            throw symlinkTraversalError(params.originalPath);
+            throw createArchiveSymlinkTraversalError(params.originalPath);
         }
         throw error;
     }
@@ -166,6 +166,9 @@ export async function preparePrivateArchiveOutputPath(params, assertGuards, dest
     await prepareOutputPath(ownArchiveOutputPathParams(params), assertGuards, true, destinationGuard);
 }
 async function prepareOutputPath(params, assertGuards, privateWorkingMode = false, existingDestinationGuard) {
+    if (isForeignWindowsShareOrDevicePath(params.outPath, [params.destinationDir, params.destinationRealDir])) {
+        throw createArchiveSymlinkTraversalError(params.originalPath);
+    }
     const targetRoot = privateWorkingMode ? {
         async mkdir(relativePath) {
             // Retain Root.mkdir's strict alias admission before the shared traversal,
@@ -298,11 +301,7 @@ export async function withStagedArchiveDestination(params) {
             await fs.rm(stagingDir, { recursive: true, force: true }).catch(() => undefined);
         }
         catch {
-            // The staging path identity changed; deleting by name could target data
-            // outside the private temp tree, so fail closed and leave it for OS cleanup.
+            // Preserve staging when its identity cannot be verified; pathname cleanup is unsafe.
         }
     }
 }
-export function createArchiveSymlinkTraversalError(originalPath) {
-    return symlinkTraversalError(originalPath);
-}

package/node_modules/@openclaw/fs-safe/dist/archive.js

@@ -17,6 +17,7 @@ import { ArchiveSecurityError, ArchiveFormatError, isArchiveFormatErrorMessage,
 import { stageArchiveFileForExtraction } from "./archive-input.js";
 import { getNativeBinding, } from "./native.js";
 import { writeSiblingTempFile } from "./sibling-temp.js";
+import { assertExclusiveCreateLeaf } from "./exclusive-create.js";
 import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
 import { classifyArchiveParserError } from "./archive-parser-errors.js";
 import { validateArchiveEntryPath } from "./archive-entry.js";
@@ -61,6 +62,7 @@ async function writeZipFileEntry(params) {
             syncTempFile: false,
             syncParentDir: false,
             writeTemp: async (tempPath) => {
+                assertExclusiveCreateLeaf(tempPath);
                 tempHandle = await fs.open(tempPath, OPEN_WRITE_CREATE_FLAGS, 0o600);
                 const writable = tempHandle.createWriteStream();
                 writable.once("close", () => {
@@ -83,11 +85,6 @@ async function writeZipFileEntry(params) {
             resolveFinalPath: (filePath) => filePath,
         });
     }
-    catch (err) {
-        // Failures here happen before the temp has been committed. The destination
-        // parent may already be untrusted, so cleanup must stay limited to temp state.
-        throw err;
-    }
     finally {
         const openTempHandle = tempHandle;
         if (openTempHandle && !handleClosedByStream) {

package/node_modules/@openclaw/fs-safe/dist/atomic-io.d.ts

@@ -0,0 +1,51 @@
+import syncFs, { type BigIntStats, type Stats } from "node:fs";
+import fs, { type FileHandle } from "node:fs/promises";
+export type Procedure<T> = Generator<unknown, T, unknown>;
+type SyncFchmod = (fd: number, mode: number) => void;
+type AsyncAtomicFileSystem = Partial<Pick<typeof fs, "open" | "lstat" | "mkdir" | "rename" | "rm" | "unlink" | "writeFile">>;
+type SyncAtomicFileSystem = Partial<Pick<typeof syncFs, "openSync" | "lstatSync" | "mkdirSync" | "renameSync" | "rmSync" | "unlinkSync" | "fstatSync" | "closeSync" | "fsyncSync" | "writeFileSync" | "readFileSync" | "readSync" | "writeSync" | "ftruncateSync">>;
+export declare function wait<T>(value: T | PromiseLike<T>): Procedure<T>;
+export declare function runAsync<T>(procedure: Procedure<T>): Promise<T>;
+export declare function runSync<T>(procedure: Procedure<T>): T;
+export declare function inspectAtomicIdentity<T extends Pick<BigIntStats, "dev" | "ino">>(io: AtomicIo, read: () => T | Promise<T>, expected?: Pick<BigIntStats, "dev" | "ino">, synchronous?: boolean, admit?: (stat: T) => void): T | Promise<T>;
+/** One adapter per operation; each admitted descriptor receives one AtomicFile. */
+export declare class AtomicIo {
+    readonly asyncFs: AsyncAtomicFileSystem | undefined;
+    readonly syncFs: SyncAtomicFileSystem | undefined;
+    fchmodSync?: SyncFchmod | undefined;
+    readonly asynchronous: boolean;
+    private constructor();
+    static async(fsModule: AsyncAtomicFileSystem): AtomicIo;
+    static sync(fsModule: SyncAtomicFileSystem, fchmodSync?: SyncFchmod): AtomicIo;
+    wrap(resource: FileHandle | number): AtomicFile;
+    open(pathname: string, flags: string | number, mode?: number): Procedure<AtomicFile>;
+    lstat(pathname: string): Procedure<Stats>;
+    lstatExact(pathname: string, synchronousBuiltin?: boolean): BigIntStats | Promise<BigIntStats>;
+    mkdir(directory: string, mode: number): Procedure<void>;
+    rename(source: string, destination: string): Procedure<void>;
+    remove(pathname: string): Procedure<void>;
+    unlink(pathname: string): Procedure<void>;
+    delay(milliseconds: number): Procedure<void>;
+}
+export declare class AtomicFile {
+    readonly io: AtomicIo;
+    readonly resource: FileHandle | number;
+    constructor(io: AtomicIo, resource: FileHandle | number);
+    get fd(): number;
+    stat(): Procedure<Stats>;
+    statExact(): BigIntStats | Promise<BigIntStats>;
+    close(): void | Promise<void>;
+    sync(): Procedure<void>;
+    syncBestEffort(): Procedure<void>;
+    chmod(mode: number): void | Promise<void>;
+    writeFile(data: string | Uint8Array, throughModule?: boolean): void | Promise<void>;
+    readFile(sizeHint?: number): Procedure<Buffer>;
+    read(buffer: Buffer, offset: number, length: number, position: number | null): number | Promise<{
+        bytesRead: number;
+    }>;
+    write(buffer: Buffer, offset: number, length: number, position: number | null): number | Promise<{
+        bytesWritten: number;
+    }>;
+    truncate(length: number): Procedure<void>;
+}
+export {};

package/node_modules/@openclaw/fs-safe/dist/atomic-io.js

@@ -0,0 +1,242 @@
+import syncFs, {} from "node:fs";
+import fs, {} from "node:fs/promises";
+import { readBoundedSync } from "./bounded-read.js";
+import { recursiveMkdirPath } from "./recursive-mkdir-path.js";
+import { inspectFileIdentity, inspectFileIdentitySync } from "./strict-file-identity.js";
+import { sleep, sleepSync } from "./timing.js";
+import { assertExclusiveCreateStat } from "./exclusive-create.js";
+import { hasNodeErrorCode } from "./path.js";
+export function* wait(value) {
+    return (yield value);
+}
+export async function runAsync(procedure) {
+    let step = procedure.next();
+    while (!step.done) {
+        let value;
+        try {
+            value = await step.value;
+        }
+        catch (error) {
+            step = procedure.throw(error);
+            continue;
+        }
+        step = procedure.next(value);
+    }
+    return step.value;
+}
+export function runSync(procedure) {
+    let step = procedure.next();
+    // Sync adapters retain their ordinary return values; this driver never reads then.
+    while (!step.done)
+        step = procedure.next(step.value);
+    return step.value;
+}
+export function inspectAtomicIdentity(io, read, expected, synchronous = false, admit) {
+    if (io.asynchronous && !synchronous) {
+        const inspect = admit ? async () => {
+            const stat = await read();
+            admit(stat);
+            return stat;
+        } : read;
+        return inspectFileIdentity(inspect, expected);
+    }
+    // Sync metadata is an ordinary value, including objects with a then getter.
+    const inspect = admit ? () => {
+        const stat = read();
+        admit(stat);
+        return stat;
+    } : read;
+    return inspectFileIdentitySync(inspect, expected);
+}
+/** One adapter per operation; each admitted descriptor receives one AtomicFile. */
+export class AtomicIo {
+    asyncFs;
+    syncFs;
+    fchmodSync;
+    asynchronous;
+    constructor(asyncFs, syncFs, fchmodSync) {
+        this.asyncFs = asyncFs;
+        this.syncFs = syncFs;
+        this.fchmodSync = fchmodSync;
+        this.asynchronous = asyncFs !== undefined;
+    }
+    static async(fsModule) {
+        return new AtomicIo(fsModule, undefined);
+    }
+    static sync(fsModule, fchmodSync) {
+        return new AtomicIo(undefined, fsModule, fchmodSync);
+    }
+    wrap(resource) {
+        return new AtomicFile(this, resource);
+    }
+    *open(pathname, flags, mode) {
+        const withMode = arguments.length > 2;
+        const exclusive = syncFs.constants.O_CREAT | syncFs.constants.O_EXCL;
+        if (process.platform === "win32" && (typeof flags === "string"
+            ? flags.includes("x") : (flags & exclusive) === exclusive)) {
+            try {
+                assertExclusiveCreateStat(pathname, yield* this.lstat(pathname));
+            }
+            catch (error) {
+                if (!hasNodeErrorCode(error, "ENOENT"))
+                    throw error;
+            }
+        }
+        const resource = this.asyncFs
+            ? yield* wait(withMode
+                ? this.asyncFs.open(pathname, flags, mode)
+                : this.asyncFs.open(pathname, flags))
+            : withMode
+                ? this.syncFs.openSync(pathname, flags, mode)
+                : this.syncFs.openSync(pathname, flags);
+        return this.wrap(resource);
+    }
+    *lstat(pathname) {
+        if (!this.asyncFs)
+            return this.syncFs.lstatSync(pathname);
+        if (this.asyncFs === fs)
+            return syncFs.lstatSync(pathname);
+        return yield* wait(this.asyncFs.lstat(pathname));
+    }
+    lstatExact(pathname, synchronousBuiltin = true) {
+        if (!this.asyncFs)
+            return this.syncFs.lstatSync(pathname, { bigint: true });
+        if (synchronousBuiltin && this.asyncFs === fs)
+            return syncFs.lstatSync(pathname, { bigint: true });
+        return this.asyncFs.lstat(pathname, { bigint: true });
+    }
+    *mkdir(directory, mode) {
+        if (this.asyncFs) {
+            const pathname = this.asyncFs === fs ? recursiveMkdirPath(directory) : directory;
+            yield* wait(this.asyncFs.mkdir(pathname, { recursive: true, mode }));
+        }
+        else {
+            const pathname = this.syncFs === syncFs ? recursiveMkdirPath(directory) : directory;
+            this.syncFs.mkdirSync(pathname, { recursive: true, mode });
+        }
+    }
+    *rename(source, destination) {
+        if (this.asyncFs)
+            yield* wait(this.asyncFs.rename(source, destination));
+        else
+            this.syncFs.renameSync(source, destination);
+    }
+    *remove(pathname) {
+        if (this.asyncFs)
+            yield* wait(this.asyncFs.rm(pathname, { force: true }));
+        else
+            this.syncFs.rmSync(pathname, { force: true });
+    }
+    *unlink(pathname) {
+        if (this.asyncFs)
+            yield* wait(this.asyncFs.unlink(pathname));
+        else
+            this.syncFs.unlinkSync(pathname);
+    }
+    *delay(milliseconds) {
+        if (this.asynchronous)
+            yield* wait(sleep(milliseconds));
+        else
+            sleepSync(milliseconds);
+    }
+}
+export class AtomicFile {
+    io;
+    resource;
+    constructor(io, resource) {
+        this.io = io;
+        this.resource = resource;
+    }
+    get fd() {
+        return typeof this.resource === "number" ? this.resource : this.resource.fd;
+    }
+    *stat() {
+        if (typeof this.resource === "number")
+            return this.io.syncFs.fstatSync(this.resource);
+        if (this.io.asyncFs === fs)
+            return syncFs.fstatSync(this.resource.fd);
+        return yield* wait(this.resource.stat());
+    }
+    statExact() {
+        if (typeof this.resource === "number")
+            return this.io.syncFs.fstatSync(this.resource, { bigint: true });
+        if (this.io.asyncFs === fs)
+            return syncFs.fstatSync(this.resource.fd, { bigint: true });
+        return this.resource.stat({ bigint: true });
+    }
+    close() {
+        if (typeof this.resource === "number")
+            this.io.syncFs.closeSync(this.resource);
+        else
+            return this.resource.close();
+    }
+    *sync() {
+        if (typeof this.resource === "number")
+            this.io.syncFs.fsyncSync(this.resource);
+        else
+            yield* wait(this.resource.sync());
+    }
+    *syncBestEffort() {
+        try {
+            yield* this.sync();
+        }
+        catch (error) {
+            if (error?.code !== "EPERM")
+                throw error;
+        }
+    }
+    chmod(mode) {
+        if (typeof this.resource === "number") {
+            const chmod = this.io.fchmodSync;
+            chmod?.(this.resource, mode);
+        }
+        else {
+            return this.resource.chmod(mode);
+        }
+    }
+    writeFile(data, throughModule = false) {
+        if (typeof this.resource === "number") {
+            this.io.syncFs.writeFileSync(this.resource, data);
+        }
+        else if (throughModule) {
+            return this.io.asyncFs.writeFile(this.resource, data);
+        }
+        else {
+            return this.resource.writeFile(data);
+        }
+    }
+    *readFile(sizeHint) {
+        if (typeof this.resource !== "number")
+            return yield* wait(this.resource.readFile());
+        if (sizeHint === undefined)
+            return this.io.syncFs.readFileSync(this.resource);
+        const fd = this.resource;
+        let position = 0;
+        return readBoundedSync(Infinity, (buffer, length) => {
+            const bytesRead = this.io.syncFs.readSync(fd, buffer, 0, length, position);
+            position += bytesRead;
+            return bytesRead;
+        }, { initialSize: Number.isSafeInteger(sizeHint) && sizeHint >= 0 ? sizeHint : undefined });
+    }
+    read(buffer, offset, length, position) {
+        if (typeof this.resource === "number") {
+            return this.io.syncFs.readSync(this.resource, buffer, offset, length, position);
+        }
+        return this.resource.read(buffer, offset, length, position);
+    }
+    write(buffer, offset, length, position) {
+        if (typeof this.resource === "number") {
+            const written = this.io.syncFs.writeSync(this.resource, buffer, offset, length, position);
+            if (written === 0)
+                throw new Error("Copy fallback write made no progress");
+            return written;
+        }
+        return this.resource.write(buffer, offset, length, position);
+    }
+    *truncate(length) {
+        if (typeof this.resource === "number")
+            this.io.syncFs.ftruncateSync(this.resource, length);
+        else
+            yield* wait(this.resource.truncate(length));
+    }
+}

package/node_modules/@openclaw/fs-safe/dist/config.d.ts

@@ -1,2 +1,2 @@
-export { configureFsSafePython, configureFsSafeNative, getFsSafeNativeConfig, type FsSafePythonConfig, type FsSafeNativeConfig, type FsSafeNativeMode, } from "./native-config.js";
+export { configureFsSafeNative, getFsSafeNativeConfig, type FsSafeNativeConfig, type FsSafeNativeMode, } from "./native-config.js";
 export { configureFsSafeLocks, getFsSafeLockConfig, type FsSafeLockConfig, } from "./lock-config.js";

package/node_modules/@openclaw/fs-safe/dist/config.js

@@ -1,2 +1,2 @@
-export { configureFsSafePython, configureFsSafeNative, getFsSafeNativeConfig, } from "./native-config.js";
+export { configureFsSafeNative, getFsSafeNativeConfig, } from "./native-config.js";
 export { configureFsSafeLocks, getFsSafeLockConfig, } from "./lock-config.js";

package/node_modules/@openclaw/fs-safe/dist/copy-file-input.d.ts

@@ -17,5 +17,5 @@ export declare function assertCopySourceCurrent(source: {
     realPath: string;
 }, identity: BigIntStats): Promise<void>;
 export declare function writeCopyFileToFd(fd: number, input: CopyFileInput, maxBytes?: number, assertBeforeMutation?: () => void): Promise<void>;
-export declare function createNativeCopyFile(native: NativeBinding, input: CopyFileInput, parentFd: number, basename: string, maxBytes: number | undefined, sync: boolean): Promise<NativeFileCopyResult | undefined>;
+export declare function createNativeCopyFile(native: NativeBinding, input: CopyFileInput, parentFd: number, basename: string, maxBytes: number | undefined): Promise<NativeFileCopyResult | undefined>;
 export declare function assertNativeCopyCompleted(input: CopyFileInput, copied?: NativeFileCopyResult): void;

package/node_modules/@openclaw/fs-safe/dist/copy-file-input.js

@@ -27,7 +27,7 @@ export async function writeCopyFileToFd(fd, input, maxBytes, assertBeforeMutatio
         maxBytes, sizeHint: input.size, signal: input.signal, assertBeforeMutation,
     });
 }
-export async function createNativeCopyFile(native, input, parentFd, basename, maxBytes, sync) {
+export async function createNativeCopyFile(native, input, parentFd, basename, maxBytes) {
     input.signal?.throwIfAborted();
     if (!native.copyFileExclusive) {
         if (input.clone === "always") {
@@ -39,7 +39,7 @@ export async function createNativeCopyFile(native, input, parentFd, basename, ma
     const nativeSignal = input.signal ? AbortSignal.any([input.signal]) : undefined;
     try {
         // The caller adopts this descriptor before observing a later cancellation.
-        return await native.copyFileExclusive(input.handle.fd, parentFd, basename, input.clone, maxBytes !== undefined && Number.isFinite(maxBytes) ? maxBytes : undefined, nativeSignal, sync);
+        return await native.copyFileExclusive(input.handle.fd, parentFd, basename, input.clone, maxBytes !== undefined && Number.isFinite(maxBytes) ? maxBytes : undefined, nativeSignal);
     }
     catch (error) {
         const code = error?.code;

package/node_modules/@openclaw/fs-safe/dist/copy-tree-portable.js

@@ -3,6 +3,7 @@ import fs from "node:fs";
 import fsp, {} from "node:fs/promises";
 import path from "node:path";
 import { FsSafeError } from "./errors.js";
+import { assertExclusiveCreateLeaf } from "./exclusive-create.js";
 import { assertStagedDirectoryCurrent, exactIdentityMatches, openStagedDirectory, } from "./staged-directory.js";
 function timestampSeconds(nanoseconds) {
     // Dates discard sub-millisecond precision; negative numbers mean "now" in
@@ -49,6 +50,7 @@ export async function copyOwnedTree(source, destination, options) {
             if (!opened.isFile() || !exactIdentityMatches(stat, opened)) {
                 throw new FsSafeError("path-mismatch", "copy source changed while opening");
             }
+            assertExclusiveCreateLeaf(to);
             output = await fsp.open(to, "wx", 0o600);
             if (options.copyFileContents) {
                 // napi-rs owns onabort. Each admitted file gets a separate signal; the