@openclaw/signal 2026.9.6 → 2026.9.8

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

@@ -270,13 +270,15 @@ export const GUEST_FILESYSTEM_PYTHON = [
     "def copy_entry(src_parent_fd, src_basename, dst_parent_fd, dst_basename):",
     "    src_stat = os.lstat(src_basename, dir_fd=src_parent_fd)",
     "    if stat.S_ISDIR(src_stat.st_mode) and not stat.S_ISLNK(src_stat.st_mode):",
-    "        os.mkdir(dst_basename, stat.S_IMODE(src_stat.st_mode) or 0o755, dir_fd=dst_parent_fd)",
     "        copied_children = []",
     "        src_dir_fd = None",
     "        dst_dir_fd = None",
+    "        destination_created = False",
     "        try:",
     "            src_dir_fd = open_dir(src_basename, dir_fd=src_parent_fd)",
     "            src_stat = os.fstat(src_dir_fd)",
+    "            os.mkdir(dst_basename, stat.S_IMODE(src_stat.st_mode), dir_fd=dst_parent_fd)",
+    "            destination_created = True",
     "            dst_dir_fd = open_dir(dst_basename, dir_fd=dst_parent_fd)",
     "            for child in os.listdir(src_dir_fd):",
     "                copied_children.append((child, copy_entry(src_dir_fd, child, dst_dir_fd, child)))",
@@ -284,10 +286,11 @@ export const GUEST_FILESYSTEM_PYTHON = [
     "            if dst_dir_fd is not None:",
     "                os.close(dst_dir_fd)",
     "                dst_dir_fd = None",
-    "            try:",
-    "                remove_tree(dst_parent_fd, dst_basename)",
-    "            except FileNotFoundError:",
-    "                pass",
+    "            if destination_created:",
+    "                try:",
+    "                    remove_tree(dst_parent_fd, dst_basename)",
+    "                except FileNotFoundError:",
+    "                    pass",
     "            raise",
     "        finally:",
     "            if src_dir_fd is not None:",
@@ -328,30 +331,36 @@ export const GUEST_FILESYSTEM_PYTHON = [
     "            raise",
     "    src_stat = os.lstat(src_basename, dir_fd=src_parent_fd)",
     "    if stat.S_ISDIR(src_stat.st_mode) and not stat.S_ISLNK(src_stat.st_mode):",
-    "        temp_dir_name = create_temp_dir(dst_parent_fd, stat.S_IMODE(src_stat.st_mode) or 0o755)",
+    "        temp_dir_name = None",
     "        copied_children = []",
     "        temp_dir_fd = None",
     "        src_dir_fd = None",
     "        try:",
-    "            temp_dir_fd = open_dir(temp_dir_name, dir_fd=dst_parent_fd)",
     "            src_dir_fd = open_dir(src_basename, dir_fd=src_parent_fd)",
     "            src_stat = os.fstat(src_dir_fd)",
+    "            source_mode = stat.S_IMODE(src_stat.st_mode)",
+    "            temp_dir_name = create_temp_dir(dst_parent_fd, source_mode or 0o700)",
+    "            temp_dir_fd = open_dir(temp_dir_name, dir_fd=dst_parent_fd)",
     "            for child in os.listdir(src_dir_fd):",
     "                copied_children.append((child, copy_entry(src_dir_fd, child, temp_dir_fd, child)))",
     "            os.close(src_dir_fd)",
     "            src_dir_fd = None",
+    "            os.rename(temp_dir_name, dst_basename, src_dir_fd=dst_parent_fd, dst_dir_fd=dst_parent_fd)",
+    "            temp_dir_name = None",
+    "            if source_mode == 0:",
+    "                os.fchmod(temp_dir_fd, 0)",
     "            os.close(temp_dir_fd)",
     "            temp_dir_fd = None",
-    "            os.rename(temp_dir_name, dst_basename, src_dir_fd=dst_parent_fd, dst_dir_fd=dst_parent_fd)",
     "        except Exception:",
     "            if src_dir_fd is not None:",
     "                os.close(src_dir_fd)",
     "            if temp_dir_fd is not None:",
     "                os.close(temp_dir_fd)",
-    "            try:",
-    "                remove_tree(dst_parent_fd, temp_dir_name)",
-    "            except FileNotFoundError:",
-    "                pass",
+    "            if temp_dir_name is not None:",
+    "                try:",
+    "                    remove_tree(dst_parent_fd, temp_dir_name)",
+    "                except FileNotFoundError:",
+    "                    pass",
     "            raise",
     "        remove_copied_entry(src_parent_fd, src_basename, ('dir', entry_identity(src_stat), copied_children))",
     "        os.fsync(dst_parent_fd)",

package/node_modules/@openclaw/fs-safe/dist/json-document-store.d.ts

@@ -1,13 +1,8 @@
-import type { FileLockRetryOptions } from "./file-lock.js";
+import { type FsSafeLockConfig } from "./lock-config.js";
 import type { Root } from "./root.js";
-import type { SidecarLockStaleRecovery } from "./sidecar-lock.js";
-export type JsonStoreLockOptions = {
-    staleMs?: number;
-    timeoutMs?: number;
-    retry?: FileLockRetryOptions;
-    staleRecovery?: SidecarLockStaleRecovery;
-    managerKey?: string;
-};
+export type JsonStoreLockOptions = Partial<FsSafeLockConfig & {
+    managerKey: string;
+}>;
 export type JsonFileStoreOptions = {
     /** Overrides the parent store's durability for every JSON mutation. */
     durable?: boolean;

package/node_modules/@openclaw/fs-safe/dist/json-durable-queue-ownership.d.ts

@@ -4,11 +4,7 @@ export type DurableQueueEntryPathsLike = {
     deliveredPath: string;
     processingPath?: string;
 };
-export type ValidatedDurableQueueEntryPaths = Readonly<{
-    jsonPath: string;
-    deliveredPath: string;
-    processingPath: string;
-}>;
+export type ValidatedDurableQueueEntryPaths = Readonly<Required<DurableQueueEntryPathsLike>>;
 export declare function validateDurableQueueEntryPaths(paths: DurableQueueEntryPathsLike): ValidatedDurableQueueEntryPaths;
 export declare function claimDurableQueueEntry(paths: DurableQueueEntryPathsLike, options?: {
     skipUnowned?: boolean;

package/node_modules/@openclaw/fs-safe/dist/json-durable-queue.d.ts

@@ -1,4 +1,3 @@
-export { DEFAULT_JSON_DURABLE_QUEUE_ENTRY_MAX_BYTES } from "./json-durable-queue-read.js";
 export type JsonDurableQueueEntryPaths = {
     jsonPath: string;
     deliveredPath: string;

package/node_modules/@openclaw/fs-safe/dist/json-durable-queue.js

@@ -8,7 +8,6 @@ import { stringifyJsonDocument } from "./json-stringify.js";
 import { replaceFileAtomicWithDirectorySync } from "./replace-file.js";
 import { assertSafePathSegment } from "./safe-path-segment.js";
 import { admitStandalonePublicationPath, assertNoWindowsPathAlias, hasWindowsPathAlias, } from "./windows-path-alias.js";
-export { DEFAULT_JSON_DURABLE_QUEUE_ENTRY_MAX_BYTES } from "./json-durable-queue-read.js";
 function assertSafeQueueEntryId(id) {
     assertSafePathSegment(id, { label: "queue entry id" });
 }
@@ -146,8 +145,7 @@ export async function loadPendingJsonDurableQueueEntries(options) {
             await unlinkStaleTmpBestEffort(path.join(queueDir, file), now, options.cleanupTmpMaxAgeMs);
         }
     }
-    const ids = [];
-    const seenIds = new Set();
+    const ids = new Set();
     for (const file of files) {
         const suffix = file.endsWith(".processing")
             ? ".processing"
@@ -163,10 +161,7 @@ export async function loadPendingJsonDurableQueueEntries(options) {
         catch {
             continue;
         }
-        if (seenIds.has(id))
-            continue;
-        seenIds.add(id);
-        ids.push(id);
+        ids.add(id);
     }
     const entries = [];
     for (const id of ids) {

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

@@ -8,10 +8,6 @@ const FILE_URL_PREFIX_RE = /^file:\/\//i;
 export function isFileUrl(input) {
     return FILE_URL_PREFIX_RE.test(input);
 }
-function isLocalFileUrlHost(hostname) {
-    const normalized = normalizeLowercaseStringOrEmpty(hostname);
-    return normalized === "" || normalized === "localhost";
-}
 export function hasEncodedFileUrlSeparator(pathname) {
     return ENCODED_FILE_URL_SEPARATOR_RE.test(pathname);
 }
@@ -41,7 +37,8 @@ export function safeFileURLToPath(fileUrl, platform = process.platform) {
     if (parsed.protocol !== "file:") {
         throw new Error(`Invalid file:// URL: ${fileUrl}`);
     }
-    if (!isLocalFileUrlHost(parsed.hostname)) {
+    const normalizedHost = normalizeLowercaseStringOrEmpty(parsed.hostname);
+    if (!(normalizedHost === "" || normalizedHost === "localhost")) {
         throw new Error(`file:// URLs with remote hosts are not allowed: ${fileUrl}`);
     }
     if (hasEncodedFileUrlSeparator(parsed.pathname)) {

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

@@ -1,16 +1,13 @@
 import type { BigIntStats, Stats } from "node:fs";
 import type { FileHandle } from "node:fs/promises";
-import type { HardlinkPolicy } from "./root-options.js";
-import type { SymlinkPolicy } from "./root-symlink-policy.js";
+import type { RootReadOptions } from "./root-options.js";
 type OwnedLocalFile = {
     handle: FileHandle;
     stat: Stats;
     identity: BigIntStats;
     preOpenStat: BigIntStats | undefined;
 };
-export declare function openLocalFileDescriptor(filePath: string, options?: {
-    hardlinks?: HardlinkPolicy;
-    symlinks?: SymlinkPolicy;
+export declare function openLocalFileDescriptor(filePath: string, options?: Pick<RootReadOptions, "hardlinks" | "symlinks"> & {
     readWrite?: true;
 }): Promise<OwnedLocalFile>;
 export {};

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

@@ -1,4 +1,4 @@
-import { type HardlinkPolicy, type ReadResult, type SymlinkPolicy } from "./root.js";
+import { type ReadResult, type RootReadOptions } from "./root.js";
 export type LocalRootsPathResult = {
     path: string;
     root: string;
@@ -15,11 +15,6 @@ export type ResolveLocalPathFromRootsSyncOptions = LocalRootsInputOptions & {
     allowMissing?: boolean;
     requireFile?: boolean;
 };
-export type ReadLocalFileFromRootsOptions = LocalRootsInputOptions & {
-    hardlinks?: HardlinkPolicy;
-    maxBytes?: number;
-    nonBlockingRead?: boolean;
-    symlinks?: SymlinkPolicy;
-};
+export type ReadLocalFileFromRootsOptions = LocalRootsInputOptions & RootReadOptions;
 export declare function resolveLocalPathFromRootsSync(options: ResolveLocalPathFromRootsSyncOptions): LocalRootsPathResult | null;
 export declare function readLocalFileFromRoots(options: ReadLocalFileFromRootsOptions): Promise<LocalRootsReadResult | null>;

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

@@ -135,9 +135,6 @@ async function observeOwnedAliasUnlink(sourcePath, group) {
     group.expected = entryIdentity(observed);
     return "removed";
 }
-function mergeCleanupResults(a, b) {
-    return a === "stale" || b === "stale" ? "stale" : "removed";
-}
 export async function cleanupCopiedEntry(sourcePath, manifest, state, assertBeforeMutation) {
     if (manifest.kind === "directory") {
         let currentStat;
@@ -162,7 +159,10 @@ export async function cleanupCopiedEntry(sourcePath, manifest, state, assertBefo
             inspectSourceDirectory(sourcePath, manifest.directoryIdentity);
         } : undefined;
         for (const child of manifest.children) {
-            result = mergeCleanupResults(result, await cleanupCopiedEntry(path.join(sourcePath, child.name), child.manifest, state, assertBeforeChildMutation));
+            const childResult = await cleanupCopiedEntry(path.join(sourcePath, child.name), child.manifest, state, assertBeforeChildMutation);
+            if (childResult === "stale") {
+                result = "stale";
+            }
         }
         // Child cleanup and the caller's authority check can replace the directory.
         // Keep the final exact observation after both, immediately before removal.

package/node_modules/@openclaw/fs-safe/dist/mutation-authority.js

@@ -1,3 +1,4 @@
+import { types } from "node:util";
 import { FsSafeError } from "./errors.js";
 export class MutationAuthorityError extends FsSafeError {
     rejection;
@@ -14,6 +15,10 @@ export function assertSynchronousCallbackResult(returned, name) {
         void Promise.resolve(returned).catch(() => undefined);
         throw new TypeError(`${name} must be synchronous`);
     }
+    // A generator returns its iterator before running the callback body.
+    if (types.isGeneratorObject(returned)) {
+        throw new TypeError(`${name} must be synchronous`);
+    }
 }
 export function composeMutationAssertions(defaultAssertion, callAssertion) {
     if (!defaultAssertion && !callAssertion)

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

@@ -1,6 +1,15 @@
+import type { RetainedFileResult } from "./retained-file-types.js";
+export interface NativeRetainedFile {
+    readonly admission: RetainedFileResult | {
+        status: "retained";
+        identity: string;
+    };
+    settle(remove: boolean): RetainedFileResult;
+}
 import type { TarMeterLimits } from "./archive-limits.js";
 import type { ArchiveMemberKind } from "./archive-plan.js";
 import type { CopyCloneMode } from "./copy-policy.js";
+import type { WindowsAceFlags } from "./owner-dacl.js";
 export interface NativeFileHash {
     bytes: number;
     digest: string;
@@ -58,16 +67,7 @@ export interface NativeWindowsAccessControlEntry {
     sid: string;
     mask: number;
     aceType: string;
-    flags: {
-        raw: number;
-        objectInherit: boolean;
-        containerInherit: boolean;
-        noPropagateInherit: boolean;
-        inheritOnly: boolean;
-        inherited: boolean;
-        successfulAccess: boolean;
-        failedAccess: boolean;
-    };
+    flags: WindowsAceFlags;
 }
 export interface NativeWindowsSecurityFacts {
     ownerSid: string;
@@ -96,7 +96,38 @@ export interface NativeWindowsDirectoryReceipt {
 export interface NativeDarwinAclFacts {
     state: "absent" | "empty" | "present";
 }
+type NativeTwoPathArgs = [
+    sourceRootFd: number,
+    sourceRelPath: string,
+    targetRootFd: number,
+    targetRelPath: string
+];
 export interface NativeBinding {
+    /** Windows-only, private handle custody; no borrowed/runtime descriptors. */
+    retainWindowsFile?(directory: string, basename: string, parentDev: bigint, parentIno: bigint, dev: bigint, ino: bigint, size: bigint, mtimeNs: bigint, ctimeNs: bigint, sha256: string, maxBytes: number): NativeRetainedFile;
+    watchRegister?(root: string, limit: number, callback: (batch: import("./watch-native.js").NativeWatchWireBatch) => void, persistent: boolean): number;
+    watchConfigure?(id: number, anchors: string[], exclusions: string[]): void;
+    watchAdd?(id: number, directory: {
+        root: string;
+        relative: string;
+        rootDev: bigint;
+        rootIno: bigint;
+        dev: bigint;
+        ino: bigint;
+    }): void;
+    watchTestEvent?(id: number, path: string, flags: number): void;
+    watchUnregister?(id: number): void;
+    watchThreadCount?(): number;
+    watchMemoryStats?(): {
+        registrations: number;
+        pendingSets: number;
+        payloadsLive: number;
+        payloadsCreated: number;
+        payloadsDestroyed: number;
+        threadsafeFunctionsLive: number;
+        threadsafeFunctionsCreated: number;
+        threadsafeFunctionsDestroyed: number;
+    };
     /** Internal: consumes only a descriptor returned by this binding. */
     closeOwnedFd(fd: number): void;
     /** Internal Darwin-only synchronous inspection; the caller retains its fd. */
@@ -125,6 +156,11 @@ export interface NativeBinding {
     readCloneFileMetadata(paths: string[]): Promise<(Buffer | null)[]>;
     probeTreeClone(parentFd: number): "apfs" | "btrfs" | "refs" | "xfs" | "zfs" | null;
     cloneTree(sourceFd: number | null, parentFd: number, basename: string, concurrency: number, signal?: AbortSignal): Promise<void>;
+    openStagedSymlink?(parentFd: number, basename: string): number;
+    stagedSymlinkTarget?(parentFd: number, basename: string, linkFd: number): string;
+    stagedSymlinkMatches?(parentFd: number, basename: string, linkFd: number): boolean;
+    publishStagedSymlink?(parentFd: number, basename: string, linkFd: number, destination: string): void;
+    removeStagedSymlink?(parentFd: number, basename: string, linkFd: number): "removed" | "name-absent" | "preserved";
     createStagedFile?(parentFd: number, basename: string): number;
     stagedFileMatches?(parentFd: number, basename: string, fileFd: number): boolean;
     removeStagedFile?(parentFd: number, basename: string, fileFd: number): "removed" | "name-absent" | "preserved";
@@ -141,7 +177,7 @@ export interface NativeBinding {
     extractArchiveNative(path: string, kind: string, rootFd: number, plan: NativeArchivePlanEntry[], limits: TarMeterLimits, signal: AbortSignal): Promise<void>;
     fstatIdentity(fd: number): NativeFileIdentity;
     inspectArchiveNative(path: string, kind: string, limits: TarMeterLimits, signal: AbortSignal): Promise<NativeArchiveEntry[]>;
-    linkBeneath(sourceRootFd: number, sourceRelPath: string, targetRootFd: number, targetRelPath: string): void;
+    linkBeneath(...args: NativeTwoPathArgs): void;
     /** Direct-child mkdir; true is receipt provenance only, never cleanup ownership. */
     mkdirChildBeneath?(parentFd: number, basename: string, mode: number): boolean;
     mkdirBeneath(rootFd: number, relPath: string, mode: number): void;
@@ -153,10 +189,11 @@ export interface NativeBinding {
     ownedTreeRemovalAvailable?(parentFd: number): boolean;
     removeOwnedTree?(parentFd: number, basename: string, directoryFd: number): Promise<NativeOwnedTreeRemovalResult>;
     removeOwnedTreeSync?(parentFd: number, basename: string, directoryFd: number): NativeOwnedTreeRemovalResult;
-    renameNoReplace(sourceRootFd: number, sourceRelPath: string, targetRootFd: number, targetRelPath: string): void;
+    renameNoReplace(...args: NativeTwoPathArgs): void;
     /** Identity-fenced retained-directory rename capability. */
-    renameNoReplaceWithIdentity?(sourceRootFd: number, sourceRelPath: string, targetRootFd: number, targetRelPath: string, expectedSourceDev: bigint, expectedSourceIno: bigint): void;
-    renameReplace(sourceRootFd: number, sourceRelPath: string, targetRootFd: number, targetRelPath: string): void;
+    renameNoReplaceWithIdentity?(...args: [...paths: NativeTwoPathArgs, expectedSourceDev: bigint, expectedSourceIno: bigint]): void;
+    renameReplace(...args: NativeTwoPathArgs): void;
     sha256File(fd: number, maxBytes?: number, signal?: AbortSignal): Promise<NativeFileHash>;
 }
 export declare function captureNativeFdClose(binding: NativeBinding): (fd: number) => void;
+export {};

package/node_modules/@openclaw/fs-safe/dist/native-pinned-write.js

@@ -182,8 +182,14 @@ async function capturePolicyAwarePosixParent(binding, params, rootFd, directoryF
             completeParentFd = binding.openBeneath(rootFd, params.relativeParentPath, directoryFlags).fd;
         }
         catch (error) {
-            if (error?.code !== "ENOENT" || !params.mkdir)
-                throw error;
+            if (error?.code !== "ENOENT" || !params.mkdir) {
+                // A mechanism rejection must not hide canonical denial/symlink policy.
+                // This admission only classifies failure; it cannot authorize a retry.
+                await authorizePinnedMutation(params, {
+                    targetPath: initialTarget, mutationPath: initialTarget, phase: "parent",
+                });
+                throw normalizePolicyParentOpenError(error, params);
+            }
         }
         if (completeParentFd !== undefined) {
             const parentFd = completeParentFd;

package/node_modules/@openclaw/fs-safe/dist/native-staged-symlink.d.ts

@@ -0,0 +1,13 @@
+import { type BigIntStats, type Stats } from "node:fs";
+import type { DirectoryReceipt } from "./directory-durability.js";
+import type { StagedSymlink, StagedSymlinkExpected } from "./staged-symlink-types.js";
+/**
+ * Admit an existing staged symlink against caller-captured identity and retain
+ * its no-follow descriptor. Admission never creates, adopts by target, or unlinks.
+ */
+export declare function retainSymlinkInDirectory(options: {
+    directory: string | DirectoryReceipt<Stats | BigIntStats>;
+    basename: string;
+    expected: StagedSymlinkExpected;
+    assertBeforeMutation: () => void;
+}): Promise<StagedSymlink>;