@lousy-agents/mcp 5.22.6 → 5.22.8

package/dist/mcp-server.js

@@ -37580,12 +37580,23 @@ function parseMode(value) {
 function configureFsSafeNative(config) {
     overrideConfig = { ...overrideConfig, ...config };
 }
+function rejectLegacyMode() {
+    for (const source of ["FS_SAFE_PYTHON_MODE", "OPENCLAW_FS_SAFE_PYTHON_MODE"]) {
+        if (process.env[source] === undefined)
+            continue;
+        const mode = parseMode(process.env[source]) ?? "auto";
+        throw new Error(`${source} has been removed. Set FS_SAFE_NATIVE_MODE=${mode} or ` +
+            `configureFsSafeNative({ mode: "${mode}" }) before using fs-safe, then remove ${source}. ` +
+            "Legacy mode settings no longer select native policy.");
+    }
+    return "auto";
+}
 function getFsSafeNativeConfig() {
     return {
         mode: overrideConfig.mode ??
             parseMode(process.env.FS_SAFE_NATIVE_MODE) ??
             parseMode(process.env.OPENCLAW_FS_SAFE_NATIVE_MODE) ??
-            "auto",
+            rejectLegacyMode(),
     };
 }
 /** Internal provenance; keep the public configuration shape unchanged. */
@@ -37597,13 +37608,13 @@ function getNativeModeSetting() {
         if (mode !== undefined)
             return { mode, source };
     }
-    return { mode: "auto", source: "default" };
+    return { mode: rejectLegacyMode(), source: "default" };
 }
 function isFsSafeNativeRequired() {
     return (overrideConfig.mode ??
         parseMode(process.env.FS_SAFE_NATIVE_MODE) ??
         parseMode(process.env.OPENCLAW_FS_SAFE_NATIVE_MODE) ??
-        "auto") === "require";
+        rejectLegacyMode()) === "require";
 }
 function __resetFsSafeNativeConfigForTest() {
     overrideConfig = {};
@@ -42445,14 +42456,15 @@ function pathExistsSync(targetPath) {
 function resolvePathViaExistingAncestorSync(targetPath) {
     return resolveExistingAncestor(targetPath, "ordinary");
 }
-function resolveExistingAncestor(targetPath, mode) {
-    const exists = mode === "native" ? root_path_existing_pathExists : pathExistsSync;
-    const canonicalize = mode === "native" ? realpath_realpathSync.native : realpath_realpathSync;
+function resolveExistingAncestor(targetPath, mode, preserveRawSegments = false, remainingHops = 64) {
+    const exists = mode === "native" || preserveRawSegments ? root_path_existing_pathExists : pathExistsSync;
+    const canonicalize = realpath_realpathSync.native;
     windows_path_alias_assertNoWindowsPathAlias(targetPath);
     const normalized = windows_path_alias_resolvePathPreservingWindowsRoot(targetPath);
     windows_path_alias_assertNoWindowsPathAlias(normalized);
-    let cursor = normalized;
-    const filesystemRoot = external_node_path_.parse(normalized).root;
+    const candidate = preserveRawSegments ? absolutePathWithRawSegments(targetPath) : normalized;
+    let cursor = candidate;
+    const filesystemRoot = external_node_path_.parse(candidate).root;
     while (cursor !== filesystemRoot &&
         !exists(cursor)) {
         cursor = external_node_path_.dirname(cursor);
@@ -42464,22 +42476,30 @@ function resolveExistingAncestor(targetPath, mode) {
     try {
         rawResolvedAncestor = canonicalize(windows_path_alias_pathForWindowsFilesystem(cursor));
     }
-    catch {
-        return normalized;
+    catch (error) {
+        if (!preserveRawSegments)
+            return normalized;
+        if (!path_isNotFoundPathError(error))
+            throw error;
+        rawResolvedAncestor = resolveSymlinkHopPath(cursor, mode, false, remainingHops);
     }
     windows_path_alias_assertNoWindowsPathAlias(rawResolvedAncestor);
     const resolvedAncestor = windows_path_alias_resolvePathPreservingWindowsRoot(rawResolvedAncestor);
     windows_path_alias_assertNoWindowsPathAlias(resolvedAncestor);
     // Keep a leading suffix separator relative to the canonical ancestor.
-    const resolved = cursor === normalized
+    const suffix = candidate.slice(cursor.length);
+    if (preserveRawSegments && suffix.split(external_node_path_.sep).includes("..")) {
+        throw new errors_FsSafeError("symlink", "symlink target has an unresolved parent component");
+    }
+    const resolved = cursor === candidate
         ? resolvedAncestor
-        : external_node_path_.resolve(resolvedAncestor, `.${external_node_path_.sep}${normalized.slice(cursor.length)}`);
+        : external_node_path_.resolve(resolvedAncestor, `.${external_node_path_.sep}${suffix}`);
     windows_path_alias_assertNoWindowsPathAlias(resolved);
     return resolved;
 }
-function resolveSymlinkHopPath(symlinkPath, mode, rejectUnresolved) {
+function resolveSymlinkHopPath(symlinkPath, mode, rejectUnresolved, remainingHops = 64) {
     try {
-        const canonicalize = mode === "native" ? realpath_realpathSync.native : realpath_realpathSync;
+        const canonicalize = realpath_realpathSync.native;
         const rawRealPath = canonicalize(symlinkPath);
         windows_path_alias_assertNoWindowsPathAlias(rawRealPath, "filesystem", "resolved symlink path uses a Windows filesystem namespace alias");
         const realPath = windows_path_alias_resolvePathPreservingWindowsRoot(rawRealPath);
@@ -42492,11 +42512,16 @@ function resolveSymlinkHopPath(symlinkPath, mode, rejectUnresolved) {
         }
         if (!path_isNotFoundPathError(error))
             throw error;
+        if (remainingHops <= 0)
+            throw new errors_FsSafeError("symlink", "too many unresolved symlink hops");
         const linkTarget = external_node_fs_.readlinkSync(symlinkPath);
         windows_path_alias_assertNoWindowsPathAlias(linkTarget, "filesystem", "symlink target uses a Windows filesystem namespace alias");
         const linkDir = windows_path_alias_resolvePathPreservingWindowsRoot(external_node_path_.dirname(symlinkPath));
-        const targetPath = windows_path_alias_resolvePathFromBasePreservingWindowsRoot(linkDir, linkTarget);
-        const resolved = resolveExistingAncestor(targetPath, mode);
+        // Keep parent segments until the kernel has resolved the existing prefix.
+        const targetPath = external_node_path_.isAbsolute(linkTarget) ? linkTarget
+            : external_node_path_.parse(linkTarget).root ? windows_path_alias_resolvePathFromBasePreservingWindowsRoot(linkDir, linkTarget)
+                : `${linkDir}${external_node_path_.sep}${linkTarget}`;
+        const resolved = resolveExistingAncestor(targetPath, mode, true, remainingHops - 1);
         windows_path_alias_assertNoWindowsPathAlias(resolved, "filesystem", "resolved symlink path uses a Windows filesystem namespace alias");
         return resolved;
     }
@@ -46485,8 +46510,8 @@ function assertResolvedLinkDirectory(pathname, isLast) {
     const stat = external_node_fs_.statSync(windows_path_alias_pathForWindowsFilesystem(pathname));
     assertDirectoryBeforeMoreSegments(stat, pathname, isLast);
 }
-// Both public APIs use synchronous metadata; only canonicalization and ancestor
-// existence differ. Promise wrappers preserve the asynchronous rejection API.
+// Both public APIs use kernel canonicalization and synchronous metadata; only
+// ancestor existence differs. Promise wrappers preserve asynchronous rejection.
 function traverseRootPath(params, { mode = "native", observation: observationOutput, observeRoot, removalReceipts }) {
     const input = captureValidRootPathInputs(params);
     const rawAbsolutePath = absolutePathWithRawSegments(input.absolutePath);
@@ -54476,7 +54501,7 @@ function directoryChangedError(error) {
         return error;
     return new errors_FsSafeError("path-mismatch", "directory changed during operation", errorCauseOptions(error));
 }
-async function assertRootDirectoryObservationGuard(root, guard) {
+async function assertRootDirectoryObservationGuard(root, guard, backend) {
     if (isNativeDirectoryObservationGuard(guard)) {
         throw new errors_FsSafeError("path-mismatch", "native directory observation cannot be revalidated");
     }
@@ -54485,7 +54510,9 @@ async function assertRootDirectoryObservationGuard(root, guard) {
         identity.dev === root.rootIdentity.dev && identity.ino === root.rootIdentity.ino;
     if (guardPinsRoot) {
         try {
-            if ("identity" in guard)
+            if (backend && "identity" in guard)
+                assertReceiptDirectoryGuardSync(root, guard, backend);
+            else if ("identity" in guard)
                 assertDirectoryObservationGuardSync(guard);
             else
                 await assertAsyncDirectoryGuard(guard);
@@ -54508,7 +54535,9 @@ async function assertRootDirectoryObservationGuard(root, guard) {
         await assertRootIdentityCurrent(root);
     }
     try {
-        if ("identity" in guard)
+        if (backend && "identity" in guard)
+            assertReceiptDirectoryGuardSync(root, guard, backend);
+        else if ("identity" in guard)
             assertDirectoryObservationGuardSync(guard);
         else
             await assertAsyncDirectoryGuard(guard);
@@ -54662,12 +54691,15 @@ async function openRootDirectoryListing(root, directory, options, receipt) {
             identity: { dev: admitted.stat.dev, ino: admitted.stat.ino },
         }, admitted.dir, admitted.realPath);
     }
+    // Windows watch listings keep every fence while sharing one handle for its
+    // identity/path queries. POSIX pathname checks are cheaper than this helper.
+    const backend = getNativeDirectoryObservationBackend(options.exactIdentity === true && process.platform === "win32");
     const assertCurrent = async () => {
         options.signal?.throwIfAborted();
         if (receipt)
             assertRootPathObservationReceiptCurrent(root, receipt);
         else
-            await assertRootDirectoryObservationGuard(root, guard);
+            await assertRootDirectoryObservationGuard(root, guard, backend);
         options.signal?.throwIfAborted();
     };
     const paths = { directory: guard.realPath, names: new Map() };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lousy-agents/mcp",
-    "version": "5.22.6",
+    "version": "5.22.8",
     "description": "MCP server for lousy-agents - provides AI coding assistant tools via the Model Context Protocol",
     "type": "module",
     "repository": {