@openclaw/feishu 2026.9.8 → 2026.10.1-beta.1

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

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { assertExclusiveCreateLeaf } from "./exclusive-create.js";
 import fs, {} from "node:fs";
 import fsAsync, {} from "node:fs/promises";
 import path from "node:path";
@@ -47,6 +48,7 @@ function createPrivateWindowsFile(selected, options, mode) {
         }
         assertSynchronousCallbackResult(assertion?.(), "assertBeforeMutation");
         assertStage();
+        assertExclusiveCreateLeaf(stagePath);
         file = ownFileDescriptorSync(fs.openSync(stagePath, fs.constants.O_RDWR | fs.constants.O_CREAT |
             fs.constants.O_EXCL | resolveReadOpenFlags(), 0o600));
         identity = assertCreationFile(file.fd, stagePath);
@@ -105,10 +107,10 @@ function createPrivateWindowsFile(selected, options, mode) {
         throw privateFileSettlementFailure({ primary, cleanup, publication, path: selected.target, stageDirectory });
     }
 }
-function createFileCore(targetPath, options, admission) {
+export function createFileSync(targetPath, options = {}) {
     const permissions = resolveCreationPermissions(options, false);
     const assertion = options.assertBeforeMutation;
-    const selected = prepareCreationPath(targetPath, admission.expectedParentIdentity);
+    const selected = prepareCreationPath(targetPath);
     if (permissions.private && process.platform === "win32") {
         assertPrivateFileCreationAvailable();
         return createPrivateWindowsFile(selected, { ...permissions, assertBeforeMutation: assertion }, permissions.mode);
@@ -116,6 +118,7 @@ function createFileCore(targetPath, options, admission) {
     assertBeforeCreation(selected, permissions, assertion, "file");
     let file;
     try {
+        assertExclusiveCreateLeaf(selected.target);
         file = ownFileDescriptorSync(fs.openSync(selected.target, fs.constants.O_RDWR | fs.constants.O_CREAT |
             fs.constants.O_EXCL | resolveReadOpenFlags(), permissions.mode ?? 0o666));
     }
@@ -142,9 +145,6 @@ function createFileCore(targetPath, options, admission) {
         });
     }
 }
-export function createFileSync(targetPath, options = {}) {
-    return createFileCore(targetPath, options, {});
-}
 /** Internal async writer; Windows preparation uses the nonblocking stage owner. */
 export async function createFileHandle(targetPath, options = {}, admission = {}) {
     const permissions = resolveCreationPermissions(options, false);
@@ -152,6 +152,12 @@ export async function createFileHandle(targetPath, options = {}, admission = {})
     if (process.platform !== "win32" || !permissions.private) {
         const selected = prepareCreationPath(targetPath, admission.expectedParentIdentity);
         assertBeforeCreation(selected, permissions, assertion, "file");
+        try {
+            assertExclusiveCreateLeaf(selected.target);
+        }
+        catch (error) {
+            throw creationCollision(error);
+        }
         const handle = await fsAsync.open(selected.target, fs.constants.O_RDWR | fs.constants.O_CREAT |
             fs.constants.O_EXCL | resolveReadOpenFlags(), permissions.mode ?? 0o666)
             .catch(error => { throw creationCollision(error); });
@@ -316,6 +322,7 @@ async function createPrivateWindowsFileHandle(selected, options) {
         }
         assertSynchronousCallbackResult(assertion?.(), "assertBeforeMutation");
         assertStage();
+        assertExclusiveCreateLeaf(stagePath);
         file = await fsAsync.open(stagePath, fs.constants.O_RDWR | fs.constants.O_CREAT |
             fs.constants.O_EXCL | resolveReadOpenFlags(), 0o600);
         assertStage();

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

@@ -7,6 +7,11 @@ export type AsyncDirectoryGuard<T extends Stats | BigIntStats = Stats> = {
 };
 export type AnyAsyncDirectoryGuard = AsyncDirectoryGuard<Stats | BigIntStats>;
 export type SyncDirectoryGuard = AsyncDirectoryGuard;
+type DirectoryGuardMode = "native" | "normalized";
+type DirectoryGuardOptions = {
+    bigint?: boolean;
+    initial?: BigIntStats;
+};
 export type DirectoryIdentity = Readonly<{
     dev: bigint;
     ino: bigint;
@@ -27,8 +32,13 @@ export declare function createAsyncDirectoryGuard(dir: string, options: {
     bigint: boolean;
 }): Promise<AnyAsyncDirectoryGuard>;
 export declare function createSyncDirectoryGuard(dir: string): SyncDirectoryGuard;
+export declare function captureDirectoryGuard(dir: string, mode: DirectoryGuardMode, options?: {
+    bigint?: false;
+}): SyncDirectoryGuard;
+export declare function captureDirectoryGuard(dir: string, mode: DirectoryGuardMode, options?: DirectoryGuardOptions): AnyAsyncDirectoryGuard;
 export declare function assertAsyncDirectoryGuard(guard: AnyAsyncDirectoryGuard): Promise<void>;
 export declare function assertSyncDirectoryGuard(guard: SyncDirectoryGuard | AnyAsyncDirectoryGuard): void;
+export declare function assertDirectoryGuard(guard: AnyAsyncDirectoryGuard, mode: DirectoryGuardMode): void;
 export declare function createNearestExistingDirectoryGuard(rootReal: string, targetPath: string): Promise<AsyncDirectoryGuard>;
 export declare function createNearestExistingDirectoryGuard(rootReal: string, targetPath: string, options: {
     bigint: true;
@@ -52,3 +62,4 @@ export declare function extendDirectoryObservationGuard(observation: StatObserva
 export declare function inspectDirectoryObservationSync(dir: string, expected?: ExactStatIdentity): StatObservationReceipt;
 export declare function assertDirectoryObservationSync(dir: string, expected: ExactStatIdentity): Stats | BigIntStats;
 export declare function assertDirectoryObservationGuardSync(guard: DirectoryObservationGuard): void;
+export {};

package/node_modules/@openclaw/fs-safe/dist/directory-guard.js

@@ -35,7 +35,7 @@ export async function createAsyncDirectoryGuard(dir, options) {
 export function createSyncDirectoryGuard(dir) {
     return captureDirectoryGuard(dir, "normalized");
 }
-function captureDirectoryGuard(dir, mode, options) {
+export function captureDirectoryGuard(dir, mode, options) {
     const operationPath = directoryOperationPath(dir);
     const stat = options?.bigint
         ? inspectDirectoryIdentityAtPathSync(operationPath, undefined, options.initial)
@@ -53,7 +53,7 @@ export async function assertAsyncDirectoryGuard(guard) {
 export function assertSyncDirectoryGuard(guard) {
     assertDirectoryGuard(guard, "normalized");
 }
-function assertDirectoryGuard(guard, mode) {
+export function assertDirectoryGuard(guard, mode) {
     const dir = guard.dir;
     const operationPath = directoryOperationPath(dir);
     const expectedRealPath = guard.realPath;
@@ -82,16 +82,13 @@ function assertDirectoryGuard(guard, mode) {
     }
 }
 export async function createNearestExistingDirectoryGuard(rootReal, targetPath, options = { bigint: false }) {
-    return nearestExistingDirectoryGuard(rootReal, targetPath, "native", options);
-}
-function nearestExistingDirectoryGuard(rootReal, targetPath, mode, options) {
     assertNoWindowsPathAlias(rootReal, "filesystem");
     assertNoWindowsPathAlias(targetPath, "filesystem");
     let current = resolvePathPreservingWindowsRoot(targetPath);
     const root = resolvePathPreservingWindowsRoot(rootReal);
     while (current !== root) {
         try {
-            return captureDirectoryGuard(current, mode, options);
+            return captureDirectoryGuard(current, "native", options);
         }
         catch (error) {
             if (!isNotFoundPathError(error)) {
@@ -100,7 +97,7 @@ function nearestExistingDirectoryGuard(rootReal, targetPath, mode, options) {
             current = path.dirname(current);
         }
     }
-    return captureDirectoryGuard(root, mode, options);
+    return captureDirectoryGuard(root, "native", options);
 }
 // Recovery receipts must retain every identity bit, including on Windows.
 export async function inspectDirectoryIdentity(dir, expected) {

package/node_modules/@openclaw/fs-safe/dist/entry-publication-types.d.ts

@@ -0,0 +1,55 @@
+/** Exact caller observation. Unknown or rounded identities are not admitted. */
+export type PublicationIdentity = Readonly<{
+    dev: bigint;
+    ino: bigint;
+}>;
+export type PublicationParent = Readonly<{
+    path: string;
+    identity: PublicationIdentity;
+}>;
+export type RetainEntryForPublicationOptions = Readonly<{
+    source: Readonly<{
+        parent: PublicationParent;
+        basename: string;
+        /** Windows symlink includes file/directory symbolic links and junctions; targets stay opaque. */
+        expected: PublicationIdentity & Readonly<{
+            kind: "directory" | "file" | "symlink";
+        }>;
+    }>;
+    destination: Readonly<{
+        parent: PublicationParent;
+        basename: string;
+    }>;
+    /** Must synchronously throw on loss of caller authority. Does not provide isolation. */
+    assertBeforeMutation: () => void;
+}>;
+export type EntryPublicationReceipt = Readonly<{
+    source: RetainEntryForPublicationOptions["source"];
+    destination: RetainEntryForPublicationOptions["destination"];
+    capability: Readonly<{
+        destinationAbsence: "atomic";
+        sourceIdentity: "observed-under-caller-exclusive-namespace";
+        parentBinding: "retained-object";
+        sourceFilesystem: string;
+        destinationFilesystem: string;
+    }>;
+}>;
+export type EntryPublicationIssue = Readonly<{
+    phase: "admission" | "authority" | "precheck" | "native" | "postcheck" | "close";
+    cause: unknown;
+}>;
+/** In-memory syscall disposition, NOT a crash-durable transaction journal. */
+export type EntryPublicationResult = Readonly<{
+    transition: "committed" | "not-published" | "indeterminate";
+    verification: "not-performed" | "verified" | "failed";
+    resources: "closed" | "close-failed";
+    /** First issue is primary; subsequent close failures never replace it. */
+    issues: readonly EntryPublicationIssue[];
+}>;
+export interface RetainedEntryPublication extends Disposable {
+    readonly receipt: EntryPublicationReceipt;
+    /** One-shot, synchronous; returns operation AND close failures without discarding transition. */
+    publish(): EntryPublicationResult;
+    /** Close only. Never reverses, unlinks, or cleans either name; idempotent. */
+    dispose(): EntryPublicationResult;
+}

package/node_modules/@openclaw/fs-safe/dist/entry-publication-types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,8 @@
+import type { RetainedEntryPublication, RetainEntryForPublicationOptions } from "./entry-publication-types.js";
+/**
+ * Retain an existing directory, single-link regular file or symlink for ONE-WAY export.
+ * Requires caller-exclusive source namespace and stable admitted topology.
+ * Native destination absence is atomic; POSIX source identity is NOT CAS.
+ * All operation results settle descriptors, never delete or reverse names.
+ */
+export declare function retainEntryForPublication(options: RetainEntryForPublicationOptions): RetainedEntryPublication;

package/node_modules/@openclaw/fs-safe/dist/entry-publication.js

@@ -0,0 +1,262 @@
+import fs, {} from "node:fs";
+import path from "node:path";
+import { assertDirectoryIdentitySync } from "./directory-guard.js";
+import { FsSafeError } from "./errors.js";
+import { assertSynchronousCallbackResult } from "./mutation-authority.js";
+import { captureNativeFdClose } from "./native-binding.js";
+import { requireNativeBinding } from "./native.js";
+import { realpathSync } from "./realpath.js";
+import { describeStagedDirectory, assertStagedDirectoryCurrent } from "./staged-directory.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
+function basename(name) {
+    if (typeof name !== "string" || !name || name === "." || name === ".." ||
+        /[/\\:\u0000-\u001f\u007f-\u009f\u2028\u2029]/u.test(name)) {
+        throw new FsSafeError("invalid-path", "publication requires a direct-child basename");
+    }
+    return name;
+}
+function identity(value) {
+    const { dev, ino } = value;
+    if (typeof dev !== "bigint" || typeof ino !== "bigint" || dev < 0n || ino <= 0n ||
+        dev > 0xffffffffffffffffn || ino > 0xffffffffffffffffn) {
+        throw new FsSafeError("path-mismatch", "publication requires an exact known identity");
+    }
+    return Object.freeze({ dev, ino });
+}
+function parent(value) {
+    const pathname = value.path;
+    const expected = identity(value.identity);
+    if (typeof pathname !== "string" || !path.isAbsolute(pathname) || path.resolve(pathname) !== pathname ||
+        realpathSync.native(pathname) !== pathname) {
+        throw new FsSafeError("path-alias", "publication parent must use its canonical physical spelling");
+    }
+    assertDirectoryIdentitySync(pathname, { ...expected, realPath: pathname });
+    return Object.freeze({ path: pathname, identity: expected });
+}
+function retainParent(expected, closes) {
+    const fd = fs.openSync(expected.path, fs.constants.O_RDONLY | fs.constants.O_DIRECTORY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+    // Register immediately: outer admission owns *all* close outcomes, including
+    // failures in the shared guard. A hidden admission close cannot report closed.
+    closes.push(() => fs.closeSync(fd));
+    const receipt = describeStagedDirectory(fd, expected.path);
+    inspectFileIdentitySync(() => fs.fstatSync(fd, { bigint: true }), expected.identity);
+    return { fd, receipt };
+}
+function assertKind(stat, kind) {
+    if (kind === "file" ? !stat.isFile() : kind === "symlink" ? !stat.isSymbolicLink() : !stat.isDirectory()) {
+        throw new FsSafeError("not-file", "publication source must be the expected file, directory or symlink");
+    }
+    if (kind !== "directory" && stat.nlink !== 1n) {
+        throw new FsSafeError("hardlink", "publication does not admit hardlinked files or symlinks");
+    }
+}
+function inspectEntry(name, expected) {
+    const stat = inspectFileIdentitySync(() => fs.lstatSync(name, { bigint: true }), expected);
+    assertKind(stat, expected.kind);
+    // A symlink target is opaque: it may be dangling, relative or inaccessible.
+    // Check the directory entry spelling without resolving or opening the target.
+    const canonical = expected.kind === "symlink"
+        ? fs.readdirSync(path.dirname(name)).includes(path.basename(name))
+        : realpathSync.native(name) === name;
+    if (!canonical) {
+        throw new FsSafeError("path-alias", "publication source must use its canonical physical spelling");
+    }
+}
+function settle(closes, issues) {
+    let resources = "closed";
+    // Consume ownership before each close; a failed close must never be retried.
+    for (const close of closes.splice(0).reverse()) {
+        try {
+            for (const cause of close() ?? []) {
+                resources = "close-failed";
+                issues.push(Object.freeze({ phase: "close", cause }));
+            }
+        }
+        catch (cause) {
+            resources = "close-failed";
+            issues.push(Object.freeze({ phase: "close", cause }));
+        }
+    }
+    return resources;
+}
+class Publication {
+    #result;
+    #busy = false;
+    #receipt;
+    #backend;
+    #closes;
+    #assertion;
+    constructor(receipt, backend, closes, assertion) {
+        this.#receipt = receipt;
+        this.#backend = backend;
+        this.#closes = closes;
+        this.#assertion = assertion;
+    }
+    get receipt() { return this.#receipt; }
+    #idle() {
+        if (this.#busy)
+            throw new FsSafeError("helper-failed", "reentrant entry publication");
+    }
+    publish() {
+        this.#idle();
+        if (this.#result)
+            return this.#result;
+        this.#busy = true;
+        let transition = "not-published";
+        let verification = "not-performed";
+        let phase = "authority";
+        const issues = [];
+        try {
+            assertSynchronousCallbackResult(this.#assertion(), "assertBeforeMutation");
+            phase = "precheck";
+            this.#backend.current(false);
+            phase = "native";
+            // Any thrown/lost/malformed native reply is unknown, even if a later path
+            // observation happens to resemble success or failure.
+            transition = "indeterminate";
+            const native = this.#backend.publish();
+            if (native?.outcome !== "committed" && native?.outcome !== "not-published" && native?.outcome !== "indeterminate") {
+                throw new FsSafeError("helper-failed", "native publication returned an unknown outcome");
+            }
+            transition = native.outcome; // Capture BEFORE diagnostics, observations or close.
+            if (native.errorCode || transition !== "committed") {
+                throw Object.assign(new Error(native.errorMessage ?? "entry publication did not commit"), { code: native.errorCode ?? "helper-failed" });
+            }
+            phase = "postcheck";
+            verification = "failed";
+            this.#backend.current(true);
+            verification = "verified";
+        }
+        catch (cause) {
+            issues.push(Object.freeze({ phase, cause }));
+        }
+        const resources = settle(this.#closes, issues);
+        this.#result = Object.freeze({ transition, verification, resources, issues: Object.freeze(issues) });
+        this.#busy = false;
+        return this.#result;
+    }
+    dispose() {
+        this.#idle();
+        if (this.#result)
+            return this.#result;
+        this.#busy = true;
+        const issues = [];
+        const resources = settle(this.#closes, issues);
+        this.#result = Object.freeze({ transition: "not-published", verification: "not-performed",
+            resources, issues: Object.freeze(issues) });
+        this.#busy = false;
+        return this.#result;
+    }
+    [Symbol.dispose]() {
+        const result = this.dispose();
+        if (result.resources === "close-failed") {
+            throw new FsSafeError("helper-failed", "entry publication descriptor close failed", {
+                cause: result.issues[0]?.cause, details: { result },
+            });
+        }
+    }
+}
+function publicationReceipt(source, destination, sourceFilesystem, destinationFilesystem) {
+    return Object.freeze({ source, destination, capability: Object.freeze({ destinationAbsence: "atomic",
+            sourceIdentity: "observed-under-caller-exclusive-namespace", parentBinding: "retained-object", sourceFilesystem, destinationFilesystem }) });
+}
+/**
+ * Retain an existing directory, single-link regular file or symlink for ONE-WAY export.
+ * Requires caller-exclusive source namespace and stable admitted topology.
+ * Native destination absence is atomic; POSIX source identity is NOT CAS.
+ * All operation results settle descriptors, never delete or reverse names.
+ */
+export function retainEntryForPublication(options) {
+    const closes = [];
+    try {
+        if (process.platform !== "darwin" && process.platform !== "linux" && process.platform !== "win32") {
+            throw new FsSafeError("unsupported-platform", "entry publication requires macOS, Linux or Windows");
+        }
+        const native = requireNativeBinding();
+        const assertion = options.assertBeforeMutation;
+        if (typeof assertion !== "function")
+            throw new FsSafeError("invalid-path", "synchronous publication authority is required");
+        const kind = options.source.expected.kind;
+        if (kind !== "directory" && kind !== "file" && kind !== "symlink")
+            throw new FsSafeError("not-file", "unsupported publication entry kind");
+        const source = Object.freeze({ parent: parent(options.source.parent), basename: basename(options.source.basename),
+            expected: Object.freeze({ ...identity(options.source.expected), kind }) });
+        const destination = Object.freeze({ parent: parent(options.destination.parent), basename: basename(options.destination.basename) });
+        const sourcePath = path.join(source.parent.path, source.basename);
+        const targetPath = path.join(destination.parent.path, destination.basename);
+        if (targetPath === sourcePath || (kind === "directory" && targetPath.startsWith(`${sourcePath}${path.sep}`))) {
+            throw new FsSafeError("invalid-path", "publication source and destination overlap");
+        }
+        if (process.platform === "win32") {
+            if (typeof native.retainWindowsEntryPublication !== "function") {
+                throw new FsSafeError("helper-unavailable", "native Windows entry retention is unavailable");
+            }
+            inspectEntry(sourcePath, source.expected);
+            let owner;
+            // A lost admission reply cannot prove resource settlement. The native GC
+            // backstop closes only; an explicit unknown close must remain visible.
+            closes.push(() => {
+                if (!owner)
+                    throw new FsSafeError("helper-failed", "native retention reply lost; closure unknown");
+                return owner.close().map(error => Object.assign(new Error(error.message), { code: error.code }));
+            });
+            owner = native.retainWindowsEntryPublication(source.parent.path, source.basename, source.parent.identity.dev, source.parent.identity.ino, destination.parent.path, destination.basename, destination.parent.identity.dev, destination.parent.identity.ino, source.expected.dev, source.expected.ino, kind);
+            const admitted = owner.admission;
+            if (admitted.outcome !== "retained" || admitted.errorCode) {
+                throw Object.assign(new Error(admitted.errorMessage ?? "native Windows publication admission failed"), { code: admitted.errorCode ?? "helper-failed" });
+            }
+            const retained = owner;
+            const receipt = publicationReceipt(source, destination, "ntfs", "ntfs");
+            return new Publication(receipt, { current: published => retained.current(published), publish: () => retained.publish() }, closes, assertion);
+        }
+        if (typeof native.entryPublicationFilesystem !== "function" ||
+            typeof native.publishRetainedEntryNoReplace !== "function" || typeof native.openBeneath !== "function") {
+            throw new FsSafeError("helper-unavailable", "native entry publication is unavailable");
+        }
+        const binding = native;
+        const closeSource = captureNativeFdClose(binding);
+        if (kind === "symlink" && typeof binding.openStagedSymlink !== "function") {
+            throw new FsSafeError("helper-unavailable", "native symlink retention is unavailable");
+        }
+        const sourceParent = retainParent(source.parent, closes);
+        const destinationParent = retainParent(destination.parent, closes);
+        const sourceFilesystem = binding.entryPublicationFilesystem(sourceParent.fd);
+        const destinationFilesystem = binding.entryPublicationFilesystem(destinationParent.fd);
+        if (source.expected.dev !== source.parent.identity.dev || source.expected.dev !== destination.parent.identity.dev) {
+            throw Object.assign(new Error("entry publication cannot cross devices"), { code: "EXDEV" });
+        }
+        inspectEntry(sourcePath, source.expected);
+        const sourceFd = kind === "symlink"
+            ? binding.openStagedSymlink(sourceParent.fd, source.basename)
+            : binding.openBeneath(sourceParent.fd, source.basename, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK |
+                (kind === "directory" ? fs.constants.O_DIRECTORY : 0))?.fd;
+        if (!Number.isInteger(sourceFd) || sourceFd < 0) {
+            throw new FsSafeError("helper-unavailable", "publication source descriptor is unavailable");
+        }
+        closes.push(() => closeSource(sourceFd));
+        assertKind(inspectFileIdentitySync(() => fs.fstatSync(sourceFd, { bigint: true }), source.expected), kind);
+        inspectEntry(sourcePath, source.expected);
+        assertStagedDirectoryCurrent(sourceParent.receipt);
+        assertStagedDirectoryCurrent(destinationParent.receipt);
+        const receipt = publicationReceipt(source, destination, sourceFilesystem, destinationFilesystem);
+        return new Publication(receipt, {
+            current(published) {
+                assertStagedDirectoryCurrent(sourceParent.receipt);
+                assertStagedDirectoryCurrent(destinationParent.receipt);
+                assertKind(inspectFileIdentitySync(() => fs.fstatSync(sourceFd, { bigint: true }), source.expected), kind);
+                const location = published ? destination : source;
+                inspectEntry(path.join(location.parent.path, location.basename), source.expected);
+            },
+            publish: () => binding.publishRetainedEntryNoReplace(sourceParent.fd, source.basename, sourceFd, destinationParent.fd, destination.basename),
+        }, closes, assertion);
+    }
+    catch (cause) {
+        const issues = [Object.freeze({ phase: "admission", cause })];
+        const resources = settle(closes, issues);
+        const result = Object.freeze({ transition: "not-published", verification: "not-performed",
+            resources, issues: Object.freeze(issues) });
+        throw new FsSafeError(cause instanceof FsSafeError ? cause.code : "helper-failed", "entry publication admission failed", {
+            cause, details: { result },
+        });
+    }
+}

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

@@ -0,0 +1,3 @@
+import fs from "node:fs";
+export declare function assertExclusiveCreateStat(pathname: string, stat: Pick<fs.Stats, "isSymbolicLink">): void;
+export declare function assertExclusiveCreateLeaf(pathname: string): void;

package/node_modules/@openclaw/fs-safe/dist/exclusive-create.js

@@ -0,0 +1,22 @@
+import fs from "node:fs";
+import { hasNodeErrorCode } from "./path.js";
+export function assertExclusiveCreateStat(pathname, stat) {
+    if (stat.isSymbolicLink()) {
+        throw Object.assign(new Error("exclusive creation target already exists"), {
+            code: "EEXIST", syscall: "open", path: pathname,
+        });
+    }
+}
+// Windows O_EXCL can create a dangling file symlink's referent. Keep the
+// exclusive-open collision contract; this preflight cannot prevent a later swap.
+export function assertExclusiveCreateLeaf(pathname) {
+    if (process.platform !== "win32")
+        return;
+    try {
+        assertExclusiveCreateStat(pathname, fs.lstatSync(pathname));
+    }
+    catch (error) {
+        if (!hasNodeErrorCode(error, "ENOENT"))
+            throw error;
+    }
+}

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

@@ -1,14 +1,9 @@
 import { type BigIntStats } from "node:fs";
-import fs, { type FileHandle } from "node:fs/promises";
+import { type FileHandle } from "node:fs/promises";
 import { type AnyAsyncDirectoryGuard } from "./directory-guard.js";
 export declare function readErrorCode(error: unknown): unknown;
 export declare function hasErrorCode(error: unknown, expected: string): boolean;
 type OwnedPathCleanupStatus = "removed" | "name-absent" | "preserved";
-export declare function removeOwnedPath(params: {
-    fsModule: Pick<typeof fs, "lstat" | "unlink">;
-    pathname: string;
-    identity?: BigIntStats;
-}): Promise<OwnedPathCleanupStatus>;
 export declare function cleanupPinnedFilePath(params: {
     pathname: string;
     handle: Pick<FileHandle, "fd">;

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

@@ -17,20 +17,18 @@ export function readErrorCode(error) {
 export function hasErrorCode(error, expected) {
     return readErrorCode(error) === expected;
 }
-export async function removeOwnedPath(params) {
+async function removeOwnedPath(params) {
     if (!params.identity)
         return "preserved";
     try {
-        const current = params.fsModule === fs
-            ? syncFs.lstatSync(params.pathname, { bigint: true })
-            : await params.fsModule.lstat(params.pathname, { bigint: true });
+        const current = syncFs.lstatSync(params.pathname, { bigint: true });
         if (current.isSymbolicLink() ||
             !current.isFile() ||
             current.nlink !== 1n ||
             !sameFileIdentityForCleanup(current, params.identity)) {
             return "preserved";
         }
-        await params.fsModule.unlink(params.pathname);
+        await fs.unlink(params.pathname);
         return "removed";
     }
     catch (error) {
@@ -68,7 +66,6 @@ export async function cleanupPinnedFilePath(params) {
     }
     try {
         return await removeOwnedPath({
-            fsModule: fs,
             pathname: params.pathname,
             identity: params.identity,
         });

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

@@ -34,12 +34,9 @@ export function sameFileIdentityForCleanup(left, right, platform = process.platf
     if (platform !== "win32") {
         return sameCleanupStatValue(left.dev, right.dev) && sameCleanupStatValue(left.ino, right.ino);
     }
-    // A zero Windows device or inode is unknown, not proof that a pathname still
-    // names the object we created. Cleanup must fail closed rather than delete a
-    // replacement that happens to share the known half of the identity.
-    // Capture each potentially adapter-backed observation once. This strengthens
-    // the fence against changing accessors; exact legacy getter traces are not a
-    // compatibility contract.
+    // Unknown Windows identity components cannot authorize cleanup: a replacement
+    // could share the known component. Snapshot adapter-backed fields once so
+    // changing accessors cannot alter the check.
     const leftDev = left.dev;
     if (isZero(leftDev))
         return false;

package/node_modules/@openclaw/fs-safe/dist/file-lock-sync-root-io.js

@@ -4,6 +4,7 @@ import { readFileDescriptorBoundedSync } from "./bounded-read.js";
 import { inspectDirectoryIdentitySync } from "./directory-guard.js";
 import { FsSafeError } from "./errors.js";
 import { isNotFoundPathError } from "./path.js";
+import { sameAbsolutePath } from "./path-segment-route.js";
 import { assertRootIdentityCurrentSync } from "./root-context.js";
 import { hardlinkedPathNotAllowedError } from "./root-errors.js";
 import { resolveReadOpenFlags } from "./read-open-flags.js";
@@ -14,12 +15,11 @@ import { createSuppressedError } from "./suppressed-error.js";
 import { assertFileLockSyncRootResolvedPathCurrent, } from "./file-lock-sync-root.js";
 import { assertNoWindowsPathAlias, pathForWindowsFilesystem } from "./windows-path-alias.js";
 const MAX_SIDECAR_LOCK_PAYLOAD_BYTES = 1024 * 1024;
-const samePath = (left, right) => path.relative(path.resolve(left), path.resolve(right)) === "";
 export function observeDirectory(pathname, initial) {
     const stat = inspectDirectoryIdentitySync(pathname, undefined, initial);
     const realPath = realpathSync.native(pathForWindowsFilesystem(pathname));
     assertNoWindowsPathAlias(realPath, "filesystem", "sidecar lock parent uses a Windows filesystem namespace alias");
-    if (!samePath(realPath, pathname)) {
+    if (!sameAbsolutePath(realPath, pathname)) {
         throw new FsSafeError("path-mismatch", "sidecar lock parent changed during operation");
     }
     return Object.freeze({

package/node_modules/@openclaw/fs-safe/dist/file-lock-sync-root-mutation.js

@@ -1,4 +1,5 @@
 import fs, {} from "node:fs";
+import { assertExclusiveCreateLeaf } from "./exclusive-create.js";
 import path from "node:path";
 import { inspectDirectoryIdentitySync } from "./directory-guard.js";
 import { FsSafeError } from "./errors.js";
@@ -89,6 +90,14 @@ export function createFileLockSyncRootFile(pathAuthority, options) {
     let receipt;
     try {
         options.assertBeforeOpen();
+        try {
+            assertExclusiveCreateLeaf(pathForWindowsFilesystem(pathAuthority.path));
+        }
+        catch (error) {
+            if (error.code === "EEXIST")
+                options.onOpenFailure(error);
+            throw error;
+        }
         try {
             fd = fs.openSync(pathForWindowsFilesystem(pathAuthority.path), fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | noFollow, 0o600);
         }

package/node_modules/@openclaw/fs-safe/dist/file-lock-sync-root.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { assertMutationNotDenied } from "./deny-mutations.js";
 import { FsSafeError } from "./errors.js";
 import { assertNoNulPathInput, isNotFoundPathError } from "./path.js";
+import { sameAbsolutePath } from "./path-segment-route.js";
 import { resolveRootPathSync } from "./root-path.js";
 import { isRootPathEscapeError } from "./root-path-errors.js";
 import { admitPathInsideRoot } from "./root-boundary.js";
@@ -91,9 +92,6 @@ export function invokeFileLockSyncRootMutationAuthority(authority) {
     assertSynchronousCallbackResult(assertion(), "assertBeforeMutation");
     return true;
 }
-function samePath(left, right) {
-    return path.relative(path.resolve(left), path.resolve(right)) === "";
-}
 function absoluteRootPath(authority, relativePath) {
     const segments = relativePath.split(path.posix.sep);
     const absolute = path.join(authority.context.rootReal, ...segments);
@@ -129,7 +127,7 @@ function resolveAdmittedPath(authority, absolutePath, policy, rootPath) {
         candidatePath: resolved.canonicalPath,
         rootIdentity: context.rootIdentity,
     });
-    if (!admitted || admitted.relativePath === "" || samePath(admitted.path, context.rootReal)) {
+    if (!admitted || admitted.relativePath === "" || sameAbsolutePath(admitted.path, context.rootReal)) {
         throw outsideWorkspaceError();
     }
     return {
@@ -143,7 +141,7 @@ function resolveBothPolicies(authority, absolutePath, rootPath) {
     const readable = policiesMatch
         ? mutation
         : resolveAdmittedPath(authority, absolutePath, readPolicy, rootPath);
-    if (!samePath(mutation.path, readable.path)) {
+    if (!sameAbsolutePath(mutation.path, readable.path)) {
         throw new FsSafeError("path-mismatch", "sidecar read and mutation paths resolve differently");
     }
     assertFileLockSyncRootMutationAllowed(mutation.path, authority.denyMutations);
@@ -190,7 +188,7 @@ export function admitFileLockSyncRootPath(authority, requestedPath) {
 }
 export function assertFileLockSyncRootResolvedPathCurrent(pathAuthority) {
     const resolved = resolveBothPolicies(pathAuthority.authority, absoluteRootPath(pathAuthority.authority, pathAuthority.relativePath), pathAuthority.authority.context.rootReal);
-    if (!samePath(resolved.path, pathAuthority.path)) {
+    if (!sameAbsolutePath(resolved.path, pathAuthority.path)) {
         throw new FsSafeError("path-mismatch", "sidecar lock path changed during operation");
     }
 }