@lousy-agents/mcp 5.22.15 → 5.22.16

package/dist/mcp-server.js

@@ -6559,7 +6559,7 @@ function escapeJsonPtr(str) {
 
 
 },
-8363(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
+9324(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
 // NAMESPACE OBJECT: ../../node_modules/micromark/lib/constructs.js
 var constructs_namespaceObject = {};
 __webpack_require__.r(constructs_namespaceObject);
@@ -53723,8 +53723,8 @@ function pinnedWriteModeAssertion(fd, mode, assertBeforeMutation, privateCreatio
 
 
 // Node has no portable no-replace rename. Publish the completed stage by link,
-// then remove its verified temporary name without yielding.
-function publishCopyStage(params) {
+// then remove its verified temporary name after any descriptor handoff.
+async function publishCopyStage(params) {
     const { identity, temporaryPath, targetPath } = params;
     const assertCurrent = () => {
         directory_guard_assertSyncDirectoryGuard(params.parentGuard);
@@ -53778,13 +53778,23 @@ function publishCopyStage(params) {
             }
         }
         else {
-            const parent = external_node_fs_.lstatSync(external_node_path_.dirname(temporaryPath), { bigint: true });
-            const current = external_node_fs_.lstatSync(temporaryPath, { bigint: true });
-            if (parent.isSymbolicLink() || !parent.isDirectory() ||
-                !file_identity_sameFileIdentityForCleanup(parent, params.parentGuard.stat) ||
-                current.isSymbolicLink() || !current.isFile() ||
-                !file_identity_sameFileIdentityForCleanup(current, identity)) {
-                throw new errors_FsSafeError("path-mismatch", "published copy temporary name changed before cleanup");
+            const verifyPair = () => {
+                directory_guard_assertSyncDirectoryGuard(params.parentGuard);
+                const parent = external_node_fs_.lstatSync(external_node_path_.dirname(temporaryPath), { bigint: true });
+                const current = external_node_fs_.lstatSync(temporaryPath, { bigint: true });
+                const target = external_node_fs_.lstatSync(targetPath, { bigint: true });
+                if (parent.isSymbolicLink() || !parent.isDirectory() ||
+                    !file_identity_sameFileIdentityForCleanup(parent, params.parentGuard.stat) ||
+                    current.isSymbolicLink() || !current.isFile() || current.nlink !== 2n ||
+                    target.isSymbolicLink() || !target.isFile() || target.nlink !== 2n ||
+                    !file_identity_sameFileIdentityForCleanup(current, identity) || !file_identity_sameFileIdentityForCleanup(target, identity)) {
+                    throw new errors_FsSafeError("path-mismatch", "published copy temporary name changed before cleanup");
+                }
+            };
+            verifyPair();
+            if (params.beforeTemporaryUnlink) {
+                await params.beforeTemporaryUnlink();
+                verifyPair();
             }
             // This removes the stage's name, never the published destination or source.
             external_node_fs_.unlinkSync(temporaryPath);
@@ -53857,6 +53867,40 @@ function publishThroughPlaceholder(params, assertCurrent) {
     }
 }
 
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/publication-handle.js
+
+
+
+
+
+
+/** Pin the published name before releasing a descriptor opened through its stage. */
+async function openPublicationHandle(targetPath, identity) {
+    const flags = read_open_flags_resolveReadOpenFlags();
+    const handle = await promises_.open(targetPath, flags).catch(async (error) => {
+        // Restrictive final modes must not be widened just to inspect publication.
+        if (!hasErrorCode(error, "EACCES") || (process.arch !== "x64" && process.arch !== "arm64"))
+            throw error;
+        const metadataFlag = process.platform === "linux" ? 0x200000 : undefined; // O_PATH
+        if (metadataFlag === undefined)
+            throw error;
+        return promises_.open(targetPath, metadataFlag | external_node_fs_.constants.O_NOFOLLOW);
+    });
+    try {
+        const opened = external_node_fs_.fstatSync(handle.fd, { bigint: true });
+        const named = external_node_fs_.lstatSync(targetPath, { bigint: true });
+        if (!opened.isFile() || !named.isFile() || named.isSymbolicLink() ||
+            !file_identity_sameFileIdentityForCleanup(opened, identity) || !file_identity_sameFileIdentityForCleanup(named, identity)) {
+            throw new errors_FsSafeError("path-mismatch", "publication descriptor handoff identity changed");
+        }
+        return handle;
+    }
+    catch (error) {
+        await handle.close().catch(() => undefined);
+        throw error;
+    }
+}
+
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/pinned-write-staged.js
 
 
@@ -53878,6 +53922,7 @@ function publishThroughPlaceholder(params, assertCurrent) {
 
 
 
+
 
 
 async function runPinnedStagedWrite(params, parentPath, parentGuard) {
@@ -53895,6 +53940,7 @@ async function runPinnedStagedWrite(params, parentPath, parentGuard) {
     let handle;
     let tempIdentity;
     let readHandle;
+    let handoffCloseFailure;
     let renamed = false;
     const completeCreate = params.overwrite === false && params.input.kind !== "file" && params.input.stageBeforePublish === true;
     let receipt;
@@ -53949,11 +53995,15 @@ async function runPinnedStagedWrite(params, parentPath, parentGuard) {
             }), external_node_path_.basename(tempPath), external_node_fs_.fstatSync(handle.fd, { bigint: true }));
         }
         let verifiedIdentity = expectedTempStat;
+        // Keep unreadable modes supported where Node has no read-free file open.
+        const canHandoff = process.platform !== "win32" &&
+            ((params.mode & 0o400) !== 0 ||
+                (process.platform === "linux" && (process.arch === "x64" || process.arch === "arm64")));
         phase = "publish";
         await withAsyncDirectoryGuards([parentGuard], async () => {
             assertFinalSymlinkRejected(targetPath, params.rejectFinalSymlink);
             if (params.overwrite === false) {
-                publishCopyStage({
+                await publishCopyStage({
                     temporaryPath: tempPath, targetPath, fd: handle.fd,
                     identity: tempIdentity, parentGuard,
                     assertBeforeMutation,
@@ -53967,6 +54017,18 @@ async function runPinnedStagedWrite(params, parentPath, parentGuard) {
                             publication = Object.freeze({ status: "published", staged: receipt, basename: params.basename, overwrite: false });
                         params.onPublished?.(identity);
                     },
+                    beforeTemporaryUnlink: !canHandoff ? undefined : async () => {
+                        readHandle = await openPublicationHandle(targetPath, expectedTempStat);
+                        // Keep the destination pinned while closing the stage's NFS dentry.
+                        const stagedHandle = handle;
+                        handle = undefined;
+                        try {
+                            await stagedHandle.close();
+                        }
+                        catch (error) {
+                            handoffCloseFailure = { error };
+                        }
+                    },
                 });
             }
             else {
@@ -53994,6 +54056,7 @@ async function runPinnedStagedWrite(params, parentPath, parentGuard) {
                     throw new errors_FsSafeError("path-mismatch", "fallback target changed during write");
                 }
                 const expectedHash = sha256Hex(params.input.data, params.input.encoding);
+                await readHandle?.close();
                 readHandle = await promises_.open(targetPath, read_open_flags_resolveReadOpenFlags());
                 const readHandleStat = external_node_fs_.fstatSync(readHandle.fd, { bigint: true });
                 const actualHash = sha256Hex(await readFileHandleBounded(readHandle, Infinity));
@@ -54032,7 +54095,11 @@ async function runPinnedStagedWrite(params, parentPath, parentGuard) {
                         pathname: tempPath, handle, identity: tempIdentity, parentGuard, throwOnCleanupError: true,
                     }) : "not-needed";
                 },
-                close: [async () => { await readHandle?.close(); }, async () => { await handle?.close(); }],
+                close: [async () => { await readHandle?.close(); }, async () => {
+                        await handle?.close();
+                        if (handoffCloseFailure)
+                            throw handoffCloseFailure.error;
+                    }],
             });
         }
         else
@@ -109911,4 +109978,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__(8363);
+var __webpack_exports__ = __webpack_require__(9324);

package/package.json

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