@lousy-agents/mcp 5.23.3 → 5.23.4

package/dist/mcp-server.js

@@ -30286,6 +30286,15 @@ function assertWindowsAclRemediationAllowed() {
 
 const runtimePlatform = process.versions.bun ? (0,external_node_os_.platform)() : undefined;
 const bunPosix = runtimePlatform === "darwin" || runtimePlatform === "linux" ? runtimePlatform : undefined;
+function nativeResult(input, result) {
+    if (result.path !== undefined)
+        return result.path;
+    const errno = -(result.errno);
+    const code = (0,external_node_util_.getSystemErrorName)(errno);
+    throw Object.assign(new Error(`${code}: realpath '${input}'`), {
+        code, errno, syscall: "realpath", path: input,
+    });
+}
 function realpath_resolve(input, native) {
     if (native && process.platform === "win32") {
         try {
@@ -30332,14 +30341,7 @@ function realpath_resolve(input, native) {
         const binding = native_getNativeBinding();
         if (binding?.canonicalizePath) {
             // Ordinary resolution normalizes both the input and each expanded symlink.
-            const result = binding.canonicalizePath(input, !native);
-            if (result.path !== undefined)
-                return result.path;
-            const errno = -(result.errno);
-            const code = (0,external_node_util_.getSystemErrorName)(errno);
-            throw Object.assign(new Error(`${code}: realpath '${input}'`), {
-                code, errno, syscall: "realpath", path: input,
-            });
+            return nativeResult(input, binding.canonicalizePath(input, !native));
         }
         if (getFsSafeNativeConfig().mode === "require") {
             throw new errors_FsSafeError("helper-unavailable", "native fs-safe canonicalization is unavailable");
@@ -30352,10 +30354,19 @@ function realpath_resolve(input, native) {
 const realpath_realpathSync = Object.assign((input) => realpath_resolve(input, false), {
     native: (input) => realpath_resolve(input, true),
 });
-/** Async on Node; retain runtime-specific native canonicalization guarantees. */
+/** POSIX async canonicalization retains Bun's native path and record-lock semantics. */
 async function realpath_realpathNative(input) {
-    if (bunPosix)
-        return realpath_realpathSync.native(input);
+    if (bunPosix) {
+        if (input.includes("\0")) {
+            throw Object.assign(new TypeError("realpath input must not contain null bytes"), { code: "ERR_INVALID_ARG_VALUE" });
+        }
+        const binding = native_getNativeBinding();
+        if (binding?.canonicalizePathAsync)
+            return nativeResult(input, await binding.canonicalizePathAsync(input, false));
+        if (binding?.canonicalizePath || getFsSafeNativeConfig().mode === "require") {
+            throw new errors_FsSafeError("helper-unavailable", "native fs-safe canonicalization is unavailable");
+        }
+    }
     try {
         return await promises_.realpath(input);
     }
@@ -30462,6 +30473,7 @@ function assertStatObservationSync(inspect, expected, initial, platform = proces
 
 
 
+
 // Numeric metadata is retained for existing internal consumers; rounded IDs
 // must never become authority for a later comparison.
 const exactGuardIdentities = new WeakMap();
@@ -30569,7 +30581,15 @@ async function createNearestExistingDirectoryGuard(rootReal, targetPath, options
 }
 // Recovery receipts must retain every identity bit, including on Windows.
 async function directory_guard_inspectDirectoryIdentity(dir, expected) {
-    return directory_guard_inspectDirectoryIdentitySync(dir, expected);
+    if (process.platform === "win32")
+        return directory_guard_inspectDirectoryIdentitySync(dir, expected);
+    const operationPath = directoryOperationPath(dir);
+    return strict_file_identity_inspectFileIdentity(async () => {
+        const stat = await promises_.lstat(operationPath, { bigint: true });
+        if (stat.isSymbolicLink() || !stat.isDirectory())
+            throw root_errors_directoryComponentNotDirectoryError();
+        return stat;
+    }, expected);
 }
 function directoryOperationPath(dir) {
     windows_path_alias_assertNoWindowsPathAlias(dir, "filesystem");
@@ -33217,7 +33237,7 @@ async function readBoundedAsync(maxBytes, readChunk, options = {}) {
     let total = 0;
     const { observeRegularFileSize, createLimitError } = options;
     const allocate = options.unpooled ? Buffer.allocUnsafeSlow : undefined;
-    const size = options.initialSize ?? observeRegularFileSize?.();
+    const size = options.initialSize ?? await observeRegularFileSize?.();
     let buffer = size === undefined ? createScratchBuffer(maxBytes, allocate) : createInitialBuffer(maxBytes, size, allocate);
     if (size !== undefined) {
         const bytesRead = await readChunk(buffer, buffer.length);
@@ -33225,7 +33245,7 @@ async function readBoundedAsync(maxBytes, readChunk, options = {}) {
             return finishReadBuffer(buffer, 0, allocate);
         // Short reads can occur before EOF. Only use the size shortcut on this
         // initial read; virtual files can report zero or stale sizes thereafter.
-        const currentSize = bytesRead < buffer.length ? observeRegularFileSize?.() : undefined;
+        const currentSize = bytesRead < buffer.length ? await observeRegularFileSize?.() : undefined;
         total = addReadBytes(total, bytesRead, maxBytes, createLimitError);
         if (currentSize !== undefined && currentSize > 0 && bytesRead >= currentSize)
             return finishReadBuffer(buffer, total, allocate);
@@ -33256,12 +33276,12 @@ function readFileHandleBoundedWithSize(handle, maxBytes, initialSize) {
         return (await handle.read(scratch, 0, length, null)).bytesRead;
     }, {
         initialSize,
-        observeRegularFileSize: fd === undefined ? undefined : () => regularFileSize(fd),
+        observeRegularFileSize: fd === undefined ? undefined : () => regularFileSizeAsync(fd),
     });
 }
 function regularFileSize(fd) {
     try {
-        const stat = external_node_fs_.fstatSync(fd);
+        const stat = fs.fstatSync(fd);
         return stat.isFile() && Number.isSafeInteger(stat.size) && stat.size >= 0
             ? stat.size : undefined;
     }
@@ -33270,6 +33290,17 @@ function regularFileSize(fd) {
         return undefined;
     }
 }
+async function regularFileSizeAsync(fd) {
+    try {
+        const stat = await new Promise((resolve, reject) => {
+            external_node_fs_.fstat(fd, (error, value) => error ? reject(error) : resolve(value));
+        });
+        return stat.isFile() && Number.isSafeInteger(stat.size) && stat.size >= 0 ? stat.size : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function readDescriptorChunk(fd, scratch, length) {
     return new Promise((resolve, reject) => {
         fs.read(fd, scratch, 0, length, null, (error, bytesRead) => {
@@ -33286,7 +33317,7 @@ async function readFileDescriptorBounded(fd, maxBytes) {
     normalizeMaxBytes(maxBytes);
     return await readBoundedAsync(maxBytes, async (scratch, length) => {
         return await readDescriptorChunk(fd, scratch, length);
-    }, { observeRegularFileSize: () => regularFileSize(fd) });
+    }, { observeRegularFileSize: () => regularFileSizeAsync(fd) });
 }
 function readBoundedSync(maxBytes, readChunk, options = {}) {
     byte_budget_normalizeMaxBytes(maxBytes);
@@ -37699,7 +37730,8 @@ function* traverseRootPath(params, { mode = "native", observation: observationOu
     windows_path_alias_assertNoWindowsPathAlias(rootPath);
     windows_path_alias_assertNoWindowsPathAlias(absolutePath);
     windows_path_alias_assertNoWindowsPathAlias(rootCanonicalPath);
-    observeRoot?.(rootCanonicalPath);
+    if (observeRoot)
+        yield* wait(observeRoot(rootCanonicalPath));
     const context = createLexicalTraversalContext(yield* prepareRootTraversal(input, rootPath, rootCanonicalPath, absolutePath, rawAbsolutePath, synchronous));
     const { state } = context;
     const observation = createLexicalTraversalObservation(context, observationOutput?.request);
@@ -37890,6 +37922,8 @@ function assertInsideBoundary(params) {
 
 
 
+
+
 const root_context_ensureTrailingSep = (value) => value.endsWith(external_node_path_.sep) ? value : value + external_node_path_.sep;
 function assertValidRootRelativePath(relativePath) {
     path_assertNoNulPathInput(relativePath, "relative path contains a NUL byte");
@@ -37913,21 +37947,24 @@ async function expandRelativePathWithHome(relativePath) {
     }
     const rawHome = process.env.HOME || process.env.USERPROFILE || external_node_os_.homedir();
     windows_path_alias_assertNoWindowsPathAlias(rawHome, "filesystem", "home path uses a Windows filesystem namespace alias");
-    if (cachedHomePath?.raw !== rawHome) {
+    let home = cachedHomePath?.raw === rawHome ? cachedHomePath.real : undefined;
+    if (home === undefined) {
         let realHome = rawHome;
         try {
-            realHome = realpath_realpathSync.native(windows_path_alias_pathForWindowsFilesystem(rawHome));
+            const homePath = windows_path_alias_pathForWindowsFilesystem(rawHome);
+            realHome = process.platform === "win32" ? realpath_realpathSync.native(homePath) : await realpath_realpathNative(homePath);
         }
         catch {
             // If the home dir cannot be canonicalized, keep lexical expansion behavior.
         }
         cachedHomePath = { raw: rawHome, real: realHome };
+        home = realHome;
     }
     if (homeOnly) {
-        windows_path_alias_assertNoWindowsPathAlias(cachedHomePath.real, "filesystem", "home path uses a Windows filesystem namespace alias");
-        return cachedHomePath.real;
+        windows_path_alias_assertNoWindowsPathAlias(home, "filesystem", "home path uses a Windows filesystem namespace alias");
+        return home;
     }
-    const expanded = `${root_context_ensureTrailingSep(cachedHomePath.real)}${relativePath.slice(2)}`;
+    const expanded = `${root_context_ensureTrailingSep(home)}${relativePath.slice(2)}`;
     windows_path_alias_assertNoWindowsPathAlias(expanded, "filesystem", "expanded path uses a Windows filesystem namespace alias");
     return expanded;
 }
@@ -37940,14 +37977,17 @@ async function resolveRootContext(rootDir) {
     let rootStat;
     let rootIdentity;
     try {
-        rootReal = realpath_realpathSync.native(windows_path_alias_pathForWindowsFilesystem(rootDir));
+        const rootPath = windows_path_alias_pathForWindowsFilesystem(absolutePathWithRawSegments(rootDir));
+        rootReal = process.platform === "win32" ? realpath_realpathSync.native(rootPath) : await realpath_realpathNative(rootPath);
         windows_path_alias_assertNoWindowsPathAlias(rootReal, "filesystem", "canonical root path uses a Windows filesystem namespace alias");
-        rootStat = await strict_file_identity_inspectFileIdentity(() => {
-            const stat = external_node_fs_.statSync(rootReal, { bigint: true });
+        const inspect = (stat) => {
             if (!stat.isDirectory())
                 throw new errors_FsSafeError("invalid-path", "root dir is not a directory");
             return stat;
-        });
+        };
+        rootStat = await strict_file_identity_inspectFileIdentity(() => process.platform === "win32"
+            ? inspect(external_node_fs_.statSync(rootReal, { bigint: true }))
+            : promises_.stat(rootReal, { bigint: true }).then(inspect));
         rootIdentity = { dev: rootStat.dev, ino: rootStat.ino };
     }
     catch (err) {
@@ -38007,7 +38047,15 @@ function root_context_assertRootIdentityCurrentSync(root, observe) {
     }
 }
 async function assertRootIdentityCurrent(root, observe) {
-    root_context_assertRootIdentityCurrentSync(root, observe);
+    if (process.platform === "win32")
+        return root_context_assertRootIdentityCurrentSync(root, observe);
+    try {
+        const stat = await directory_guard_inspectDirectoryIdentity(root.rootReal, { dev: root.rootIdentity.dev, ino: root.rootIdentity.ino });
+        observe?.(stat);
+    }
+    catch (error) {
+        throw rootPathChangedError(error instanceof Error ? error : undefined);
+    }
 }
 /**
  * Observe the current Root with an exact, operation-local receipt.
@@ -45143,7 +45191,8 @@ async function recordPreOpenFileChange(error, handle, filePath, before, opened)
         return;
     try {
         await strict_file_identity_inspectFileIdentity(async () => before);
-        const current = await strict_file_identity_inspectFileIdentity(() => external_node_fs_.fstatSync(handle.fd, { bigint: true }), opened);
+        const current = await strict_file_identity_inspectFileIdentity(() => process.platform === "win32"
+            ? external_node_fs_.fstatSync(handle.fd, { bigint: true }) : handle.stat({ bigint: true }), opened);
         if (current.isFile() && [0n, 1n].includes(current.nlink) &&
             (before.dev !== current.dev || before.ino !== current.ino)) {
             // A stale pathname sample is not proof that its former inode was unlinked.
@@ -45159,7 +45208,8 @@ async function recordOpenedFileFailure(error, handle, filePath, identity) {
         !identity.isFile() || identity.nlink > 1n)
         return;
     try {
-        const current = await strict_file_identity_inspectFileIdentity(() => external_node_fs_.fstatSync(handle.fd, { bigint: true }), identity);
+        const current = await strict_file_identity_inspectFileIdentity(() => process.platform === "win32"
+            ? external_node_fs_.fstatSync(handle.fd, { bigint: true }) : handle.stat({ bigint: true }), identity);
         if (current.isFile() && current.nlink === 0n)
             recordFileObservationFailure(error, `unlinked:${filePath}`);
     }
@@ -45191,8 +45241,7 @@ async function openLocalFileDescriptor(filePath, options) {
     // Reject directories before opening so we never surface EISDIR to callers (e.g. tool
     // results that get sent to messaging channels). See openclaw/openclaw#31186.
     try {
-        preOpenStat = strict_file_identity_inspectFileIdentitySync(() => {
-            const stat = external_node_fs_.lstatSync(filePath, { bigint: true });
+        const inspect = (stat) => {
             observedBeforeOpen = true;
             if (stat.isSymbolicLink() && options?.symlinks !== "follow-within-root") {
                 throw new errors_FsSafeError("symlink", "symlink not allowed");
@@ -45201,7 +45250,10 @@ async function openLocalFileDescriptor(filePath, options) {
                 throw new errors_FsSafeError("not-file", "not a file");
             }
             return stat;
-        });
+        };
+        preOpenStat = process.platform === "win32"
+            ? strict_file_identity_inspectFileIdentitySync(() => inspect(external_node_fs_.lstatSync(filePath, { bigint: true })))
+            : await strict_file_identity_inspectFileIdentity(async () => inspect(await promises_.lstat(filePath, { bigint: true })));
     }
     catch (err) {
         if (err instanceof errors_FsSafeError || observedBeforeOpen) {
@@ -45238,12 +45290,16 @@ async function openLocalFileDescriptor(filePath, options) {
         let openedIdentity;
         let identity;
         try {
-            identity = strict_file_identity_inspectFileIdentitySync(() => {
-                openedIdentity = external_node_fs_.fstatSync(handle.fd, { bigint: true });
-                if (!openedIdentity.isFile())
+            const inspect = (stat) => {
+                openedIdentity = stat;
+                if (!stat.isFile())
                     throw new errors_FsSafeError("not-file", "not a file");
-                return openedIdentity;
-            }, preOpenStat && !preOpenStat.isSymbolicLink() ? preOpenStat : undefined);
+                return stat;
+            };
+            const expected = preOpenStat && !preOpenStat.isSymbolicLink() ? preOpenStat : undefined;
+            identity = process.platform === "win32"
+                ? strict_file_identity_inspectFileIdentitySync(() => inspect(external_node_fs_.fstatSync(handle.fd, { bigint: true })), expected)
+                : await strict_file_identity_inspectFileIdentity(async () => inspect(await handle.stat({ bigint: true })), expected);
         }
         catch (error) {
             if (openedIdentity && [0n, 1n].includes(openedIdentity.nlink)) {
@@ -48144,6 +48200,8 @@ async function movePathNative(root, params, paths, overwrite = false) {
 
 
 
+
+
 function resolveFinalOpenedRealPath(filePath) {
     try {
         return realpath_realpathSync.native(filePath);
@@ -48167,6 +48225,12 @@ function inspectOpenedPathIdentitySync(filePath, symlinks) {
     }
     return stat;
 }
+async function inspectOpenedPathIdentity(filePath, symlinks) {
+    const stat = await (symlinks === "follow-within-root" ? promises_.stat(filePath, { bigint: true }) : promises_.lstat(filePath, { bigint: true }));
+    if (stat.isSymbolicLink() && symlinks !== "follow-within-root")
+        throw new errors_FsSafeError("symlink", "symlink not allowed");
+    return stat;
+}
 async function admitRootReadHandle(params) {
     try {
         if (params.hardlinks !== "allow" && params.opened.stat.nlink > 1) {
@@ -48175,14 +48239,20 @@ async function admitRootReadHandle(params) {
         if (params.beforeFinalFence) {
             await params.beforeFinalFence(params.filePath, params.opened.handle);
         }
-        try {
-            root_context_assertRootIdentityCurrentSync(params.root);
+        function* admit() {
+            const synchronous = process.platform === "win32";
+            if (synchronous)
+                root_context_assertRootIdentityCurrentSync(params.root);
+            else
+                yield* wait(assertRootIdentityCurrent(params.root));
             let realPath;
             try {
-                const current = strict_file_identity_inspectFileIdentitySync(() => inspectOpenedPathIdentitySync(params.filePath, params.symlinks), params.identity);
+                const current = synchronous
+                    ? strict_file_identity_inspectFileIdentitySync(() => inspectOpenedPathIdentitySync(params.filePath, params.symlinks), params.identity)
+                    : yield* wait(strict_file_identity_inspectFileIdentity(() => inspectOpenedPathIdentity(params.filePath, params.symlinks), params.identity));
                 if (params.hardlinks !== "allow" && current.nlink > 1n)
                     throw hardlinkedPathNotAllowedError();
-                const canonicalPath = resolveFinalOpenedRealPath(params.filePath);
+                const canonicalPath = synchronous ? resolveFinalOpenedRealPath(params.filePath) : yield* wait(realpath_realpathNative(params.filePath));
                 windows_path_alias_assertNoWindowsPathAlias(canonicalPath, "filesystem", "resolved file path uses a Windows filesystem namespace alias");
                 const admittedRealPath = root_boundary_admitPathInsideRoot({
                     rootPath: params.root.rootReal,
@@ -48194,7 +48264,9 @@ async function admitRootReadHandle(params) {
                 }
                 // This is a fresh no-follow observation even when canonicalPath and
                 // filePath have the same spelling; realpath may have raced a replacement.
-                const canonical = strict_file_identity_inspectFileIdentitySync(() => inspectOpenedPathIdentitySync(canonicalPath, undefined), params.identity);
+                const canonical = synchronous
+                    ? strict_file_identity_inspectFileIdentitySync(() => inspectOpenedPathIdentitySync(canonicalPath, undefined), params.identity)
+                    : yield* wait(strict_file_identity_inspectFileIdentity(() => inspectOpenedPathIdentity(canonicalPath), params.identity));
                 if (params.hardlinks !== "allow" && canonical.nlink > 1n)
                     throw hardlinkedPathNotAllowedError();
                 realPath = admittedRealPath.path;
@@ -48205,9 +48277,15 @@ async function admitRootReadHandle(params) {
                     : error;
             }
             params.afterPathIdentityCheck?.(params.filePath, params.opened.handle);
-            root_context_assertRootIdentityCurrentSync(params.root);
+            if (synchronous)
+                root_context_assertRootIdentityCurrentSync(params.root);
+            else
+                yield* wait(assertRootIdentityCurrent(params.root));
             return { ...params.opened, realPath };
         }
+        try {
+            return process.platform === "win32" ? atomic_io_runSync(admit()) : await runAsync(admit());
+        }
         catch (error) {
             if (params.identity.nlink <= 1n) {
                 await recordOpenedFileFailure(error, params.opened.handle, params.filePath, params.identity);

package/package.json

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