@openclaw/openshell-sandbox 2026.10.5-beta.4 → 2026.10.10-beta.2

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

@@ -1,3 +1,4 @@
+import { type ExactFileIdentity } from "./exact-identity.js";
 import type { Stats } from "node:fs";
 import fsSync from "node:fs";
 export type RegularFileStatResult = {
@@ -5,6 +6,7 @@ export type RegularFileStatResult = {
 } | {
     missing: false;
     stat: Stats;
+    exactIdentity: ExactFileIdentity;
 };
 type RegularFileAppendFlagConstants = Pick<typeof fsSync.constants, "O_APPEND" | "O_CREAT" | "O_WRONLY"> & Partial<Pick<typeof fsSync.constants, "O_NOFOLLOW" | "O_NONBLOCK">>;
 export type AppendRegularFileOptions = {
@@ -24,6 +26,7 @@ export declare function readRegularFile(params: {
 }): Promise<{
     buffer: Buffer;
     stat: Stats;
+    exactIdentity: ExactFileIdentity;
 }>;
 export declare function readRegularFileSync(params: {
     filePath: string;
@@ -31,6 +34,7 @@ export declare function readRegularFileSync(params: {
 }): {
     buffer: Buffer;
     stat: Stats;
+    exactIdentity: ExactFileIdentity;
 };
 export declare function appendRegularFile(options: AppendRegularFileOptions): Promise<void>;
 export declare function appendRegularFileSync(options: AppendRegularFileOptions): void;

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

@@ -1,3 +1,4 @@
+import { exactFileIdentity, numberStats } from "./exact-identity.js";
 import fsSync from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
@@ -36,7 +37,7 @@ export function statRegularFileSync(filePath) {
     assertNoWindowsPathAlias(filePath, "filesystem", "file path uses a Windows filesystem namespace alias");
     let stat;
     try {
-        stat = fsSync.lstatSync(filePath);
+        stat = fsSync.lstatSync(filePath, { bigint: true });
     }
     catch (err) {
         if (isNotFoundPathError(err)) {
@@ -47,7 +48,7 @@ export function statRegularFileSync(filePath) {
     if (stat.isSymbolicLink() || !stat.isFile()) {
         throw new Error("path must be a regular file");
     }
-    return { missing: false, stat };
+    return { missing: false, stat: numberStats(stat), exactIdentity: exactFileIdentity(stat) };
 }
 export async function readRegularFile(params) {
     const { filePath, maxBytes, before } = prepareRegularRead(params);
@@ -62,15 +63,11 @@ export async function readRegularFile(params) {
         throw err;
     }
     try {
-        const stat = inspectOpenedRegularRead(handle.fd, filePath, before, maxBytes);
-        // With a byte cap, avoid readFile(): a raced file growth would allocate
-        // the oversized content before the post-read check could reject it.
+        const { stat, exactIdentity } = inspectOpenedRegularRead(handle.fd, filePath, before, maxBytes);
+        // readFile() can stop at a short nonblocking read before EOF (for example, 9p).
         let buffer;
         try {
-            buffer =
-                maxBytes === undefined
-                    ? await handle.readFile()
-                    : await readFileHandleBounded(handle, maxBytes);
+            buffer = await readFileHandleBounded(handle, maxBytes ?? Infinity);
         }
         catch (error) {
             if (maxBytes !== undefined) {
@@ -78,7 +75,7 @@ export async function readRegularFile(params) {
             }
             throw error;
         }
-        return { buffer, stat };
+        return { buffer, stat, exactIdentity };
     }
     finally {
         await handle.close();
@@ -117,7 +114,6 @@ function prepareRegularRead(params) {
     return { filePath, maxBytes, before };
 }
 function inspectOpenedRegularRead(fd, filePath, preOpenStat, maxBytes) {
-    const stat = fsSync.fstatSync(fd);
     const identity = inspectFileIdentitySync(() => {
         const exact = fsSync.fstatSync(fd, { bigint: true });
         assertRegularReadStat(exact, filePath);
@@ -136,10 +132,10 @@ function inspectOpenedRegularRead(fd, filePath, preOpenStat, maxBytes) {
         }
         throw error;
     }
-    if (maxBytes !== undefined && stat.size > maxBytes) {
+    if (maxBytes !== undefined && identity.size > maxBytes) {
         throw regularFileTooLargeError(filePath, maxBytes);
     }
-    return stat;
+    return { stat: numberStats(identity), exactIdentity: exactFileIdentity(identity) };
 }
 export function readRegularFileSync(params) {
     const { filePath, maxBytes, before } = prepareRegularRead(params);
@@ -154,7 +150,7 @@ export function readRegularFileSync(params) {
         throw error;
     }
     try {
-        const stat = inspectOpenedRegularRead(fd, filePath, before, maxBytes);
+        const { stat, exactIdentity } = inspectOpenedRegularRead(fd, filePath, before, maxBytes);
         // Keep capped reads incremental so raced growth cannot allocate unbounded content.
         let buffer;
         try {
@@ -168,7 +164,7 @@ export function readRegularFileSync(params) {
             }
             throw error;
         }
-        return { buffer, stat };
+        return { buffer, stat, exactIdentity };
     }
     finally {
         fsSync.closeSync(fd);

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

@@ -139,10 +139,11 @@ export function* writeTempFile(io, params) {
         const writing = file.writeFile(params.content, true);
         if (io.asynchronous)
             yield writing;
-        if (io.asyncFs === fs && process.platform !== "win32" && !params.sync) {
+        if ((io.asyncFs === fs || (process.platform === "win32" && io.syncFs === syncFs)) && !params.sync) {
             // Matching non-durable writes have no I/O left after this identity fence.
             const current = inspectAtomicIdentity(io, () => file.statExact(), identity, true);
-            if (Number(current.mode & 4095n) === (params.mode & 0o7777))
+            const modeMask = process.platform === "win32" ? 0o200 : 0o7777;
+            if (Number(current.mode & BigInt(modeMask)) === (params.mode & modeMask))
                 return { file, identity };
         }
         const chmod = file.chmod(params.mode);

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

@@ -0,0 +1,18 @@
+import { type BigIntStats } from "node:fs";
+import type { OpenResult } from "./root-impl.js";
+import type { RootContext } from "./root-context.js";
+import type { RootCopyOptions, RootCopySource, HardlinkPolicy } from "./root-options.js";
+import { onCopyPublication, onCopySourceAdmission, type CopyPublicationOptions } from "./copy-publication.js";
+type RootCopyParams = RootCopyOptions & {
+    source: RootCopySource;
+    relativePath: string;
+    verifyPublished?: CopyPublicationOptions[typeof onCopyPublication];
+    admitSource?: CopyPublicationOptions[typeof onCopySourceAdmission];
+};
+export declare function copyFileInRoot(root: RootContext, params: RootCopyParams, openVerifiedLocalFile: (path: string, options: {
+    hardlinks?: HardlinkPolicy;
+}) => Promise<{
+    opened: OpenResult;
+    identity: BigIntStats;
+}>): Promise<void>;
+export {};

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

@@ -0,0 +1,128 @@
+import fsSync, {} from "node:fs";
+import { assertCopySourceCurrent, resolveFileCopyCloneMode } from "./copy-file-input.js";
+import { resolveCopyCloneMode } from "./copy-policy.js";
+import { captureCopyMetadata } from "./copy-metadata.js";
+import { admitCopyLink, assertCopyLinkAvailable } from "./copy-link.js";
+import { assertAbsolutePathInput } from "./absolute-path.js";
+import { assertNoNulPathInput } from "./path.js";
+import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
+import { MutationAuthorityError } from "./mutation-authority.js";
+import { serializePathWrite } from "./write-queue.js";
+import { rootWriteQueueKey } from "./root-create-native.js";
+import { resolvePinnedWriteTargetInRoot } from "./root-write-admission.js";
+import { createCopyPublicationObserver, onCopyPublication, onCopySourceAdmission } from "./copy-publication.js";
+import { isAlreadyExistsError, normalizePinnedWriteError } from "./root-errors.js";
+import { runPinnedWriteHelper } from "./pinned-write.js";
+import { FsSafeError } from "./errors.js";
+export async function copyFileInRoot(root, params, openVerifiedLocalFile) {
+    params.signal?.throwIfAborted();
+    resolveCopyCloneMode(params.clone, "never");
+    if (params.sourceSymlinks !== undefined && params.sourceSymlinks !== "reject" && params.sourceSymlinks !== "copy-link") {
+        throw new FsSafeError("invalid-path", "sourceSymlinks must be reject or copy-link");
+    }
+    if (params.sourceSymlinks === "copy-link") {
+        if (typeof params.source !== "string") {
+            throw new FsSafeError("invalid-path", "sourceSymlinks: copy-link requires an absolute-path string source; open/stat capabilities cannot observe links without following them");
+        }
+        const link = await admitCopyLink(assertAbsolutePathInput(params.source), params.preserveMetadata === true, params.signal)
+            .catch(error => { throw normalizePinnedWriteError(error); });
+        if (link) {
+            if (params.overwrite === true)
+                throw new FsSafeError("invalid-path", "copy-link cannot overwrite an existing destination; omit overwrite or use false");
+            assertCopyLinkAvailable();
+            const mode = params.mode ?? (params.preserveSourceMode ? Number(link.identity.mode & 4095n) : undefined);
+            await copyInputInRoot(root, { ...params, overwrite: false }, link, mode);
+            return;
+        }
+    }
+    const clone = resolveFileCopyCloneMode(params.clone);
+    let source;
+    let sourceIdentity;
+    if (typeof params.source === "string") {
+        assertNoNulPathInput(params.source, "source path contains a NUL byte");
+        assertNoWindowsPathAlias(params.source, "filesystem", "source path uses a Windows filesystem namespace alias");
+        ({ opened: source, identity: sourceIdentity } = await openVerifiedLocalFile(params.source, {
+            hardlinks: params.sourceHardlinks,
+        }));
+    }
+    else {
+        source = await params.source.root.open(params.source.relativePath, params.sourceHardlinks === undefined ? undefined : { hardlinks: params.sourceHardlinks });
+        try {
+            sourceIdentity = inspectFileIdentitySync(() => fsSync.fstatSync(source.handle.fd, { bigint: true }));
+        }
+        catch (error) {
+            await source.handle.close().catch(() => undefined);
+            throw error;
+        }
+    }
+    try {
+        if (params.maxBytes !== undefined && source.stat.size > params.maxBytes) {
+            throw new FsSafeError("too-large", `file exceeds limit of ${params.maxBytes} bytes (got ${source.stat.size})`);
+        }
+        let metadata;
+        try {
+            metadata = params.preserveMetadata ? captureCopyMetadata(source.handle.fd, sourceIdentity) : undefined;
+        }
+        catch (error) {
+            throw normalizePinnedWriteError(error);
+        }
+        const sourceAdmission = params.admitSource?.(sourceIdentity, source.realPath);
+        const verifySource = async () => {
+            params.signal?.throwIfAborted();
+            try {
+                sourceAdmission?.verify();
+            }
+            catch (error) {
+                throw new MutationAuthorityError(error);
+            }
+            if (typeof params.source !== "string")
+                await params.source.root.stat(".");
+            assertCopySourceCurrent(source, sourceIdentity);
+        };
+        const mode = sourceAdmission?.mode ?? params.mode ?? (params.preserveSourceMode ? Number(sourceIdentity.mode & 4095n) : undefined);
+        await copyInputInRoot(root, params, {
+            kind: "file", handle: source.handle, size: source.stat.size, clone,
+            signal: params.signal, metadata, verifySource,
+        }, mode, () => assertCopySourceCurrent(source, sourceIdentity));
+    }
+    finally {
+        await source.handle.close().catch(() => { });
+    }
+}
+async function copyInputInRoot(root, params, input, mode, verifyAdmission = input.verifySource) {
+    if (mode !== undefined && (!Number.isInteger(mode) || mode < 0 || mode > 0o7777)) {
+        throw new FsSafeError("invalid-path", "invalid copy mode");
+    }
+    await serializePathWrite(rootWriteQueueKey(root, params.relativePath), async () => {
+        const pinned = await resolvePinnedWriteTargetInRoot(root, params.relativePath, mode, params.denyMutations, params.overwrite !== false, params.mutationSymlinks);
+        await serializePathWrite(pinned.targetPath, async () => {
+            await verifyAdmission();
+            const observer = createCopyPublicationObserver(pinned.targetPath, params.onDestinationPublished);
+            try {
+                await runPinnedWriteHelper({
+                    rootPath: pinned.rootReal, relativeParentPath: pinned.relativeParentPath, basename: pinned.basename,
+                    mkdir: params.mkdir !== false, mode: pinned.mode, overwrite: params.overwrite !== false,
+                    rejectFinalSymlink: params.mutationSymlinks !== undefined, maxBytes: params.maxBytes,
+                    sync: params.durable !== false,
+                    assertBeforeMutation: params.signal || params.assertBeforeMutation ? () => {
+                        if (params.signal?.aborted)
+                            throw new MutationAuthorityError(params.signal.reason);
+                        params.assertBeforeMutation?.();
+                    } : undefined,
+                    verifyPublished: params.verifyPublished, onPublished: observer.onPublished, input,
+                    rootIdentity: root.rootIdentity, mutationAdmission: pinned.mutationAdmission,
+                });
+            }
+            catch (error) {
+                observer.rethrowObserverFailure(error);
+                if (params.signal?.aborted && error === params.signal.reason)
+                    throw error;
+                if (isAlreadyExistsError(error))
+                    throw new FsSafeError("already-exists", "copy destination already exists", { cause: error });
+                throw normalizePinnedWriteError(error);
+            }
+            await input.verifySource();
+        });
+    });
+}

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

@@ -1,11 +1,13 @@
 import fs from "node:fs";
 import type { FileHandle } from "node:fs/promises";
 import { type AnyAsyncDirectoryGuard } from "./directory-guard.js";
-import { type PinnedMutationPolicySnapshot } from "./pinned-mutation-admission.js";
+import { type NativeBinding } from "./native.js";
 import { type RootContext } from "./root-context.js";
 import type { RootWritePathSelection, RetainedRootWriteSelection } from "./root-write-admission.js";
 import type { WritableOpenResult } from "./root-impl.js";
 import type { RootOpenWritableOptions } from "./root-options.js";
+import { type Creation } from "./root-native-creation-path.js";
+export { probeNativeCreationPath } from "./root-native-creation-path.js";
 export type OpenedWritableFileInRoot = {
     opened: WritableOpenResult;
     identity: fs.BigIntStats;
@@ -28,18 +30,12 @@ export type MissingWritableFileInRoot = {
     parentGuard: AnyAsyncDirectoryGuard;
     writeSelection?: RootWritePathSelection;
 };
-type Creation = {
-    root: RootContext;
-    directory: string;
-    target: string;
-    mkdir: boolean;
-    private?: boolean;
-    policy?: PinnedMutationPolicySnapshot;
-    resolveCurrent(): Promise<string>;
-    assertBeforeMutation?: () => void;
-    originalPath?: string;
-};
+export declare function isNativeCreateCollision(error: unknown): boolean;
+/** Admit only an ordinary direct child; aliases keep the full resolver. */
+export declare function tryMkdirNativeDirectChild(root: RootContext, relativePath: string): boolean;
 export declare function tryMkdirRootNative(params: Creation): Promise<boolean>;
+export declare function verifyMkdirDirectory(binding: NativeBinding, fd: number, pathname: string): void;
+export declare function ensureNativeRootCurrent(root: RootContext): void;
 export declare function tryOpenCreateRootNative(params: Creation & {
     flags: number;
     existingFlags: number;
@@ -49,4 +45,3 @@ export declare function tryOpenCreateRootNative(params: Creation & {
     cleanupCreated(): Promise<void>;
     releaseCreationParent(): void;
 }>;
-export {};