@openclaw/feishu 2026.9.6 → 2026.9.8

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

@@ -0,0 +1,71 @@
+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;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "0" || normalized === "false" || normalized === "off" || normalized === "never") {
+        return "off";
+    }
+    if (normalized === "1" || normalized === "true" || normalized === "on" || normalized === "auto") {
+        return "auto";
+    }
+    if (normalized === "required" || normalized === "require") {
+        return "require";
+    }
+    return undefined;
+}
+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 __resetFsSafeNativeConfigForTest() {
+    overrideConfig = {};
+    legacyWarningEmitted = false;
+}

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

@@ -0,0 +1,16 @@
+import { type NativeBinding } from "./native.js";
+import type { NativeDirectoryObservation } from "./native-binding.js";
+import type { ExactStatIdentity } from "./stat-observation.js";
+export type NativeDirectoryObservationBackend = NativeBinding & {
+    observeDirectory(pathname: string): NativeDirectoryObservation;
+};
+export type NativeDirectoryObservationGuard = NativeDirectoryObservation & {
+    dir: string;
+    identity: ExactStatIdentity;
+    nativeDirectoryObservation: true;
+};
+export declare function getNativeDirectoryObservationBackend(enabled?: boolean): NativeDirectoryObservationBackend | undefined;
+/** Exact identity, type, and canonical path captured from one retained handle. */
+export declare function inspectNativeDirectoryObservation(backend: NativeDirectoryObservationBackend, pathname: string, expected?: ExactStatIdentity, platform?: NodeJS.Platform): NativeDirectoryObservation;
+export declare function extendNativeDirectoryObservationGuard(observation: NativeDirectoryObservation, dir: string): NativeDirectoryObservationGuard;
+export declare function isNativeDirectoryObservationGuard(guard: unknown): guard is NativeDirectoryObservationGuard;

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

@@ -0,0 +1,37 @@
+import path from "node:path";
+import { FsSafeError } from "./errors.js";
+import { getNativeBinding } from "./native.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
+export function getNativeDirectoryObservationBackend(enabled = true) {
+    if (!enabled)
+        return undefined;
+    const binding = getNativeBinding();
+    return binding && typeof binding.observeDirectory === "function"
+        ? binding
+        : undefined;
+}
+function validateNativeDirectoryObservation(observation) {
+    if (!observation || typeof observation.dev !== "bigint" || observation.dev < 0n ||
+        typeof observation.ino !== "bigint" || observation.ino < 0n ||
+        typeof observation.realPath !== "string" ||
+        observation.realPath.includes("\0") ||
+        (!path.isAbsolute(observation.realPath) && !path.win32.isAbsolute(observation.realPath))) {
+        throw new FsSafeError("path-mismatch", "native directory observation is invalid");
+    }
+    return observation;
+}
+/** Exact identity, type, and canonical path captured from one retained handle. */
+export function inspectNativeDirectoryObservation(backend, pathname, expected, platform = process.platform) {
+    return inspectFileIdentitySync(() => validateNativeDirectoryObservation(backend.observeDirectory(pathname)), expected, platform);
+}
+export function extendNativeDirectoryObservationGuard(observation, dir) {
+    const guard = observation;
+    guard.dir = dir;
+    guard.identity = guard;
+    guard.nativeDirectoryObservation = true;
+    return guard;
+}
+export function isNativeDirectoryObservationGuard(guard) {
+    return typeof guard === "object" && guard !== null &&
+        guard.nativeDirectoryObservation === true;
+}

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

@@ -0,0 +1,3 @@
+/** Warn once per capability, without including caller paths or native error text. */
+export declare function warnNativeFallback(feature: string, limitation: string): void;
+export declare function __resetNativeFallbackWarningsForTest(): void;

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

@@ -0,0 +1,11 @@
+const warnedFeatures = new Set();
+/** Warn once per capability, without including caller paths or native error text. */
+export function warnNativeFallback(feature, limitation) {
+    if (warnedFeatures.has(feature))
+        return;
+    warnedFeatures.add(feature);
+    process.emitWarning(`${feature} is using its portable fallback because native support is unavailable or disabled. ${limitation}`, { code: "FS_SAFE_NATIVE_FALLBACK", type: "FsSafeWarning" });
+}
+export function __resetNativeFallbackWarningsForTest() {
+    warnedFeatures.clear();
+}

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

@@ -0,0 +1,15 @@
+import { type BigIntStats } from "node:fs";
+export type NativeFileHandle = {
+    readonly fd: number;
+    close(): Promise<void>;
+    writeFile(data: string | Buffer, encoding?: BufferEncoding): Promise<void>;
+};
+export declare function nativeOpenFlags(flags: number): number;
+export declare function writeNativeFd(fd: number, data: Buffer): void;
+export declare function removeNativeCreatedFileIfStillPinned(params: {
+    parentPath: string;
+    parentFd: number;
+    basename: string;
+    created?: BigIntStats;
+}): void;
+export declare function createNativeExclusiveFile(targetPath: string, mode: number): Promise<NativeFileHandle | undefined>;

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

@@ -0,0 +1,111 @@
+import fsSync, {} from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { sameFileIdentityForCleanup } from "./file-identity.js";
+import { getNativeBinding } from "./native.js";
+import { captureNativeFdClose } from "./native-binding.js";
+export function nativeOpenFlags(flags) {
+    const closeOnExec = fsSync.constants.O_CLOEXEC;
+    return (flags |
+        (closeOnExec ?? 0) |
+        (typeof fsSync.constants.O_NOFOLLOW === "number" ? fsSync.constants.O_NOFOLLOW : 0));
+}
+export function writeNativeFd(fd, data) {
+    let offset = 0;
+    while (offset < data.byteLength) {
+        const written = fsSync.writeSync(fd, data, offset, data.byteLength - offset);
+        if (written <= 0) {
+            throw Object.assign(new Error("native file write made no progress"), { code: "EIO" });
+        }
+        offset += written;
+    }
+}
+function wrapNativeFd(fd, closeFd) {
+    let open = true;
+    return {
+        fd,
+        async close() {
+            if (open) {
+                open = false;
+                closeFd(fd);
+            }
+        },
+        async writeFile(data, encoding) {
+            writeNativeFd(fd, Buffer.isBuffer(data) ? data : Buffer.from(data, encoding ?? "utf8"));
+        },
+    };
+}
+export function removeNativeCreatedFileIfStillPinned(params) {
+    if (!params.created) {
+        return;
+    }
+    try {
+        const parentPathStat = fsSync.lstatSync(params.parentPath, { bigint: true });
+        const parentFdStat = fsSync.fstatSync(params.parentFd, { bigint: true });
+        const targetPath = path.join(params.parentPath, params.basename);
+        const target = fsSync.lstatSync(targetPath, { bigint: true });
+        if (!parentPathStat.isSymbolicLink() && parentPathStat.isDirectory() &&
+            sameFileIdentityForCleanup(parentPathStat, parentFdStat) &&
+            !target.isSymbolicLink() && target.isFile() &&
+            sameFileIdentityForCleanup(target, params.created)) {
+            fsSync.rmSync(targetPath);
+        }
+    }
+    catch {
+        // Failed cleanup leaves a fail-closed artifact instead of deleting an
+        // unverified pathname.
+    }
+}
+export async function createNativeExclusiveFile(targetPath, mode) {
+    const binding = getNativeBinding();
+    if (!binding) {
+        return undefined;
+    }
+    const closeFd = captureNativeFdClose(binding);
+    const parentPath = path.dirname(targetPath);
+    const basename = path.basename(targetPath);
+    const parent = await fs.open(parentPath, fsSync.constants.O_RDONLY |
+        (typeof fsSync.constants.O_DIRECTORY === "number" ? fsSync.constants.O_DIRECTORY : 0));
+    let fd;
+    let created;
+    try {
+        let opened;
+        try {
+            opened = binding.openBeneath(parent.fd, basename, nativeOpenFlags(fsSync.constants.O_WRONLY | fsSync.constants.O_CREAT | fsSync.constants.O_EXCL));
+        }
+        catch (error) {
+            // The parent open above and every post-create operation remain untagged.
+            // Only this exclusive-open failure has enough provenance for a caller to
+            // classify a Windows lock-file denial without swallowing setup failures.
+            const openError = error;
+            if (process.platform === "win32" && openError.code === "EPERM") {
+                openError.path = targetPath;
+            }
+            throw error;
+        }
+        fd = opened.fd;
+        fsSync.fchmodSync(fd, mode);
+        created = fsSync.fstatSync(fd, { bigint: true });
+        return wrapNativeFd(fd, closeFd);
+    }
+    catch (error) {
+        if (fd !== undefined) {
+            try {
+                closeFd(fd);
+            }
+            catch {
+                // Preserve the original error.
+            }
+            removeNativeCreatedFileIfStillPinned({
+                parentPath,
+                parentFd: parent.fd,
+                basename,
+                created,
+            });
+        }
+        throw error;
+    }
+    finally {
+        await parent.close().catch(() => undefined);
+    }
+}

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

@@ -0,0 +1,34 @@
+import { type BigIntStats, type Stats } from "node:fs";
+import type { FileHandle } from "node:fs/promises";
+import type { FileIdentityStat } from "./file-identity.js";
+import type { NativeBinding } from "./native.js";
+import { describeStagedDirectory } from "./staged-directory.js";
+type RootIdentity = Pick<FileIdentityStat, "dev" | "ino">;
+export type NativeRootAdmission = {
+    exactRoot: boolean;
+    reportCloseErrors?: boolean;
+    operation: string;
+    root: FileHandle;
+    rootPath: string;
+};
+export type NativeParentAdmission = {
+    fd: number;
+    close(): void;
+    guard: {
+        dir: string;
+        realPath: string;
+        stat: Stats | BigIntStats;
+    };
+    stagedDirectory?: ReturnType<typeof describeStagedDirectory>;
+};
+export declare function sameNativeIdentity(left: RootIdentity, right: RootIdentity): boolean;
+export declare function openNativeRootAdmission(binding: NativeBinding, params: {
+    rootPath: string;
+    rootIdentity?: RootIdentity;
+    operation?: string;
+    reportCloseErrors?: boolean;
+}): Promise<NativeRootAdmission>;
+export declare function openNativeParentAdmission(binding: NativeBinding, rootAdmission: Omit<NativeRootAdmission, "root"> & {
+    root: Pick<FileHandle, "fd">;
+}, relativeParentPath: string, observation?: "native-directory"): Promise<NativeParentAdmission>;
+export {};

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

@@ -0,0 +1,147 @@
+import fsSync, {} from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { inspectDirectoryIdentity, inspectDirectoryIdentitySync } from "./directory-guard.js";
+import { inspectNativeDirectoryObservation } from "./native-directory-observation.js";
+import { FsSafeError } from "./errors.js";
+import { captureNativeFdClose } from "./native-binding.js";
+import { realpathSync } from "./realpath.js";
+import { describeStagedDirectory, exactIdentityMatches } from "./staged-directory.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
+import { createSuppressedError } from "./suppressed-error.js";
+import { assertNoWindowsPathAlias, pathForWindowsFilesystem } from "./windows-path-alias.js";
+export function sameNativeIdentity(left, right) {
+    return left.dev === right.dev && left.ino === right.ino;
+}
+function unavailable(message) {
+    return new FsSafeError("helper-unavailable", message);
+}
+function assertParentAdmissionAvailable(binding) {
+    if (typeof binding.openBeneath !== "function") {
+        throw unavailable("native parent directory admission is unavailable");
+    }
+    captureNativeFdClose(binding);
+}
+export async function openNativeRootAdmission(binding, params) {
+    assertParentAdmissionAvailable(binding);
+    const directoryFlags = 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 {
+        const exactRoot = typeof params.rootIdentity?.dev === "bigint" &&
+            typeof params.rootIdentity.ino === "bigint";
+        let rootMatches;
+        if (exactRoot) {
+            inspectFileIdentitySync(() => fsSync.fstatSync(root.fd, { bigint: true }), params.rootIdentity);
+            rootMatches = true;
+        }
+        else if (process.platform === "win32") {
+            if (typeof binding.fstatIdentity !== "function") {
+                throw unavailable("native root directory identity checks are unavailable");
+            }
+            const identity = binding.fstatIdentity(root.fd);
+            rootMatches = !params.rootIdentity || sameNativeIdentity(params.rootIdentity, identity);
+        }
+        else {
+            const identity = fsSync.fstatSync(root.fd, { bigint: true });
+            rootMatches = !params.rootIdentity || exactIdentityMatches(params.rootIdentity, identity);
+        }
+        if (!rootMatches) {
+            throw new FsSafeError("path-mismatch", `root path changed during ${params.operation ?? "native admission"}`);
+        }
+        return {
+            exactRoot,
+            reportCloseErrors: params.reportCloseErrors,
+            operation: params.operation ?? "native admission",
+            root,
+            rootPath: params.rootPath,
+        };
+    }
+    catch (error) {
+        try {
+            await root.close();
+        }
+        catch (closeError) {
+            // Windows admission keeps the typed boundary failure primary.
+            if (process.platform !== "win32" || params.reportCloseErrors) {
+                throw createSuppressedError(closeError, error, "native root admission and close failed");
+            }
+        }
+        throw error;
+    }
+}
+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);
+    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) {
+        throw unavailable("native parent directory admission did not provide a descriptor");
+    }
+    const parentFd = opened.fd;
+    try {
+        const parentInput = relativeParentPath
+            ? path.join(rootAdmission.rootPath, ...relativeParentPath.split("/"))
+            : rootAdmission.rootPath;
+        if (observation === "native-directory" && process.platform === "win32" && rootAdmission.exactRoot &&
+            typeof binding.observeDirectory === "function") {
+            const stat = inspectFileIdentitySync(() => fsSync.fstatSync(parentFd, { bigint: true }));
+            let observed;
+            try {
+                observed = inspectNativeDirectoryObservation(binding, parentInput, stat);
+            }
+            catch (error) {
+                if (error?.code !== "OBSERVATION_UNAVAILABLE")
+                    throw error;
+            }
+            if (observed) {
+                assertNoWindowsPathAlias(observed.realPath, "filesystem", "native parent uses a Windows filesystem namespace alias");
+                inspectDirectoryIdentitySync(observed.realPath, stat, stat);
+                return {
+                    fd: parentFd,
+                    close: () => closeFd(parentFd),
+                    guard: { dir: observed.realPath, realPath: observed.realPath, stat },
+                };
+            }
+        }
+        const parentPath = realpathSync.native(pathForWindowsFilesystem(parentInput));
+        assertNoWindowsPathAlias(parentPath, "filesystem", "native parent uses a Windows filesystem namespace alias");
+        const stagedDirectory = process.platform === "win32"
+            ? undefined
+            : describeStagedDirectory(parentFd, parentPath);
+        const parentPathStat = rootAdmission.exactRoot
+            ? await inspectDirectoryIdentity(parentPath, inspectFileIdentitySync(() => fsSync.fstatSync(parentFd, { bigint: true })))
+            : fsSync.lstatSync(pathForWindowsFilesystem(parentPath));
+        if (process.platform === "win32" && !rootAdmission.exactRoot) {
+            if (typeof binding.fstatIdentity !== "function") {
+                throw unavailable("native parent directory identity checks are unavailable");
+            }
+            const parentIdentity = binding.fstatIdentity(parentFd);
+            if (parentPathStat.isSymbolicLink() || !sameNativeIdentity(parentPathStat, parentIdentity)) {
+                throw new FsSafeError("path-mismatch", `${rootAdmission.operation} parent changed during resolution`);
+            }
+        }
+        else if (process.platform !== "win32" &&
+            (parentPathStat.isSymbolicLink() || !exactIdentityMatches(parentPathStat, stagedDirectory.identity))) {
+            throw new FsSafeError("path-mismatch", `${rootAdmission.operation} parent changed during resolution`);
+        }
+        return {
+            fd: parentFd,
+            close: () => closeFd(parentFd),
+            guard: { dir: parentPath, realPath: parentPath, stat: parentPathStat },
+            stagedDirectory,
+        };
+    }
+    catch (error) {
+        try {
+            closeFd(parentFd);
+        }
+        catch (closeError) {
+            if (process.platform !== "win32" || rootAdmission.reportCloseErrors) {
+                throw createSuppressedError(closeError, error, "native parent admission and close failed");
+            }
+        }
+        throw error;
+    }
+}

package/node_modules/@openclaw/fs-safe/dist/native-pinned-write-windows.d.ts

@@ -0,0 +1,6 @@
+import type { FileHandle } from "node:fs/promises";
+import { type AnyAsyncDirectoryGuard } from "./directory-guard.js";
+import type { FileIdentityStat } from "./file-identity.js";
+import type { NativeBinding } from "./native.js";
+import type { PinnedWriteParams } from "./pinned-write-types.js";
+export declare function runPinnedWriteWindows(binding: NativeBinding, params: PinnedWriteParams, root: FileHandle, parentFd: number, parentGuard: AnyAsyncDirectoryGuard): Promise<FileIdentityStat>;