@lousy-agents/agent-shell 5.14.10 → 5.15.1

package/dist/index.js

@@ -2,7 +2,7 @@
 import { createRequire as __rspack_createRequire } from "node:module";
 const __rspack_createRequire_require = __rspack_createRequire(import.meta.url);
 var __webpack_modules__ = ({
-145(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
+341(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
 
 ;// CONCATENATED MODULE: external "node:child_process"
 const external_node_child_process_namespaceObject = __rspack_createRequire_require("node:child_process");
@@ -546,6 +546,191 @@ function guardedRmSync(params) {
     }), { verifyAfter: params.verifyAfter });
 }
 
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/deny-mutations.js
+
+
+
+
+async function pathExists(filePath) {
+    try {
+        await promises_namespaceObject.lstat(filePath);
+        return true;
+    }
+    catch (err) {
+        if (!path_isNotFoundPathError(err)) {
+            throw err;
+        }
+        return false;
+    }
+}
+async function resolvePathViaExistingAncestor(targetPath) {
+    const normalized = external_node_path_namespaceObject.resolve(targetPath);
+    let cursor = normalized;
+    const missingSuffix = [];
+    while (external_node_path_namespaceObject.dirname(cursor) !== cursor && !(await pathExists(cursor))) {
+        missingSuffix.unshift(external_node_path_namespaceObject.basename(cursor));
+        cursor = external_node_path_namespaceObject.dirname(cursor);
+    }
+    if (!(await pathExists(cursor))) {
+        return normalized;
+    }
+    try {
+        const resolvedAncestor = external_node_path_namespaceObject.resolve(await promises_namespaceObject.realpath(cursor));
+        return missingSuffix.length === 0
+            ? resolvedAncestor
+            : external_node_path_namespaceObject.resolve(resolvedAncestor, ...missingSuffix);
+    }
+    catch {
+        return normalized;
+    }
+}
+async function comparablePaths(rawPath) {
+    path_assertNoNulPathInput(rawPath, "path contains a NUL byte");
+    const resolved = external_node_path_namespaceObject.resolve(rawPath);
+    return new Set([resolved, await resolvePathViaExistingAncestor(resolved)]);
+}
+function isSamePath(left, right) {
+    return path_isPathInside(left, right) && path_isPathInside(right, left);
+}
+function hasPolicyEntries(policy) {
+    return Boolean(policy?.paths?.length || policy?.prefixes?.length);
+}
+function policyPathEntries(entries) {
+    const paths = [];
+    for (const entry of entries ?? []) {
+        if (entry.length === 0) {
+            throw new errors_FsSafeError("invalid-path", "deny mutation paths must be non-empty");
+        }
+        path_assertNoNulPathInput(entry, "deny mutation path contains a NUL byte");
+        if (!external_node_path_namespaceObject.isAbsolute(entry)) {
+            throw new errors_FsSafeError("invalid-path", "deny mutation paths must be absolute");
+        }
+        paths.push(entry);
+    }
+    return paths;
+}
+async function assertMutationNotDenied(filePath, policy, options = {}) {
+    if (!hasPolicyEntries(policy)) {
+        return;
+    }
+    const targetPaths = await comparablePaths(filePath);
+    for (const deniedPath of policyPathEntries(policy.paths)) {
+        const deniedPaths = await comparablePaths(deniedPath);
+        for (const target of targetPaths) {
+            for (const denied of deniedPaths) {
+                if (isSamePath(denied, target) ||
+                    (options.protectAncestors === true && path_isPathInside(target, denied))) {
+                    throw new errors_FsSafeError("denied-path", "path is denied by denyMutations policy");
+                }
+            }
+        }
+    }
+    for (const deniedPrefix of policyPathEntries(policy.prefixes)) {
+        const deniedPaths = await comparablePaths(deniedPrefix);
+        for (const target of targetPaths) {
+            for (const denied of deniedPaths) {
+                if (path_isPathInside(denied, target) ||
+                    (options.protectAncestors === true && path_isPathInside(target, denied))) {
+                    throw new errors_FsSafeError("denied-path", "path is denied by denyMutations policy");
+                }
+            }
+        }
+    }
+}
+function mergeDenyMutationPolicies(defaultPolicy, callPolicy) {
+    if (!defaultPolicy) {
+        return callPolicy;
+    }
+    if (!callPolicy) {
+        return defaultPolicy;
+    }
+    return {
+        paths: [...(defaultPolicy.paths ?? []), ...(callPolicy.paths ?? [])],
+        prefixes: [...(defaultPolicy.prefixes ?? []), ...(callPolicy.prefixes ?? [])],
+    };
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/opened-realpath.js
+
+
+
+
+
+async function resolveOpenedFileRealPathForHandle(handle, ioPath) {
+    const handleStat = await handle.stat();
+    const fdCandidates = process.platform === "linux"
+        ? [`/proc/self/fd/${handle.fd}`, `/dev/fd/${handle.fd}`]
+        : process.platform === "win32"
+            ? []
+            : [`/dev/fd/${handle.fd}`];
+    for (const fdPath of fdCandidates) {
+        try {
+            const fdRealPath = await promises_namespaceObject.realpath(fdPath);
+            const fdRealStat = await promises_namespaceObject.stat(fdRealPath);
+            if (file_identity_sameFileIdentity(handleStat, fdRealStat)) {
+                return fdRealPath;
+            }
+        }
+        catch {
+            // try next fd path
+        }
+    }
+    try {
+        const ioRealPath = await promises_namespaceObject.realpath(ioPath);
+        const ioRealStat = await promises_namespaceObject.stat(ioRealPath);
+        if (file_identity_sameFileIdentity(handleStat, ioRealStat)) {
+            return ioRealPath;
+        }
+    }
+    catch (err) {
+        if (!path_isNotFoundPathError(err)) {
+            throw err;
+        }
+    }
+    const parentResolved = await resolveOpenedFileRealPathFromParent(handleStat, ioPath);
+    if (parentResolved) {
+        return parentResolved;
+    }
+    throw new errors_FsSafeError("path-mismatch", "unable to resolve opened file path");
+}
+async function resolveOpenedFileRealPathFromParent(handleStat, ioPath) {
+    let parentReal;
+    try {
+        parentReal = await promises_namespaceObject.realpath(external_node_path_namespaceObject.dirname(ioPath));
+    }
+    catch (err) {
+        if (path_isNotFoundPathError(err)) {
+            return null;
+        }
+        throw err;
+    }
+    let entries;
+    try {
+        entries = await promises_namespaceObject.readdir(parentReal);
+    }
+    catch (err) {
+        if (path_isNotFoundPathError(err)) {
+            return null;
+        }
+        throw err;
+    }
+    for (const entry of entries.toSorted()) {
+        const candidatePath = external_node_path_namespaceObject.join(parentReal, entry);
+        try {
+            const candidateStat = await promises_namespaceObject.lstat(candidatePath);
+            if (candidateStat.isFile() && file_identity_sameFileIdentity(handleStat, candidateStat)) {
+                return await promises_namespaceObject.realpath(candidatePath);
+            }
+        }
+        catch (err) {
+            if (!path_isNotFoundPathError(err)) {
+                throw err;
+            }
+        }
+    }
+    return null;
+}
+
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/pinned-python-config.js
 let overrideConfig = {};
 function parseMode(value) {
@@ -1390,7 +1575,7 @@ async function runPinnedWriteHelper(params) {
         relativeParentPath: params.relativeParentPath,
     });
     if (getFsSafePythonConfig().mode === "off") {
-        return await runPinnedWriteFallbackOrThrow(params);
+        return await runPinnedWriteFallback(params);
     }
     if (params.input.kind === "stream") {
         try {
@@ -1398,7 +1583,7 @@ async function runPinnedWriteHelper(params) {
         }
         catch (error) {
             if (canFallbackFromPythonError(error)) {
-                return await runPinnedWriteFallbackOrThrow(params, error);
+                return await runPinnedWriteFallback(params);
             }
             throw error;
         }
@@ -1422,7 +1607,7 @@ async function runPinnedWriteHelper(params) {
     }
     catch (error) {
         if (canFallbackFromPythonError(error)) {
-            return await runPinnedWriteFallbackOrThrow(params, error);
+            return await runPinnedWriteFallback(params);
         }
         throw error;
     }
@@ -1449,12 +1634,6 @@ async function runPinnedCopyHelper(params) {
         },
     });
 }
-async function runPinnedWriteFallbackOrThrow(params, cause) {
-    if (process.platform !== "win32") {
-        throw new errors_FsSafeError("helper-unavailable", "Python helper is required for pinned writes on this platform", { cause });
-    }
-    return await runPinnedWriteFallback(params);
-}
 async function runPinnedWriteFallback(params) {
     const parentPath = params.relativeParentPath
         ? external_node_path_namespaceObject.join(params.rootPath, ...params.relativeParentPath.split("/"))
@@ -1577,7 +1756,7 @@ async function resolveRootPath(params) {
     const absolutePath = external_node_path_namespaceObject.resolve(params.absolutePath);
     const rootCanonicalPath = params.rootCanonicalPath
         ? external_node_path_namespaceObject.resolve(params.rootCanonicalPath)
-        : await resolvePathViaExistingAncestor(rootPath);
+        : await root_path_resolvePathViaExistingAncestor(rootPath);
     const context = createBoundaryResolutionContext({
         resolveParams: params,
         rootPath,
@@ -1946,7 +2125,7 @@ async function resolveOutsideLexicalCanonicalPathAsync(params) {
     if (path_isPathInside(params.rootPath, params.absolutePath)) {
         return undefined;
     }
-    return await resolvePathViaExistingAncestor(params.absolutePath);
+    return await root_path_resolvePathViaExistingAncestor(params.absolutePath);
 }
 function resolveOutsideLexicalCanonicalPathSync(params) {
     if (isPathInside(params.rootPath, params.absolutePath)) {
@@ -1993,11 +2172,11 @@ function buildResolvedRootPath(params) {
         kind: params.kind.kind,
     };
 }
-async function resolvePathViaExistingAncestor(targetPath) {
+async function root_path_resolvePathViaExistingAncestor(targetPath) {
     const normalized = external_node_path_namespaceObject.resolve(targetPath);
     let cursor = normalized;
     const missingSuffix = [];
-    while (!isFilesystemRoot(cursor) && !(await pathExists(cursor))) {
+    while (!isFilesystemRoot(cursor) && !(await root_path_pathExists(cursor))) {
         missingSuffix.unshift(external_node_path_namespaceObject.basename(cursor));
         const parent = external_node_path_namespaceObject.dirname(cursor);
         if (parent === cursor) {
@@ -2005,7 +2184,7 @@ async function resolvePathViaExistingAncestor(targetPath) {
         }
         cursor = parent;
     }
-    if (!(await pathExists(cursor))) {
+    if (!(await root_path_pathExists(cursor))) {
         return normalized;
     }
     try {
@@ -2117,7 +2296,7 @@ function shortPath(value) {
 function isFilesystemRoot(candidate) {
     return external_node_path_namespaceObject.parse(candidate).root === candidate;
 }
-async function pathExists(targetPath) {
+async function root_path_pathExists(targetPath) {
     try {
         await promises_namespaceObject.lstat(targetPath);
         return true;
@@ -2139,7 +2318,7 @@ async function resolveSymlinkHopPath(symlinkPath) {
         }
         const linkTarget = await promises_namespaceObject.readlink(symlinkPath);
         const linkAbsolute = external_node_path_namespaceObject.resolve(external_node_path_namespaceObject.dirname(symlinkPath), linkTarget);
-        return resolvePathViaExistingAncestor(linkAbsolute);
+        return root_path_resolvePathViaExistingAncestor(linkAbsolute);
     }
 }
 function resolveSymlinkHopPathSync(symlinkPath) {
@@ -2208,6 +2387,23 @@ function path_policy_shortPath(value) {
     return value;
 }
 
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/read-opened-file.js
+
+async function read_opened_file_readOpenedFileSafely(params) {
+    if (params.maxBytes !== undefined && params.opened.stat.size > params.maxBytes) {
+        throw new errors_FsSafeError("too-large", `file exceeds limit of ${params.maxBytes} bytes (got ${params.opened.stat.size})`);
+    }
+    const buffer = await params.opened.handle.readFile();
+    if (params.maxBytes !== undefined && buffer.byteLength > params.maxBytes) {
+        throw new errors_FsSafeError("too-large", `file exceeds limit of ${params.maxBytes} bytes (got ${buffer.byteLength})`);
+    }
+    return {
+        buffer,
+        realPath: params.opened.realPath,
+        stat: params.opened.stat,
+    };
+}
+
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/path-stat.js
 function pathStatFromStats(stat) {
     return {
@@ -2535,6 +2731,10 @@ async function serializePathWrite(key, run) {
 
 
 
+
+
+
+
 
 
 
@@ -2733,6 +2933,7 @@ class RootHandle {
             mkdir: this.defaults.mkdir,
             mode: this.defaults.mode,
             ...options,
+            denyMutations: mergeDenyMutationPolicies(this.defaults.denyMutations, options.denyMutations),
             append: writeMode === "append",
             truncateExisting: writeMode === "replace",
         });
@@ -2744,18 +2945,29 @@ class RootHandle {
             mkdir: this.defaults.mkdir,
             mode: this.defaults.mode,
             ...options,
+            denyMutations: mergeDenyMutationPolicies(this.defaults.denyMutations, options.denyMutations),
         });
     }
-    async remove(relativePath) {
+    async remove(relativePath, options = {}) {
         assertValidRootRelativePath(relativePath);
-        await removePathInRoot(this.context, relativePath);
+        await removePathInRoot(this.context, {
+            relativePath,
+            denyMutations: mergeDenyMutationPolicies(this.defaults.denyMutations, options.denyMutations),
+        });
     }
-    async mkdir(relativePath) {
+    async mkdir(relativePath, options = {}) {
         assertValidRootRelativePath(relativePath);
-        await mkdirPathInRoot(this.context, { relativePath });
+        await mkdirPathInRoot(this.context, {
+            relativePath,
+            denyMutations: mergeDenyMutationPolicies(this.defaults.denyMutations, options.denyMutations),
+        });
     }
-    async ensureRoot() {
-        await mkdirPathInRoot(this.context, { relativePath: "", allowRoot: true });
+    async ensureRoot(options = {}) {
+        await mkdirPathInRoot(this.context, {
+            relativePath: "",
+            allowRoot: true,
+            denyMutations: mergeDenyMutationPolicies(this.defaults.denyMutations, options.denyMutations),
+        });
     }
     async write(relativePath, data, options = {}) {
         await writeFileInRoot(this.context, {
@@ -2764,6 +2976,7 @@ class RootHandle {
             mkdir: this.defaults.mkdir,
             mode: this.defaults.mode,
             ...options,
+            denyMutations: mergeDenyMutationPolicies(this.defaults.denyMutations, options.denyMutations),
         });
     }
     async create(relativePath, data, options = {}) {
@@ -2773,6 +2986,7 @@ class RootHandle {
             mkdir: this.defaults.mkdir,
             mode: this.defaults.mode,
             ...options,
+            denyMutations: mergeDenyMutationPolicies(this.defaults.denyMutations, options.denyMutations),
             overwrite: false,
         });
     }
@@ -2795,6 +3009,7 @@ class RootHandle {
             mkdir: this.defaults.mkdir,
             mode: this.defaults.mode,
             ...options,
+            denyMutations: mergeDenyMutationPolicies(this.defaults.denyMutations, options.denyMutations),
         });
     }
     async exists(relativePath) {
@@ -2838,6 +3053,12 @@ class RootHandle {
     async move(fromRelative, toRelative, options = {}) {
         assertValidRootRelativePath(fromRelative);
         assertValidRootRelativePath(toRelative);
+        const denyMutations = mergeDenyMutationPolicies(this.defaults.denyMutations, options.denyMutations);
+        await assertMoveMutationAllowed(this.context, {
+            fromRelative,
+            toRelative,
+            denyMutations,
+        });
         try {
             await runPinnedHelper("rename", this.rootReal, {
                 from: fromRelative,
@@ -2849,6 +3070,7 @@ class RootHandle {
             if (canFallbackFromPythonError(error)) {
                 await movePathFallback(this.context, {
                     fromRelative,
+                    denyMutations,
                     overwrite: options.overwrite ?? false,
                     toRelative,
                 });
@@ -2897,7 +3119,7 @@ async function openFileInRoot(root, params) {
 async function readFileInRoot(root, params) {
     const opened = await openFileInRoot(root, params);
     try {
-        return await readOpenedFileSafely({ opened, maxBytes: params.maxBytes });
+        return await read_opened_file_readOpenedFileSafely({ opened, maxBytes: params.maxBytes });
     }
     finally {
         await opened.handle.close().catch(() => { });
@@ -2930,20 +3152,6 @@ async function openLocalFileSafely(params) {
     assertNoNulPathInput(params.filePath, "file path contains a NUL byte");
     return await openVerifiedLocalFile(params.filePath);
 }
-async function readOpenedFileSafely(params) {
-    if (params.maxBytes !== undefined && params.opened.stat.size > params.maxBytes) {
-        throw new errors_FsSafeError("too-large", `file exceeds limit of ${params.maxBytes} bytes (got ${params.opened.stat.size})`);
-    }
-    const buffer = await params.opened.handle.readFile();
-    if (params.maxBytes !== undefined && buffer.byteLength > params.maxBytes) {
-        throw new errors_FsSafeError("too-large", `file exceeds limit of ${params.maxBytes} bytes (got ${buffer.byteLength})`);
-    }
-    return {
-        buffer,
-        realPath: params.opened.realPath,
-        stat: params.opened.stat,
-    };
-}
 function emitWriteBoundaryWarning(reason) {
     logWarn(`security: fs-safe write boundary warning (${reason})`);
 }
@@ -2984,82 +3192,9 @@ async function verifyAtomicWriteResult(params) {
         await opened.handle.close().catch(() => { });
     }
 }
-async function resolveOpenedFileRealPathForHandle(handle, ioPath) {
-    const handleStat = await handle.stat();
-    const fdCandidates = process.platform === "linux"
-        ? [`/proc/self/fd/${handle.fd}`, `/dev/fd/${handle.fd}`]
-        : process.platform === "win32"
-            ? []
-            : [`/dev/fd/${handle.fd}`];
-    for (const fdPath of fdCandidates) {
-        try {
-            const fdRealPath = await promises_namespaceObject.realpath(fdPath);
-            const fdRealStat = await promises_namespaceObject.stat(fdRealPath);
-            if (file_identity_sameFileIdentity(handleStat, fdRealStat)) {
-                return fdRealPath;
-            }
-        }
-        catch {
-            // try next fd path
-        }
-    }
-    try {
-        const ioRealPath = await promises_namespaceObject.realpath(ioPath);
-        const ioRealStat = await promises_namespaceObject.stat(ioRealPath);
-        if (file_identity_sameFileIdentity(handleStat, ioRealStat)) {
-            return ioRealPath;
-        }
-    }
-    catch (err) {
-        if (!path_isNotFoundPathError(err)) {
-            throw err;
-        }
-    }
-    const parentResolved = await resolveOpenedFileRealPathFromParent(handleStat, ioPath);
-    if (parentResolved) {
-        return parentResolved;
-    }
-    throw new errors_FsSafeError("path-mismatch", "unable to resolve opened file path");
-}
-async function resolveOpenedFileRealPathFromParent(handleStat, ioPath) {
-    let parentReal;
-    try {
-        parentReal = await promises_namespaceObject.realpath(external_node_path_namespaceObject.dirname(ioPath));
-    }
-    catch (err) {
-        if (path_isNotFoundPathError(err)) {
-            return null;
-        }
-        throw err;
-    }
-    let entries;
-    try {
-        entries = await promises_namespaceObject.readdir(parentReal);
-    }
-    catch (err) {
-        if (path_isNotFoundPathError(err)) {
-            return null;
-        }
-        throw err;
-    }
-    for (const entry of entries.toSorted()) {
-        const candidatePath = external_node_path_namespaceObject.join(parentReal, entry);
-        try {
-            const candidateStat = await promises_namespaceObject.lstat(candidatePath);
-            if (candidateStat.isFile() && file_identity_sameFileIdentity(handleStat, candidateStat)) {
-                return await promises_namespaceObject.realpath(candidatePath);
-            }
-        }
-        catch (err) {
-            if (!path_isNotFoundPathError(err)) {
-                throw err;
-            }
-        }
-    }
-    return null;
-}
 async function openWritableFileInRoot(root, params) {
     const { rootReal, rootWithSep, resolved } = await resolvePathInRoot(root, params.relativePath);
+    await assertMutationNotDenied(resolved, params.denyMutations);
     try {
         await assertNoPathAliasEscape({
             absolutePath: resolved,
@@ -3186,6 +3321,7 @@ async function appendFileInRoot(root, params) {
         relativePath: params.relativePath,
         mkdir: params.mkdir,
         mode: params.mode,
+        denyMutations: params.denyMutations,
         truncateExisting: false,
         append: true,
     });
@@ -3213,8 +3349,8 @@ async function appendFileInRoot(root, params) {
         await target.handle.close().catch(() => { });
     }
 }
-async function removePathInRoot(root, relativePath) {
-    const resolved = await resolvePinnedRemovePathInRoot(root, relativePath);
+async function removePathInRoot(root, params) {
+    const resolved = await resolvePinnedRemovePathInRoot(root, params.relativePath, params.denyMutations);
     if (process.platform === "win32") {
         await removePathFallback(resolved);
         return;
@@ -3262,7 +3398,7 @@ async function writeFileInRoot(root, params) {
         });
         return;
     }
-    const pinned = await resolvePinnedWriteTargetInRoot(root, params.relativePath, params.mode);
+    const pinned = await resolvePinnedWriteTargetInRoot(root, params.relativePath, params.mode, params.denyMutations);
     await serializePathWrite(pinned.targetPath, async () => {
         let identity;
         try {
@@ -3318,7 +3454,7 @@ async function copyFileInRoot(root, params) {
             });
             return;
         }
-        const pinned = await resolvePinnedWriteTargetInRoot(root, params.relativePath, params.mode);
+        const pinned = await resolvePinnedWriteTargetInRoot(root, params.relativePath, params.mode, params.denyMutations);
         await serializePathWrite(pinned.targetPath, async () => {
             let identity;
             try {
@@ -3362,8 +3498,9 @@ async function copyFileInRoot(root, params) {
         await source.handle.close().catch(() => { });
     }
 }
-async function resolvePinnedWriteTargetInRoot(root, relativePath, requestedMode) {
+async function resolvePinnedWriteTargetInRoot(root, relativePath, requestedMode, denyMutations) {
     const { rootReal, rootWithSep, resolved } = await resolvePathInRoot(root, relativePath);
+    await assertMutationNotDenied(resolved, denyMutations);
     try {
         await assertNoPathAliasEscape({
             absolutePath: resolved,
@@ -3420,12 +3557,16 @@ async function resolvePinnedWriteTargetInRoot(root, relativePath, requestedMode)
 async function resolvePinnedPathInRoot(root, params) {
     return await resolvePinnedOperationPathInRoot(root, {
         allowRoot: params.allowRoot,
+        denyMutations: params.denyMutations,
+        protectDenyMutationAncestors: false,
         relativePath: params.relativePath,
         policy: PATH_ALIAS_POLICIES.strict,
     });
 }
-async function resolvePinnedRemovePathInRoot(root, relativePath) {
+async function resolvePinnedRemovePathInRoot(root, relativePath, denyMutations) {
     return await resolvePinnedOperationPathInRoot(root, {
+        denyMutations,
+        protectDenyMutationAncestors: true,
         relativePath,
         policy: PATH_ALIAS_POLICIES.unlinkTarget,
     });
@@ -3437,6 +3578,7 @@ async function resolvePinnedOperationPathInRoot(root, params) {
     });
     const relativeResolved = external_node_path_namespaceObject.relative(resolved.rootReal, resolved.canonicalPath);
     if ((relativeResolved === "" || relativeResolved === ".") && params.allowRoot === true) {
+        await assertMutationNotDenied(resolved.canonicalPath, params.denyMutations);
         return { rootReal: resolved.rootReal, resolved: resolved.canonicalPath, relativePosix: "" };
     }
     const firstSegment = relativeResolved.split(external_node_path_namespaceObject.sep)[0];
@@ -3450,6 +3592,9 @@ async function resolvePinnedOperationPathInRoot(root, params) {
     if (!path_isPathInside(resolved.rootWithSep, resolved.canonicalPath)) {
         throw new errors_FsSafeError("outside-workspace", "file is outside workspace root");
     }
+    await assertMutationNotDenied(resolved.canonicalPath, params.denyMutations, {
+        protectAncestors: params.protectDenyMutationAncestors,
+    });
     return { rootReal: resolved.rootReal, resolved: resolved.canonicalPath, relativePosix };
 }
 async function resolvePinnedRootPathInRoot(root, params) {
@@ -3527,13 +3672,21 @@ async function listPathFallback(root, relativePath, withFileTypes) {
         throw error;
     }
 }
+async function assertMoveMutationAllowed(root, params) {
+    const source = await resolvePathInRoot(root, params.fromRelative);
+    await assertMutationNotDenied(source.resolved, params.denyMutations, { protectAncestors: true });
+    const target = await resolvePathInRoot(root, params.toRelative);
+    await assertMutationNotDenied(target.resolved, params.denyMutations, { protectAncestors: true });
+}
 async function movePathFallback(root, params) {
     const source = await resolvePathInRoot(root, params.fromRelative);
+    await assertMutationNotDenied(source.resolved, params.denyMutations, { protectAncestors: true });
     await resolvePinnedRootPathInRoot(root, {
         relativePath: params.fromRelative,
         policy: PATH_ALIAS_POLICIES.strict,
     });
     const target = await resolvePathInRoot(root, params.toRelative);
+    await assertMutationNotDenied(target.resolved, params.denyMutations, { protectAncestors: true });
     await resolvePinnedRootPathInRoot(root, {
         relativePath: params.toRelative,
         policy: PATH_ALIAS_POLICIES.unlinkTarget,
@@ -3617,6 +3770,7 @@ async function writeFileFallback(root, params) {
         relativePath: params.relativePath,
         mkdir: params.mkdir,
         mode: params.mode,
+        denyMutations: params.denyMutations,
         truncateExisting: false,
     });
     const destinationPath = target.realPath;
@@ -3662,6 +3816,7 @@ async function writeFileFallback(root, params) {
 }
 async function writeMissingFileFallback(root, params) {
     const { rootReal, resolved } = await resolvePathInRoot(root, params.relativePath);
+    await assertMutationNotDenied(resolved, params.denyMutations);
     try {
         await assertNoPathAliasEscape({
             absolutePath: resolved,
@@ -3735,6 +3890,7 @@ async function copyFileFallback(root, params, source) {
             relativePath: params.relativePath,
             mkdir: params.mkdir,
             mode: params.mode,
+            denyMutations: params.denyMutations,
             truncateExisting: false,
         });
         const destinationPath = target.realPath;
@@ -12366,7 +12522,7 @@ async function emitScriptEndEvent(options, deps) {
     const capturedEnv = captureEnv(options.env);
     const tags = captureTags(options.env);
     const event = {
-        v: SCHEMA_VERSION,
+        v: (/* inlined export .SCHEMA_VERSION */1),
         session_id: sessionId,
         event: "script_end",
         command: options.command,
@@ -12395,7 +12551,7 @@ async function emitShimErrorEvent(options, deps) {
     const capturedEnv = captureEnv(options.env);
     const tags = captureTags(options.env);
     const event = {
-        v: SCHEMA_VERSION,
+        v: (/* inlined export .SCHEMA_VERSION */1),
         session_id: sessionId,
         event: "shim_error",
         command: options.command,
@@ -12416,7 +12572,7 @@ async function emitPolicyDecisionEvent(options, deps) {
     const capturedEnv = captureEnv(options.env);
     const tags = captureTags(options.env);
     const event = {
-        v: SCHEMA_VERSION,
+        v: (/* inlined export .SCHEMA_VERSION */1),
         session_id: sessionId,
         event: "policy_decision",
         command: options.command,
@@ -12439,7 +12595,7 @@ async function emitToolUseEvent(options, deps) {
     const capturedEnv = captureEnv(options.env);
     const tags = captureTags(options.env);
     const event = {
-        v: SCHEMA_VERSION,
+        v: (/* inlined export .SCHEMA_VERSION */1),
         session_id: sessionId,
         event: "tool_use",
         tool_name: options.tool_name,
@@ -14896,4 +15052,4 @@ if (installedChunkData !== 0) { // 0 means "already installed".'
 // module factories are used so entry inlining is disabled
 // startup
 // Load entry module and return exports
-var __webpack_exports__ = __webpack_require__(145);
+var __webpack_exports__ = __webpack_require__(341);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lousy-agents/agent-shell",
-    "version": "5.14.10",
+    "version": "5.15.1",
     "description": "A flight recorder for npm script execution",
     "type": "module",
     "repository": {
@@ -36,11 +36,11 @@
         "build": "rspack build --config rspack.config.ts && chmod +x dist/index.js"
     },
     "dependencies": {
-        "@openclaw/fs-safe": "0.2.6",
+        "@openclaw/fs-safe": "0.3.0",
         "zod": "4.4.3"
     },
     "peerDependencies": {
-        "@github/copilot-sdk": "0.3.0"
+        "@github/copilot-sdk": "1.0.0"
     },
     "peerDependenciesMeta": {
         "@github/copilot-sdk": {