@openclaw/feishu 2026.9.8 → 2026.10.1-beta.2

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

@@ -1,12 +1,4 @@
 let overrideConfig = {};
-let legacyWarningEmitted = false;
-const legacyModeEnvKeys = ["FS_SAFE_PYTHON_MODE", "OPENCLAW_FS_SAFE_PYTHON_MODE"];
-const legacyPathEnvKeys = [
-    "FS_SAFE_PYTHON",
-    "OPENCLAW_FS_SAFE_PYTHON",
-    "OPENCLAW_PINNED_PYTHON",
-    "OPENCLAW_PINNED_WRITE_PYTHON",
-];
 function parseMode(value) {
     if (!value) {
         return undefined;
@@ -26,46 +18,20 @@ function parseMode(value) {
 export function configureFsSafeNative(config) {
     overrideConfig = { ...overrideConfig, ...config };
 }
-function warnLegacyPythonConfiguration(source, mappedMode) {
-    if (legacyWarningEmitted) {
-        return;
-    }
-    legacyWarningEmitted = true;
-    process.emitWarning(`${source} is a deprecated 0.4 compatibility bridge; mapped to native mode ` +
-        `"${mappedMode}". Use configureFsSafeNative({ mode: "${mappedMode}" }) or ` +
-        `FS_SAFE_NATIVE_MODE=${mappedMode}. Python interpreter paths are no longer used.`, { code: "FS_SAFE_PYTHON_DEPRECATED", type: "DeprecationWarning" });
-}
-function readLegacyPythonMode() {
-    const configuredKeys = [...legacyModeEnvKeys, ...legacyPathEnvKeys].filter((key) => process.env[key] !== undefined);
-    if (configuredKeys.length === 0) {
-        return undefined;
-    }
-    const rawMode = legacyModeEnvKeys.map((key) => process.env[key]).find((value) => value !== undefined);
-    const mappedMode = parseMode(rawMode) ?? "auto";
-    warnLegacyPythonConfiguration(`Legacy ${configuredKeys.join(", ")}`, mappedMode);
-    return mappedMode;
-}
-/**
- * @deprecated Compatibility bridge for 0.4 upgrades. Use configureFsSafeNative.
- */
-export function configureFsSafePython(config) {
-    const mappedMode = config.mode ?? "auto";
-    warnLegacyPythonConfiguration("configureFsSafePython()", mappedMode);
-    if (config.mode !== undefined) {
-        configureFsSafeNative({ mode: config.mode });
-    }
-}
 export function getFsSafeNativeConfig() {
-    const legacyMode = readLegacyPythonMode();
     return {
         mode: overrideConfig.mode ??
             parseMode(process.env.FS_SAFE_NATIVE_MODE) ??
             parseMode(process.env.OPENCLAW_FS_SAFE_NATIVE_MODE) ??
-            legacyMode ??
             "auto",
     };
 }
+export function isFsSafeNativeRequired() {
+    return (overrideConfig.mode ??
+        parseMode(process.env.FS_SAFE_NATIVE_MODE) ??
+        parseMode(process.env.OPENCLAW_FS_SAFE_NATIVE_MODE) ??
+        "auto") === "require";
+}
 export function __resetFsSafeNativeConfigForTest() {
     overrideConfig = {};
-    legacyWarningEmitted = false;
 }

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

@@ -5,6 +5,7 @@ import type { NativeBinding } from "./native.js";
 import { describeStagedDirectory } from "./staged-directory.js";
 type RootIdentity = Pick<FileIdentityStat, "dev" | "ino">;
 export type NativeRootAdmission = {
+    directoryFlags?: number;
     exactRoot: boolean;
     reportCloseErrors?: boolean;
     operation: string;
@@ -27,6 +28,7 @@ export declare function openNativeRootAdmission(binding: NativeBinding, params:
     rootIdentity?: RootIdentity;
     operation?: string;
     reportCloseErrors?: boolean;
+    searchOnly?: boolean;
 }): Promise<NativeRootAdmission>;
 export declare function openNativeParentAdmission(binding: NativeBinding, rootAdmission: Omit<NativeRootAdmission, "root"> & {
     root: Pick<FileHandle, "fd">;

package/node_modules/@openclaw/fs-safe/dist/native-parent-admission.js

@@ -2,6 +2,7 @@ import fsSync, {} from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { inspectDirectoryIdentity, inspectDirectoryIdentitySync } from "./directory-guard.js";
+import { nodeDirectorySearchOnlyFlags } from "./directory-mode-node.js";
 import { inspectNativeDirectoryObservation } from "./native-directory-observation.js";
 import { FsSafeError } from "./errors.js";
 import { captureNativeFdClose } from "./native-binding.js";
@@ -24,7 +25,8 @@ function assertParentAdmissionAvailable(binding) {
 }
 export async function openNativeRootAdmission(binding, params) {
     assertParentAdmissionAvailable(binding);
-    const directoryFlags = fsSync.constants.O_RDONLY | (fsSync.constants.O_DIRECTORY ?? 0);
+    const directoryFlags = (params.searchOnly ? nodeDirectorySearchOnlyFlags()?.flags ?? fsSync.constants.O_RDONLY : fsSync.constants.O_RDONLY) |
+        (fsSync.constants.O_DIRECTORY ?? 0);
     assertNoWindowsPathAlias(params.rootPath, "filesystem", "native root uses a Windows filesystem namespace alias");
     const root = await fs.open(pathForWindowsFilesystem(params.rootPath), directoryFlags);
     try {
@@ -50,6 +52,7 @@ export async function openNativeRootAdmission(binding, params) {
             throw new FsSafeError("path-mismatch", `root path changed during ${params.operation ?? "native admission"}`);
         }
         return {
+            directoryFlags,
             exactRoot,
             reportCloseErrors: params.reportCloseErrors,
             operation: params.operation ?? "native admission",
@@ -73,7 +76,7 @@ export async function openNativeRootAdmission(binding, params) {
 export async function openNativeParentAdmission(binding, rootAdmission, relativeParentPath, observation) {
     assertParentAdmissionAvailable(binding);
     const closeFd = captureNativeFdClose(binding);
-    const directoryFlags = fsSync.constants.O_RDONLY | (fsSync.constants.O_DIRECTORY ?? 0);
+    const directoryFlags = rootAdmission.directoryFlags ?? (fsSync.constants.O_RDONLY | (fsSync.constants.O_DIRECTORY ?? 0));
     assertNoWindowsPathAlias(relativeParentPath, "relative", "native parent uses a Windows filesystem namespace alias");
     const opened = binding.openBeneath(rootAdmission.root.fd, relativeParentPath, directoryFlags);
     if (!opened || !Number.isInteger(opened.fd) || opened.fd < 0) {

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

@@ -52,312 +52,13 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 });
 import fsSync, {} from "node:fs";
 import path from "node:path";
-import { inspectDirectoryIdentity } from "./directory-guard.js";
-import { FsSafeError } from "./errors.js";
 import { runPinnedWriteWindows } from "./native-pinned-write-windows.js";
-import { capturePolicyAwareWindowsParent } from "./native-policy-parent-windows.js";
+import { capturePolicyAwareNativeParent } from "./native-policy-parent.js";
 import { openNativeParentAdmission, openNativeRootAdmission } from "./native-parent-admission.js";
 import { assertNativeStaging, writeNativeStage } from "./native-staged-file.js";
 import { captureNativeFdClose } from "./native-binding.js";
-import { NativePolicyDirectoryMismatch } from "./native-policy-directory-observation.js";
-import { assertPolicyStagedDirectoryCurrent, assertStagedDirectoryCurrent, describePolicyStagedDirectory, describeStagedDirectory, refreshPolicyStagedDirectoryObservation, } from "./staged-directory.js";
-import { inspectFileIdentitySync } from "./strict-file-identity.js";
-import { realpathSync } from "./realpath.js";
-import { errorCauseOptions } from "./root-errors.js";
-import { isNotFoundPathError, isSymlinkOpenError } from "./path.js";
-import { checkedMutationDirectory, } from "./pinned-mutation-observation.js";
-import { createPathSegmentRoute, joinPathSegmentRoute } from "./path-segment-route.js";
-function sameAbsolutePath(left, right) {
-    return path.relative(path.resolve(left), path.resolve(right)) === "";
-}
-function assertDirectChildBasename(basename) {
-    if (!basename || basename === "." || basename === ".." || basename.includes("/") ||
-        basename.includes("\0") || (process.platform === "win32" && basename.includes("\\"))) {
-        throw new FsSafeError("invalid-path", "native parent creation requires one direct-child basename");
-    }
-}
-function mkdirPolicyChild(binding, parentFd, basename, mode) {
-    assertDirectChildBasename(basename);
-    const mkdirChild = binding.mkdirChildBeneath;
-    if (typeof mkdirChild === "function") {
-        const created = mkdirChild.call(binding, parentFd, basename, mode);
-        if (typeof created === "boolean")
-            return created;
-    }
-    // Old or malformed optional helpers still execute through the established
-    // recursive primitive, but cannot provide exclusive-creation provenance.
-    binding.mkdirBeneath(parentFd, basename, mode);
-    return false;
-}
-async function authorizePinnedMutation(params, request) {
-    return await params.mutationAdmission?.authorize(Object.freeze(request));
-}
-function normalizePolicyParentOpenError(error, params) {
-    if (!isSymlinkOpenError(error))
-        return error;
-    return params.mutationAdmission?.rejectParentSymlinks
-        ? new FsSafeError("symlink", "symlink path component not allowed", errorCauseOptions(error))
-        : new FsSafeError("path-mismatch", "native write parent changed during policy admission", errorCauseOptions(error));
-}
-async function describePosixParent(parentFd, pathname) {
-    const parentPath = realpathSync.native(pathname);
-    const directory = describeStagedDirectory(parentFd, parentPath);
-    const parentPathStat = await inspectDirectoryIdentity(parentPath, inspectFileIdentitySync(() => fsSync.fstatSync(parentFd, { bigint: true })));
-    return {
-        parentFd,
-        parentPath,
-        directory,
-        parentPathStat,
-        observation: checkedMutationDirectory(parentPath, directory.realPath, parentPathStat),
-    };
-}
-function describePolicyPosixParent(binding, parentFd, pathname) {
-    const policyDirectory = describePolicyStagedDirectory(parentFd, pathname, binding);
-    return {
-        parentFd,
-        parentPath: policyDirectory.directory.realPath,
-        directory: policyDirectory.directory,
-        parentPathStat: policyDirectory.stat,
-        observation: policyDirectory.observation,
-        policyDirectory,
-    };
-}
-function policyParentCaptureDeopt(error) {
-    return error instanceof FsSafeError &&
-        !(error instanceof NativePolicyDirectoryMismatch) &&
-        (error.code === "path-mismatch" || error.code === "not-file");
-}
-function tryDescribePolicyPosixParent(binding, parentFd, pathname) {
-    try {
-        return describePolicyPosixParent(binding, parentFd, pathname);
-    }
-    catch (error) {
-        if (!policyParentCaptureDeopt(error))
-            throw error;
-        return undefined;
-    }
-}
-function assertPosixParentCurrent(parent) {
-    return parent.policyDirectory
-        ? assertPolicyStagedDirectoryCurrent(parent.policyDirectory)
-        : assertStagedDirectoryCurrent(parent.directory);
-}
-async function capturePolicyAwarePosixParent(binding, params, rootFd, directoryFlags) {
-    const env_1 = { stack: [], error: void 0, hasError: false };
-    try {
-        const closeFd = captureNativeFdClose(binding);
-        const observationDisposers = new Map();
-        const disposeObservation = (fd) => {
-            const dispose = observationDisposers.get(fd);
-            observationDisposers.delete(fd);
-            dispose?.();
-        };
-        const observationScope = __addDisposableResource(env_1, {
-            [Symbol.dispose]() { for (const dispose of observationDisposers.values())
-                dispose(); },
-        }, false);
-        const capturePolicyParent = (fd, pathname) => {
-            const captured = tryDescribePolicyPosixParent(binding, fd, pathname);
-            const dispose = captured?.policyDirectory?.disposeObservation;
-            if (dispose)
-                observationDisposers.set(fd, dispose);
-            return captured;
-        };
-        const segments = params.relativeParentPath.split("/").filter(Boolean);
-        const parentSpelling = segments.length
-            ? path.join(params.rootPath, ...segments)
-            : params.rootPath;
-        const segmentRoute = createPathSegmentRoute(segments);
-        const initialTarget = joinPathSegmentRoute(params.rootPath, segmentRoute, 0, params.basename);
-        let retainedTargetPath = params.mutationAdmission?.beginParentWalk?.();
-        if (retainedTargetPath && !sameAbsolutePath(retainedTargetPath, initialTarget)) {
-            retainedTargetPath = undefined;
-        }
-        // Preserve the one-open hot path when the complete parent still exists.
-        // Policy is attached only after the opened descriptor is associated with its
-        // current canonical pathname, so a contained redirect cannot retain the old
-        // preflight authorization.
-        let completeParentFd;
-        try {
-            completeParentFd = binding.openBeneath(rootFd, params.relativeParentPath, directoryFlags).fd;
-        }
-        catch (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;
-            try {
-                let admitted = retainedTargetPath
-                    ? capturePolicyParent(parentFd, parentSpelling)
-                    : undefined;
-                if (!admitted) {
-                    retainedTargetPath = undefined;
-                    admitted = await describePosixParent(parentFd, parentSpelling);
-                }
-                const targetPath = path.join(admitted.parentPath, params.basename);
-                await authorizePinnedMutation(params, {
-                    targetPath,
-                    mutationPath: targetPath,
-                    phase: "parent",
-                });
-                assertPosixParentCurrent(admitted);
-                return admitted;
-            }
-            catch (error) {
-                disposeObservation(parentFd);
-                closeFd(parentFd);
-                throw error;
-            }
-        }
-        // The canonical preflight spelling has no intentional symlinks in its
-        // existing prefix. Walk missing-parent cases one direct child at a time so
-        // every existing/opened object is authorized and every mkdir is authorized
-        // before dispatch. O_NOFOLLOW makes a concurrently introduced link fail
-        // before the next component can be created through it.
-        const secureDirectoryFlags = directoryFlags | (fsSync.constants.O_NOFOLLOW ?? 0);
-        let currentFd = rootFd;
-        let currentOwnedFd;
-        let currentPath = params.rootPath;
-        let current = retainedTargetPath
-            ? capturePolicyParent(rootFd, currentPath)
-            : undefined;
-        if (!current) {
-            retainedTargetPath = undefined;
-            current = await describePosixParent(rootFd, currentPath);
-        }
-        try {
-            await authorizePinnedMutation(params, {
-                targetPath: retainedTargetPath ?? initialTarget,
-                mutationPath: retainedTargetPath ?? initialTarget,
-                phase: "parent",
-            });
-            assertPosixParentCurrent(current);
-            for (let index = 0; index < segments.length; index += 1) {
-                const segment = segments[index];
-                const childPath = path.join(currentPath, segment);
-                let childFd;
-                let createdByMkdir = false;
-                let createReceipt;
-                try {
-                    childFd = binding.openBeneath(currentFd, segment, secureDirectoryFlags).fd;
-                }
-                catch (openError) {
-                    if (!isNotFoundPathError(openError)) {
-                        throw normalizePolicyParentOpenError(openError, params);
-                    }
-                    const targetPath = retainedTargetPath ?? joinPathSegmentRoute(currentPath, segmentRoute, index, params.basename);
-                    const request = Object.freeze({
-                        targetPath,
-                        mutationPath: childPath,
-                        phase: "parent-create",
-                    });
-                    createReceipt = params.mutationAdmission?.tryAuthorizeAtParent?.(request, current.observation);
-                    if (!createReceipt) {
-                        createReceipt = await authorizePinnedMutation(params, request);
-                        assertPosixParentCurrent(current);
-                    }
-                    params.assertBeforeMutation?.();
-                    // Do not carry pathname freshness across the live authority callback.
-                    assertPosixParentCurrent(current);
-                    createdByMkdir = mkdirPolicyChild(binding, currentFd, segment, 0o777);
-                    try {
-                        childFd = binding.openBeneath(currentFd, segment, secureDirectoryFlags).fd;
-                    }
-                    catch (createdOpenError) {
-                        throw normalizePolicyParentOpenError(createdOpenError, params);
-                    }
-                }
-                let child;
-                try {
-                    const acceleratedChild = retainedTargetPath
-                        ? capturePolicyParent(childFd, childPath)
-                        : undefined;
-                    if (acceleratedChild) {
-                        child = acceleratedChild;
-                    }
-                    else {
-                        retainedTargetPath = undefined;
-                        child = await describePosixParent(childFd, childPath);
-                    }
-                    if (!sameAbsolutePath(child.parentPath, childPath))
-                        retainedTargetPath = undefined;
-                    let childAuthorization;
-                    if (createdByMkdir && createReceipt && params.mutationAdmission?.advanceCreatedDirectory) {
-                        let evidence;
-                        try {
-                            const parent = current.policyDirectory
-                                ? refreshPolicyStagedDirectoryObservation(current.policyDirectory)
-                                : checkedMutationDirectory(currentPath, current.directory.realPath, assertStagedDirectoryCurrent(current.directory));
-                            evidence = Object.freeze({
-                                admission: createReceipt,
-                                parent,
-                                child: child.observation,
-                            });
-                        }
-                        catch {
-                            // Leave failed evidence to the full ordered admission below.
-                        }
-                        if (evidence) {
-                            childAuthorization = params.mutationAdmission.advanceCreatedDirectory(evidence);
-                        }
-                    }
-                    const targetPath = retainedTargetPath ?? joinPathSegmentRoute(child.parentPath, segmentRoute, index + 1, params.basename);
-                    const request = Object.freeze({
-                        targetPath,
-                        mutationPath: targetPath,
-                        phase: "parent",
-                    });
-                    childAuthorization ??= params.mutationAdmission?.tryAuthorizeAtParent?.(request, child.observation);
-                    if (!childAuthorization) {
-                        await authorizePinnedMutation(params, request);
-                        assertPosixParentCurrent(child);
-                    }
-                }
-                catch (error) {
-                    disposeObservation(childFd);
-                    closeFd(childFd);
-                    throw error;
-                }
-                const previousOwnedFd = currentOwnedFd;
-                disposeObservation(current.parentFd);
-                currentOwnedFd = child.parentFd;
-                currentFd = child.parentFd;
-                currentPath = child.parentPath;
-                current = child;
-                if (previousOwnedFd !== undefined)
-                    closeFd(previousOwnedFd);
-                if (index === segments.length - 1) {
-                    currentOwnedFd = undefined;
-                    return child;
-                }
-            }
-            // Empty relative parents are handled by the complete-parent fast path.
-            throw new FsSafeError("path-mismatch", "native write parent admission did not complete");
-        }
-        finally {
-            if (currentOwnedFd !== undefined) {
-                disposeObservation(currentOwnedFd);
-                closeFd(currentOwnedFd);
-            }
-        }
-    }
-    catch (e_1) {
-        env_1.error = e_1;
-        env_1.hasError = true;
-    }
-    finally {
-        __disposeResources(env_1);
-    }
-}
 export async function runPinnedWriteNative(binding, params) {
-    const env_2 = { stack: [], error: void 0, hasError: false };
+    const env_1 = { stack: [], error: void 0, hasError: false };
     try {
         const closeFd = captureNativeFdClose(binding);
         const windows = process.platform === "win32";
@@ -373,13 +74,13 @@ export async function runPinnedWriteNative(binding, params) {
             reportCloseErrors: completeCreate,
         });
         const root = rootAdmission.root;
-        const posixRoot = __addDisposableResource(env_2, windows ? undefined : root, true);
+        const posixRoot = __addDisposableResource(env_1, windows ? undefined : root, true);
         let parentFd;
         let windowsOwnsDirectories = false;
         let admissionFailure;
         // Until stage construction takes ownership, even admission failures must close
         // the raw POSIX parent. Disposal preserves both admission and close failures.
-        const parentGuard = __addDisposableResource(env_2, {
+        const parentGuard = __addDisposableResource(env_1, {
             [Symbol.dispose]() {
                 if (!windows && parentFd !== undefined) {
                     closeFd(parentFd);
@@ -390,17 +91,11 @@ export async function runPinnedWriteNative(binding, params) {
             let parentPath;
             let directory;
             let parentPathStat;
-            if (!windows && params.mutationAdmission) {
-                const admitted = await capturePolicyAwarePosixParent(binding, params, root.fd, directoryFlags);
-                parentFd = admitted.parentFd;
-                parentPath = admitted.parentPath;
-                directory = admitted.directory;
-                parentPathStat = admitted.parentPathStat;
-            }
-            else if (windows && params.mutationAdmission) {
-                const admitted = await capturePolicyAwareWindowsParent(binding, params, rootAdmission);
+            if (params.mutationAdmission) {
+                const admitted = await capturePolicyAwareNativeParent(binding, params, rootAdmission, windows, directoryFlags);
                 parentFd = admitted.fd;
                 parentPath = admitted.guard.realPath;
+                directory = admitted.stagedDirectory;
                 parentPathStat = admitted.guard.stat;
             }
             else {
@@ -466,12 +161,12 @@ export async function runPinnedWriteNative(binding, params) {
             }
         }
     }
-    catch (e_2) {
-        env_2.error = e_2;
-        env_2.hasError = true;
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
     }
     finally {
-        const result_1 = __disposeResources(env_2);
+        const result_1 = __disposeResources(env_1);
         if (result_1)
             await result_1;
     }

package/node_modules/@openclaw/fs-safe/dist/native-policy-parent-windows.d.ts

@@ -4,10 +4,10 @@ import { type NativeRootAdmission } from "./native-parent-admission.js";
 import type { NativeBinding } from "./native.js";
 import type { PinnedWriteParams } from "./pinned-write-types.js";
 import { type MutationDirectoryObservation } from "./pinned-mutation-observation.js";
-type PolicyParent = {
-    fd: number;
-    guard: AsyncDirectoryGuard<BigIntStats>;
-    observation: MutationDirectoryObservation;
-};
-export declare function capturePolicyAwareWindowsParent(binding: NativeBinding, params: PinnedWriteParams, rootAdmission: NativeRootAdmission): Promise<PolicyParent>;
-export {};
+import type { NativePolicyParent } from "./native-policy-parent.js";
+export declare function assertWindowsPolicyParentCurrent(parent: NativePolicyParent): void;
+export declare function closeWindowsPolicyParentAfterFailure(closeFd: (fd: number) => void, fd: number, failure?: {
+    error: unknown;
+}, report?: boolean): void;
+export declare function windowsParentObservation(binding: NativeBinding, fd: number, guard: AsyncDirectoryGuard<BigIntStats>): MutationDirectoryObservation;
+export declare function openWindowsPolicyParent(binding: NativeBinding, params: PinnedWriteParams, rootAdmission: NativeRootAdmission, fd: number, parentPath: string, relativePath: string): Promise<NativePolicyParent>;