@lousy-agents/mcp 5.22.21 → 5.22.23

package/dist/mcp-server.js

@@ -39157,7 +39157,7 @@ function sameCleanupStatValue(left, right) {
         return false;
     return sameStatValue(left, right);
 }
-function file_identity_sameFileIdentityForCleanup(left, right, platform = process.platform) {
+function sameFileIdentityForCleanup(left, right, platform = process.platform) {
     if (platform !== "win32") {
         return sameCleanupStatValue(left.dev, right.dev) && sameCleanupStatValue(left.ino, right.ino);
     }
@@ -41145,19 +41145,32 @@ async function serializePathWrite(key, run) {
 
 function assertOwnedDirectory(expected, actual) {
     if (actual.isSymbolicLink() || !actual.isDirectory()) {
-        throw new FsSafeError("not-file", "directory mode target must be a real directory");
+        throw new errors_FsSafeError("not-file", "directory mode target must be a real directory");
     }
     if (!sameFileIdentityForCleanup(expected, actual)) {
-        throw new FsSafeError("path-mismatch", "directory changed before its mode could be applied");
+        throw new errors_FsSafeError("path-mismatch", "directory changed before its mode could be applied");
+    }
+}
+/** The caller retains a verified native mkdir receipt and owns the descriptor lifetime. */
+function finalizeCreatedDirectoryModeSync(child, mode) {
+    if (mode === undefined || !child.created || process.platform === "win32")
+        return;
+    const expected = strict_file_identity_inspectFileIdentitySync(() => external_node_fs_.fstatSync(child.fd, { bigint: true }));
+    assertOwnedDirectory(expected, expected);
+    external_node_fs_.fchmodSync(child.fd, mode & 0o7777);
+    const finalized = strict_file_identity_inspectFileIdentitySync(() => external_node_fs_.fstatSync(child.fd, { bigint: true }), expected);
+    assertOwnedDirectory(expected, finalized);
+    if ((finalized.mode & 4095n) !== BigInt(mode & 0o7777)) {
+        throw new errors_FsSafeError("path-mismatch", "created directory mode could not be finalized");
     }
 }
 /** Serializes use and close: even a queued path-based fd operation retains its descriptor. */
-function directory_mode_node_ownDirectoryMode(params) {
+function ownDirectoryMode(params) {
     let pending = Promise.resolve();
     let closing;
     const enqueue = (run) => {
         if (closing)
-            return Promise.reject(new FsSafeError("path-mismatch", "directory mode owner is closed"));
+            return Promise.reject(new errors_FsSafeError("path-mismatch", "directory mode owner is closed"));
         const operation = pending.then(run);
         pending = operation.catch(() => undefined);
         return operation;
@@ -41210,7 +41223,7 @@ function directory_mode_node_ownDirectoryMode(params) {
                 throw dispatchDeadlineFailure.error;
             checks.check?.();
             if (!params.ignoreChmodError && finalMode !== mode) {
-                throw new FsSafeError("path-mismatch", "directory final mode could not be verified");
+                throw new errors_FsSafeError("path-mismatch", "directory final mode could not be verified");
             }
         }),
         close() {
@@ -41258,7 +41271,7 @@ async function pinNodeDirectoryForMode(dirPath, options = {}) {
     assertOwner(expected);
     if (process.platform === "win32") {
         // POSIX mode enforcement is unsupported; retain strict path identity checks.
-        return directory_mode_node_ownDirectoryMode({
+        return ownDirectoryMode({
             inspect: async () => { assertOwner(await inspectDirectoryIdentity(dirPath, expected)); return 0; },
             chmod: async () => undefined, close: async () => undefined, ignoreChmodError: true,
         });
@@ -41305,7 +41318,7 @@ async function pinNodeDirectoryForMode(dirPath, options = {}) {
             assertOwner(followed);
         };
         const observeCanonical = observer;
-        const owner = directory_mode_node_ownDirectoryMode({
+        const owner = ownDirectoryMode({
             inspect,
             inspectCanonical: observeCanonical ? () => {
                 const observed = observeCanonical();
@@ -42486,7 +42499,7 @@ function creation_boundary_assertPrivateCreationFile(stat, fd) {
     assertDarwinCreationAcl(fd);
 }
 function assertRecordedFile(current, identity) {
-    if (!current.isFile() || current.isSymbolicLink() || !file_identity_sameFileIdentityForCleanup(current, identity)) {
+    if (!current.isFile() || current.isSymbolicLink() || !sameFileIdentityForCleanup(current, identity)) {
         throw new errors_FsSafeError("path-mismatch", "created file cleanup preserved a replacement");
     }
 }
@@ -43266,7 +43279,7 @@ function exclusive_create_assertExclusiveCreateLeaf(pathname) {
 
 
 
-function* atomic_io_wait(value) {
+function* wait(value) {
     return (yield value);
 }
 async function runAsync(procedure) {
@@ -43291,7 +43304,7 @@ function runSync(procedure) {
         step = procedure.next(step.value);
     return step.value;
 }
-function atomic_io_inspectAtomicIdentity(io, read, expected, synchronous = false, admit) {
+function inspectAtomicIdentity(io, read, expected, synchronous = false, admit) {
     if (io.asynchronous && !synchronous) {
         const inspect = admit ? async () => {
             const stat = await read();
@@ -43343,7 +43356,7 @@ class AtomicIo {
             }
         }
         const resource = this.asyncFs
-            ? yield* atomic_io_wait(withMode
+            ? yield* wait(withMode
                 ? this.asyncFs.open(pathname, flags, mode)
                 : this.asyncFs.open(pathname, flags))
             : withMode
@@ -43356,7 +43369,7 @@ class AtomicIo {
             return this.syncFs.lstatSync(pathname);
         if (this.asyncFs === promises_)
             return external_node_fs_.lstatSync(pathname);
-        return yield* atomic_io_wait(this.asyncFs.lstat(pathname));
+        return yield* wait(this.asyncFs.lstat(pathname));
     }
     lstatExact(pathname, synchronousBuiltin = true) {
         if (!this.asyncFs)
@@ -43368,34 +43381,40 @@ class AtomicIo {
     *mkdir(directory, mode) {
         if (this.asyncFs) {
             const pathname = this.asyncFs === promises_ ? recursiveMkdirPath(directory) : directory;
-            yield* atomic_io_wait(this.asyncFs.mkdir(pathname, { recursive: true, mode }));
+            yield* wait(this.asyncFs.mkdir(pathname, { recursive: true, mode }));
         }
         else {
             const pathname = this.syncFs === external_node_fs_ ? recursiveMkdirPath(directory) : directory;
             this.syncFs.mkdirSync(pathname, { recursive: true, mode });
         }
     }
+    *mkdirExclusive(directory, mode) {
+        if (this.asyncFs)
+            yield* wait(this.asyncFs.mkdir(directory, { recursive: false, mode }));
+        else
+            this.syncFs.mkdirSync(directory, { recursive: false, mode });
+    }
     *rename(source, destination) {
         if (this.asyncFs)
-            yield* atomic_io_wait(this.asyncFs.rename(source, destination));
+            yield* wait(this.asyncFs.rename(source, destination));
         else
             this.syncFs.renameSync(source, destination);
     }
     *remove(pathname) {
         if (this.asyncFs)
-            yield* atomic_io_wait(this.asyncFs.rm(pathname, { force: true }));
+            yield* wait(this.asyncFs.rm(pathname, { force: true }));
         else
             this.syncFs.rmSync(pathname, { force: true });
     }
     *unlink(pathname) {
         if (this.asyncFs)
-            yield* atomic_io_wait(this.asyncFs.unlink(pathname));
+            yield* wait(this.asyncFs.unlink(pathname));
         else
             this.syncFs.unlinkSync(pathname);
     }
     *delay(milliseconds) {
         if (this.asynchronous)
-            yield* atomic_io_wait(sleep(milliseconds));
+            yield* wait(sleep(milliseconds));
         else
             sleepSync(milliseconds);
     }
@@ -43415,7 +43434,7 @@ class AtomicFile {
             return this.io.syncFs.fstatSync(this.resource);
         if (this.io.asyncFs === promises_)
             return external_node_fs_.fstatSync(this.resource.fd);
-        return yield* atomic_io_wait(this.resource.stat());
+        return yield* wait(this.resource.stat());
     }
     statExact() {
         if (typeof this.resource === "number")
@@ -43434,7 +43453,7 @@ class AtomicFile {
         if (typeof this.resource === "number")
             this.io.syncFs.fsyncSync(this.resource);
         else
-            yield* atomic_io_wait(this.resource.sync());
+            yield* wait(this.resource.sync());
     }
     *syncBestEffort() {
         try {
@@ -43467,7 +43486,7 @@ class AtomicFile {
     }
     *readFile(sizeHint) {
         if (typeof this.resource !== "number")
-            return yield* atomic_io_wait(readFileHandleBounded(this.resource, Infinity));
+            return yield* wait(readFileHandleBounded(this.resource, Infinity));
         if (sizeHint === undefined)
             return this.io.syncFs.readFileSync(this.resource);
         const fd = this.resource;
@@ -43497,7 +43516,7 @@ class AtomicFile {
         if (typeof this.resource === "number")
             this.io.syncFs.ftruncateSync(this.resource, length);
         else
-            yield* atomic_io_wait(this.resource.truncate(length));
+            yield* wait(this.resource.truncate(length));
     }
 }
 
@@ -43532,14 +43551,14 @@ function* replace_file_descriptor_syncDirectoryBestEffort(io, dirPath) {
     }
 }
 function replace_file_descriptor_directoryOpenFlags() {
-    return (syncFs.constants.O_RDONLY |
-        syncFs.constants.O_DIRECTORY |
-        syncFs.constants.O_NOFOLLOW |
-        syncFs.constants.O_NONBLOCK);
+    return (external_node_fs_.constants.O_RDONLY |
+        external_node_fs_.constants.O_DIRECTORY |
+        external_node_fs_.constants.O_NOFOLLOW |
+        external_node_fs_.constants.O_NONBLOCK);
 }
 function assertDirectory(identity, dirPath) {
     if (identity.isSymbolicLink() || !identity.isDirectory()) {
-        throw new FsSafeError("not-file", `Atomic replace parent must be a real directory: ${dirPath}`);
+        throw new errors_FsSafeError("not-file", `Atomic replace parent must be a real directory: ${dirPath}`);
     }
     return identity;
 }
@@ -43550,16 +43569,16 @@ async function pinDirectoryForMode(params) {
     if (process.platform === "win32") {
         return;
     }
-    const expected = params.fsModule === fs
-        ? inspectFileIdentitySync(() => assertDirectory(syncFs.lstatSync(params.dirPath, { bigint: true }), params.dirPath))
-        : await inspectFileIdentity(async () => assertDirectory(await params.fsModule.lstat(params.dirPath, { bigint: true }), params.dirPath));
+    const expected = params.expectedIdentity ?? (params.fsModule === promises_
+        ? strict_file_identity_inspectFileIdentitySync(() => assertDirectory(external_node_fs_.lstatSync(params.dirPath, { bigint: true }), params.dirPath))
+        : await strict_file_identity_inspectFileIdentity(async () => assertDirectory(await params.fsModule.lstat(params.dirPath, { bigint: true }), params.dirPath)));
     const handle = await params.fsModule.open(params.dirPath, replace_file_descriptor_directoryOpenFlags());
     try {
         const owner = ownDirectoryMode({
             async inspect() {
-                const opened = params.fsModule === fs
-                    ? inspectFileIdentitySync(() => assertDirectory(syncFs.fstatSync(handle.fd, { bigint: true }), params.dirPath), expected)
-                    : await inspectFileIdentity(async () => assertDirectory(await handle.stat({ bigint: true }), params.dirPath), expected);
+                const opened = params.fsModule === promises_
+                    ? strict_file_identity_inspectFileIdentitySync(() => assertDirectory(external_node_fs_.fstatSync(handle.fd, { bigint: true }), params.dirPath), expected)
+                    : await strict_file_identity_inspectFileIdentity(async () => assertDirectory(await handle.stat({ bigint: true }), params.dirPath), expected);
                 return Number(opened.mode & 4095n);
             },
             chmod: (mode) => {
@@ -43590,7 +43609,7 @@ function* applyDirectoryMode(io, params) {
         }));
         let primary;
         try {
-            if (owner)
+            if (owner && params.mode !== "preserve")
                 yield* wait(owner.apply(params.mode));
         }
         catch (error) {
@@ -43611,13 +43630,15 @@ function* applyDirectoryMode(io, params) {
     if (process.platform === "win32")
         return;
     const admit = (stat) => assertDirectory(stat, params.dirPath);
-    const expected = inspectAtomicIdentity(io, () => io.lstatExact(params.dirPath), undefined, false, admit);
+    const expected = params.expectedIdentity ?? inspectAtomicIdentity(io, () => io.lstatExact(params.dirPath), undefined, false, admit);
     const file = yield* io.open(params.dirPath, replace_file_descriptor_directoryOpenFlags());
     let primary;
     try {
         inspectAtomicIdentity(io, () => file.statExact(), expected, false, admit);
-        params.mutation?.assert();
-        file.chmod(params.mode & 0o7777);
+        if (params.mode !== "preserve") {
+            params.mutation?.assert();
+            file.chmod(params.mode & 0o7777);
+        }
     }
     catch (error) {
         primary = { error };
@@ -43636,7 +43657,7 @@ function* writeTempFile(io, params) {
     params.mutation?.assert();
     const file = yield* io.open(params.tempPath, "wx", params.mode);
     try {
-        const openedInspection = atomic_io_inspectAtomicIdentity(io, () => file.statExact());
+        const openedInspection = inspectAtomicIdentity(io, () => file.statExact());
         const identity = (io.asynchronous ? (yield openedInspection) : openedInspection);
         params.onIdentity?.(identity);
         params.mutation?.assert();
@@ -43645,7 +43666,7 @@ function* writeTempFile(io, params) {
             yield writing;
         if ((io.asyncFs === promises_ || (process.platform === "win32" && io.syncFs === external_node_fs_)) && !params.sync) {
             // Matching non-durable writes have no I/O left after this identity fence.
-            const current = atomic_io_inspectAtomicIdentity(io, () => file.statExact(), identity, true);
+            const current = inspectAtomicIdentity(io, () => file.statExact(), identity, true);
             const modeMask = process.platform === "win32" ? 0o200 : 0o7777;
             if (Number(current.mode & BigInt(modeMask)) === (params.mode & modeMask))
                 return { file, identity };
@@ -43655,7 +43676,7 @@ function* writeTempFile(io, params) {
             yield chmod;
         if (params.sync)
             yield* file.syncBestEffort();
-        const currentInspection = atomic_io_inspectAtomicIdentity(io, () => file.statExact(), identity);
+        const currentInspection = inspectAtomicIdentity(io, () => file.statExact(), identity);
         if (io.asynchronous)
             yield currentInspection;
         return { file, identity };
@@ -43701,7 +43722,7 @@ async function removeOwnedPath(params) {
         if (current.isSymbolicLink() ||
             !current.isFile() ||
             current.nlink !== 1n ||
-            !file_identity_sameFileIdentityForCleanup(current, params.identity)) {
+            !sameFileIdentityForCleanup(current, params.identity)) {
             return "preserved";
         }
         await promises_.unlink(params.pathname);
@@ -43724,11 +43745,11 @@ async function cleanupPinnedFilePath(params) {
         await assertAsyncDirectoryGuard(guard);
         const parent = external_node_fs_.lstatSync(guard.dir, { bigint: true });
         if (parent.isSymbolicLink() || !parent.isDirectory() ||
-            !file_identity_sameFileIdentityForCleanup(parent, guard.stat))
+            !sameFileIdentityForCleanup(parent, guard.stat))
             return "preserved";
         const opened = external_node_fs_.fstatSync(params.handle.fd, { bigint: true });
         if (!opened.isFile() || opened.nlink !== 1n ||
-            !file_identity_sameFileIdentityForCleanup(opened, params.identity))
+            !sameFileIdentityForCleanup(opened, params.identity))
             return "preserved";
     }
     catch (error) {
@@ -43863,7 +43884,7 @@ function pathStillMatchesReceipt(entry) {
     try {
         const current = external_node_fs_.lstatSync(entry.path, { bigint: true });
         return (!entry.singleLinkFile || (current.isFile() && current.nlink === 1n)) &&
-            file_identity_sameFileIdentityForCleanup(current, entry.identity);
+            sameFileIdentityForCleanup(current, entry.identity);
     }
     catch {
         // A missing pathname grants no authority over an entry created after this lookup.
@@ -43967,7 +43988,7 @@ async function removePathIfIdentityUnchanged(targetPath, identity) {
     const parentGuard = await directory_guard_createAsyncDirectoryGuard(external_node_path_.dirname(targetPath), { bigint: true });
     await withAsyncDirectoryGuards([parentGuard], async () => {
         const current = external_node_fs_.lstatSync(targetPath, { bigint: true });
-        if (current.isSymbolicLink() || !current.isFile() || !file_identity_sameFileIdentityForCleanup(current, identity))
+        if (current.isSymbolicLink() || !current.isFile() || !sameFileIdentityForCleanup(current, identity))
             return;
         await promises_.unlink(targetPath);
     });
@@ -44042,7 +44063,7 @@ class AtomicTempOwner {
         this.onIdentity(temp.identity);
     }
     inspectOwned(read, pathname, pathnameEntry, expected) {
-        return atomic_io_inspectAtomicIdentity(this.io, read, expected, false, stat => assertOwnedFile(stat, pathname, pathnameEntry));
+        return inspectAtomicIdentity(this.io, read, expected, false, stat => assertOwnedFile(stat, pathname, pathnameEntry));
     }
     *assertCurrent(pathname = this.pathname) {
         const openedInspection = this.inspectOwned(() => this.resource.statExact(), pathname, false, this.identity);
@@ -44122,9 +44143,9 @@ class AtomicTempOwner {
         try {
             const observation = this.io.lstatExact(this.pathname);
             const current = this.io.asyncFs && this.io.asyncFs !== promises_
-                ? yield* atomic_io_wait(observation) : observation;
+                ? yield* wait(observation) : observation;
             if (!current.isSymbolicLink() && current.isFile() && current.nlink === 1n &&
-                file_identity_sameFileIdentityForCleanup(current, identity)) {
+                sameFileIdentityForCleanup(current, identity)) {
                 yield* this.io.unlink(this.pathname);
             }
             return true;
@@ -44195,7 +44216,7 @@ function probeEntry(directory, name, names) {
         original = strict_file_identity_inspectFileIdentitySync(() => external_node_fs_.lstatSync(originalPath, { bigint: true }));
         try {
             const other = strict_file_identity_inspectFileIdentitySync(() => external_node_fs_.lstatSync(external_node_path_.join(directory, alternate), { bigint: true }));
-            const sameIdentity = file_identity_sameFileIdentityForCleanup(original, other);
+            const sameIdentity = sameFileIdentityForCleanup(original, other);
             if (sameIdentity || bothListed) {
                 // Matching inodes can belong to newly linked case-distinct names.
                 const currentNames = new Set(external_node_fs_.readdirSync(directory));
@@ -47929,7 +47950,7 @@ async function withNativeDirectory(params, operation, discard) {
     }
 }
 /** Admit only an ordinary direct child; aliases keep the full resolver. */
-function tryMkdirNativeDirectChild(root, relativePath) {
+function tryMkdirNativeDirectChild(root, relativePath, mode) {
     if (!isSafePathSegment(relativePath, { allowDotPrefix: true }) || relativePath.endsWith(".") ||
         getFsSafeTestHooks()?.beforeRootFallbackMutation)
         return false;
@@ -47945,7 +47966,7 @@ function tryMkdirNativeDirectChild(root, relativePath) {
         return false;
     }
     try {
-        mkdirNativeRootChild({ root, target });
+        mkdirNativeRootChild({ root, target }, mode);
         return true;
     }
     catch (error) {
@@ -48054,7 +48075,7 @@ function ensureNativeRootCurrentLegacy(root, binding) {
         root_create_native_disposeResources(env_4);
     }
 }
-function mkdirNativeRootChild(params) {
+function mkdirNativeRootChild(params, mode) {
     const env_5 = { stack: [], error: void 0, hasError: false };
     try {
         const binding = native_getNativeBinding("openBeneath", "mkdirChildBeneath");
@@ -48064,19 +48085,28 @@ function mkdirNativeRootChild(params) {
             rootPath: params.root.rootReal, rootIdentity: params.root.rootIdentity,
         }), false);
         verifyMkdirDirectory(binding, rootOwner.fd, params.root.rootReal);
-        const flags = (nodeDirectorySearchOnlyFlags()?.flags ?? external_node_fs_.constants.O_RDONLY) |
+        const flags = (mode === undefined ? nodeDirectorySearchOnlyFlags()?.flags ?? external_node_fs_.constants.O_RDONLY : external_node_fs_.constants.O_RDONLY) |
             (external_node_fs_.constants.O_DIRECTORY ?? 0) | (external_node_fs_.constants.O_NOFOLLOW ?? 0);
         const name = external_node_path_.basename(params.target);
         // The admitted Root is already this operation's immediate parent. Retain
         // both handles through the same fresh pathname and canonical identity fences.
         const child = binding.mkdirOpenChildBeneath
-            ? binding.mkdirOpenChildBeneath(rootOwner.fd, name, 0o777, flags).fd
-            : (binding.mkdirChildBeneath(rootOwner.fd, name, 0o777), binding.openBeneath(rootOwner.fd, name, flags).fd);
+            ? binding.mkdirOpenChildBeneath(rootOwner.fd, name, mode ?? 0o777, flags)
+            : {
+                created: binding.mkdirChildBeneath(rootOwner.fd, name, mode ?? 0o777),
+                fd: binding.openBeneath(rootOwner.fd, name, flags).fd,
+            };
         const close = captureNativeFdClose(binding);
-        const childOwner = root_create_native_addDisposableResource(env_5, { [Symbol.dispose]() { close(child); } }, false);
+        const childOwner = root_create_native_addDisposableResource(env_5, { [Symbol.dispose]() { close(child.fd); } }, false);
         root_context_assertRootIdentityCurrentSync(params.root);
-        verifyMkdirDirectory(binding, child, params.target);
+        verifyMkdirDirectory(binding, child.fd, params.target);
         verifyMkdirDirectory(binding, rootOwner.fd, params.root.rootReal);
+        if (mode !== undefined && child.created) {
+            finalizeCreatedDirectoryModeSync(child, mode);
+            verifyMkdirDirectory(binding, child.fd, params.target);
+            verifyMkdirDirectory(binding, rootOwner.fd, params.root.rootReal);
+            root_context_assertRootIdentityCurrentSync(params.root);
+        }
     }
     catch (e_5) {
         env_5.error = e_5;
@@ -48444,7 +48474,7 @@ function removeSiblingIfOwned(params) {
     if (current.isSymbolicLink() ||
         !current.isFile() ||
         (current.nlink !== 1n && current.nlink !== 2n) ||
-        !file_identity_sameFileIdentityForCleanup(current, params.identity)) {
+        !sameFileIdentityForCleanup(current, params.identity)) {
         throw pathMismatch("isolated producer sibling changed before cleanup");
     }
     external_node_fs_.unlinkSync(params.targetPath);
@@ -49146,6 +49176,8 @@ async function createPrivateWindowsFileHandle(selected, options) {
 
 
 
+
+
 function sameDirectoryFacts(left, right) {
     return left.dev === right.dev && left.ino === right.ino && left.mode === right.mode &&
         left.nlink === right.nlink;
@@ -49405,6 +49437,13 @@ async function mkdirPathComponentsWithGuards(params) {
         if (!createdAuthorization || !createdEvidence) {
             directory_guard_assertDirectoryGuard(parentGuard, "native");
         }
+        if (created && params.finalizeCreatedMode && params.mode !== undefined) {
+            await runAsync(applyDirectoryMode(AtomicIo.async(promises_), {
+                dirPath: currentGuard.dir, mode: params.mode, expectedIdentity: currentGuard.stat,
+            }));
+            directory_guard_assertDirectoryGuard(parentGuard, "native");
+            directory_guard_assertDirectoryGuard(currentGuard, "native");
+        }
         current = admittedNextPath;
     }
     return current;
@@ -50207,9 +50246,9 @@ function removeNativeCreatedFileIfStillPinned(params) {
         const targetPath = external_node_path_.join(params.parentPath, params.basename);
         const target = external_node_fs_.lstatSync(targetPath, { bigint: true });
         if (!parentPathStat.isSymbolicLink() && parentPathStat.isDirectory() &&
-            file_identity_sameFileIdentityForCleanup(parentPathStat, parentFdStat) &&
+            sameFileIdentityForCleanup(parentPathStat, parentFdStat) &&
             !target.isSymbolicLink() && target.isFile() &&
-            file_identity_sameFileIdentityForCleanup(target, params.created)) {
+            sameFileIdentityForCleanup(target, params.created)) {
             external_node_fs_.rmSync(targetPath);
         }
     }
@@ -51907,7 +51946,7 @@ function sidecarLockSnapshotMatches(current, observed) {
     }
     if (observed.stat &&
         current.stat &&
-        !file_identity_sameFileIdentityForCleanup(observed.stat, current.stat)) {
+        !sameFileIdentityForCleanup(observed.stat, current.stat)) {
         return false;
     }
     if (observed.raw !== undefined) {
@@ -52673,7 +52712,7 @@ function cleanupCreatedSidecar(lockPath, raw, fd, parent, identity) {
                 throw new errors_FsSafeError("helper-unavailable", "creator cleanup is unavailable");
             }
             const entry = parent.binding.rootRemovalStat(parent.fd, name);
-            if (entry.directory || entry.symlink || !file_identity_sameFileIdentityForCleanup(identity, entry))
+            if (entry.directory || entry.symlink || !sameFileIdentityForCleanup(identity, entry))
                 throw sidecar_lock_retained_mismatch("identity");
         }
         else if (!parent.binding.stagedFileMatches || !parent.binding.removeStagedFile) {
@@ -52689,7 +52728,7 @@ function cleanupCreatedSidecar(lockPath, raw, fd, parent, identity) {
         throw error;
     }
     const stat = external_node_fs_.fstatSync(fd, { bigint: true });
-    if (!stat.isFile() || stat.nlink !== 1n || !file_identity_sameFileIdentityForCleanup(identity, stat))
+    if (!stat.isFile() || stat.nlink !== 1n || !sameFileIdentityForCleanup(identity, stat))
         throw sidecar_lock_retained_mismatch("identity");
     assertOwnerRecord(fd, Buffer.from(raw));
     if (windows) {
@@ -52747,7 +52786,7 @@ function retainCreatedSidecar(lockPath, raw, createdFd, guard, nativeParent) {
     let fd;
     try {
         const parentStat = external_node_fs_.fstatSync(parentFd, { bigint: true });
-        if (!parentStat.isDirectory() || !file_identity_sameFileIdentityForCleanup(guard.stat, parentStat))
+        if (!parentStat.isDirectory() || !sameFileIdentityForCleanup(guard.stat, parentStat))
             throw sidecar_lock_retained_mismatch("identity");
         fd = binding.openBeneath(parentFd, name, nativeOpenFlags(external_node_fs_.constants.O_RDONLY | external_node_fs_.constants.O_NONBLOCK)).fd;
         const ownedFd = fd;
@@ -52762,7 +52801,7 @@ function retainCreatedSidecar(lockPath, raw, createdFd, guard, nativeParent) {
                 throw error;
             }
             const current = external_node_fs_.fstatSync(ownedFd, { bigint: true });
-            if (!current.isFile() || current.nlink !== 1n || !file_identity_sameFileIdentityForCleanup(created, current))
+            if (!current.isFile() || current.nlink !== 1n || !sameFileIdentityForCleanup(created, current))
                 throw sidecar_lock_retained_mismatch("identity");
             return true;
         };
@@ -53189,7 +53228,7 @@ async function acquireSidecarLock(options, context) {
                 }
                 const snapshot = { raw, payload, stat: external_node_fs_.fstatSync(handle.fd, { bigint: true }), ownershipToken };
                 createdSnapshot = snapshot;
-                if (retainedSidecar && !file_identity_sameFileIdentityForCleanup(retainedSidecar.identity, snapshot.stat)) {
+                if (retainedSidecar && !sameFileIdentityForCleanup(retainedSidecar.identity, snapshot.stat)) {
                     throw new errors_FsSafeError("path-mismatch", "created sidecar lock identity changed before admission");
                 }
                 if (snapshot.stat.nlink === 0n) {
@@ -53465,7 +53504,7 @@ function snapshotMatchesSync(lockPath, observed) {
         const openedStat = external_node_fs_.fstatSync(fd, { bigint: true });
         // Token-owned files can have different descriptor/path identities on VirtioFS.
         // Require a known descriptor identity without rejecting that supported drift.
-        if (!openedStat.isFile() || !file_identity_sameFileIdentityForCleanup(openedStat, openedStat)) {
+        if (!openedStat.isFile() || !sameFileIdentityForCleanup(openedStat, openedStat)) {
             return false;
         }
         if (observed.raw !== undefined && openedStat.size !== BigInt(Buffer.byteLength(observed.raw))) {
@@ -53473,7 +53512,7 @@ function snapshotMatchesSync(lockPath, observed) {
         }
         const raw = external_node_fs_.readFileSync(fd, "utf8");
         const afterStat = external_node_fs_.lstatSync(lockPath, { bigint: true });
-        if (!afterStat.isFile() || !file_identity_sameFileIdentityForCleanup(beforeStat, afterStat)) {
+        if (!afterStat.isFile() || !sameFileIdentityForCleanup(beforeStat, afterStat)) {
             return false;
         }
         return sidecarLockSnapshotMatches({ raw, payload: null, stat: afterStat }, observed);
@@ -53748,8 +53787,8 @@ async function publishCopyStage(params) {
         const staged = external_node_fs_.lstatSync(temporaryPath, { bigint: true });
         const opened = external_node_fs_.fstatSync(params.fd, { bigint: true });
         if (!staged.isFile() || staged.isSymbolicLink() || staged.nlink !== 1n ||
-            !file_identity_sameFileIdentityForCleanup(staged, identity) ||
-            !file_identity_sameFileIdentityForCleanup(opened, identity)) {
+            !sameFileIdentityForCleanup(staged, identity) ||
+            !sameFileIdentityForCleanup(opened, identity)) {
             throw new errors_FsSafeError("path-mismatch", "exclusive copy stage changed before publication");
         }
     };
@@ -53790,7 +53829,7 @@ async function publishCopyStage(params) {
             }
             const target = external_node_fs_.lstatSync(targetPath, { bigint: true });
             if (!target.isFile() || target.isSymbolicLink() || target.nlink !== 1n ||
-                !file_identity_sameFileIdentityForCleanup(target, identity)) {
+                !sameFileIdentityForCleanup(target, identity)) {
                 throw new errors_FsSafeError("path-mismatch", "renamed copy target changed after publication");
             }
         }
@@ -53801,10 +53840,10 @@ async function publishCopyStage(params) {
                 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) ||
+                    !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)) {
+                    !sameFileIdentityForCleanup(current, identity) || !sameFileIdentityForCleanup(target, identity)) {
                     throw new errors_FsSafeError("path-mismatch", "published copy temporary name changed before cleanup");
                 }
             };
@@ -53828,7 +53867,7 @@ async function publishCopyStage(params) {
 }
 function isEmptyPlaceholder(current, identity) {
     return current.isFile() && !current.isSymbolicLink() && current.nlink === 1n &&
-        current.size === 0n && file_identity_sameFileIdentityForCleanup(current, identity);
+        current.size === 0n && sameFileIdentityForCleanup(current, identity);
 }
 function publishThroughPlaceholder(params, assertCurrent) {
     const { targetPath, temporaryPath } = params;
@@ -53907,7 +53946,7 @@ async function openPublicationHandle(targetPath, identity) {
         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)) {
+            !sameFileIdentityForCleanup(opened, identity) || !sameFileIdentityForCleanup(named, identity)) {
             throw new errors_FsSafeError("path-mismatch", "publication descriptor handoff identity changed");
         }
         return handle;
@@ -54911,9 +54950,9 @@ var root_mkdir_native_disposeResources = (undefined && undefined.__disposeResour
 
 
 
-function tryMkdirNativeParents(root, relativePath) {
+function tryMkdirNativeParents(root, relativePath, mode) {
     try {
-        return mkdirOrdinaryNativeParents(root, relativePath);
+        return mkdirOrdinaryNativeParents(root, relativePath, mode);
     }
     catch (error) {
         if (hasNodeErrorCode(error, "ENOTDIR"))
@@ -54921,7 +54960,7 @@ function tryMkdirNativeParents(root, relativePath) {
         throw error;
     }
 }
-function mkdirOrdinaryNativeParents(root, relativePath) {
+function mkdirOrdinaryNativeParents(root, relativePath, mode) {
     if (getFsSafeTestHooks()?.beforeRootFallbackMutation)
         return false;
     const segments = relativePath.split(external_node_path_.sep === "\\" ? /[\\/]/ : "/");
@@ -54946,7 +54985,7 @@ function mkdirOrdinaryNativeParents(root, relativePath) {
     catch (error) {
         // Reuse this exact Root snapshot and failed parent observation without an
         // intervening await. All opened ancestors still receive fresh native fences.
-        return hasNodeErrorCode(error, "ENOENT") ? mkdirMissingParents(root, segments, rootStat) : false;
+        return hasNodeErrorCode(error, "ENOENT") ? mkdirMissingParents(root, segments, rootStat, mode) : false;
     }
     try {
         if (realpath_realpathSync.native(windows_path_alias_pathForWindowsFilesystem(parentPath)) !== parentPath)
@@ -54955,12 +54994,12 @@ function mkdirOrdinaryNativeParents(root, relativePath) {
     catch {
         return false;
     }
-    return mkdirExistingParent(root, segments, parentIdentity);
+    return mkdirExistingParent(root, segments, parentIdentity, mode);
 }
 /** Ordinary missing suffixes need no policy callbacks or repeated path resolution. */
-function mkdirMissingParents(root, segments, rootStat) {
+function mkdirMissingParents(root, segments, rootStat, mode) {
     const binding = native_getNativeBinding("openBeneath", "mkdirChildBeneath");
-    if (!binding?.openBeneath || !binding.mkdirOpenChildBeneath)
+    if (!binding?.openBeneath || !binding.mkdirChildBeneath || (!binding.mkdirOpenChildBeneath && mode === undefined))
         return false;
     let parentDepth = segments.length - 2;
     let parentPath;
@@ -55000,7 +55039,7 @@ function mkdirMissingParents(root, segments, rootStat) {
                     if (errors.length)
                         throw new AggregateError(errors, "mkdir directory close failed");
                 } }, false);
-            const flags = (nodeDirectorySearchOnlyFlags()?.flags ?? external_node_fs_.constants.O_RDONLY) |
+            const flags = (mode === undefined ? nodeDirectorySearchOnlyFlags()?.flags ?? external_node_fs_.constants.O_RDONLY : external_node_fs_.constants.O_RDONLY) |
                 (external_node_fs_.constants.O_DIRECTORY ?? 0) | (external_node_fs_.constants.O_NOFOLLOW ?? 0);
             let current = rootOwner.fd;
             if (parentDepth > 0) {
@@ -55016,12 +55055,21 @@ function mkdirMissingParents(root, segments, rootStat) {
             };
             assertCurrent();
             for (const segment of segments.slice(parentDepth)) {
-                const child = binding.mkdirOpenChildBeneath(current, segment, 0o777, flags);
+                const child = binding.mkdirOpenChildBeneath
+                    ? binding.mkdirOpenChildBeneath(current, segment, mode ?? 0o777, flags)
+                    : {
+                        created: binding.mkdirChildBeneath(current, segment, mode ?? 0o777),
+                        fd: binding.openBeneath(current, segment, flags).fd,
+                    };
                 parentPath = external_node_path_.join(parentPath, segment);
                 directories.push({ fd: child.fd, pathname: parentPath });
                 // Retain every ancestor until the complete suffix is admitted. The
                 // post-create fence also precedes the next synchronous child mutation.
                 assertCurrent();
+                if (mode !== undefined && child.created) {
+                    finalizeCreatedDirectoryModeSync(child, mode);
+                    assertCurrent();
+                }
                 current = child.fd;
             }
             return true;
@@ -55040,7 +55088,7 @@ function mkdirMissingParents(root, segments, rootStat) {
         throw error;
     }
 }
-function mkdirExistingParent(root, segments, parentIdentity) {
+function mkdirExistingParent(root, segments, parentIdentity, mode) {
     const env_2 = { stack: [], error: void 0, hasError: false };
     try {
         const target = external_node_path_.join(root.rootReal, ...segments);
@@ -55053,7 +55101,7 @@ function mkdirExistingParent(root, segments, parentIdentity) {
             rootPath: root.rootReal, rootIdentity: root.rootIdentity,
         }), false);
         verifyMkdirDirectory(binding, rootOwner.fd, root.rootReal);
-        const flags = (nodeDirectorySearchOnlyFlags()?.flags ?? external_node_fs_.constants.O_RDONLY) |
+        const flags = (mode === undefined ? nodeDirectorySearchOnlyFlags()?.flags ?? external_node_fs_.constants.O_RDONLY : external_node_fs_.constants.O_RDONLY) |
             (external_node_fs_.constants.O_DIRECTORY ?? 0) | (external_node_fs_.constants.O_NOFOLLOW ?? 0);
         const close = captureNativeFdClose(binding);
         const parent = binding.openBeneath(rootOwner.fd, segments.slice(0, -1).join("/"), flags).fd;
@@ -55063,14 +55111,24 @@ function mkdirExistingParent(root, segments, parentIdentity) {
         root_context_assertRootIdentityCurrentSync(root);
         const name = segments.at(-1);
         const child = binding.mkdirOpenChildBeneath
-            ? binding.mkdirOpenChildBeneath(parent, name, 0o777, flags).fd
-            : (binding.mkdirChildBeneath(parent, name, 0o777), binding.openBeneath(parent, name, flags).fd);
-        const childOwner = root_mkdir_native_addDisposableResource(env_2, { [Symbol.dispose]() { close(child); } }, false);
+            ? binding.mkdirOpenChildBeneath(parent, name, mode ?? 0o777, flags)
+            : {
+                created: binding.mkdirChildBeneath(parent, name, mode ?? 0o777),
+                fd: binding.openBeneath(parent, name, flags).fd,
+            };
+        const childOwner = root_mkdir_native_addDisposableResource(env_2, { [Symbol.dispose]() { close(child.fd); } }, false);
         root_context_assertRootIdentityCurrentSync(root);
-        verifyMkdirDirectory(binding, child, target);
+        verifyMkdirDirectory(binding, child.fd, target);
         directory_guard_inspectDirectoryIdentitySync(parentPath, parentIdentity);
         verifyMkdirDirectory(binding, parent, parentPath);
         verifyMkdirDirectory(binding, rootOwner.fd, root.rootReal);
+        if (mode !== undefined && child.created) {
+            finalizeCreatedDirectoryModeSync(child, mode);
+            verifyMkdirDirectory(binding, child.fd, target);
+            verifyMkdirDirectory(binding, parent, parentPath);
+            verifyMkdirDirectory(binding, rootOwner.fd, root.rootReal);
+            root_context_assertRootIdentityCurrentSync(root);
+        }
         return true;
     }
     catch (e_2) {
@@ -56230,7 +56288,7 @@ async function assertMissingRemovalPrefixCurrent(rootGuard, intermediates) {
     catch (error) {
         throw removalAncestorChanged(error);
     }
-    if (!file_identity_sameFileIdentityForCleanup(deepestGuard.stat, deepest) ||
+    if (!sameFileIdentityForCleanup(deepestGuard.stat, deepest) ||
         !sameCanonicalDirectory(deepestGuard.realPath, deepest.path)) {
         throw removalAncestorChanged();
     }
@@ -56255,7 +56313,7 @@ async function captureNonrecursiveRemovalAdmission(root, targetPath, options, re
             await assertRootIdentityCurrent(root);
         throw normalizeRemoveGuardError(error);
     }
-    if (!file_identity_sameFileIdentityForCleanup(rootGuard.stat, root.rootIdentity))
+    if (!sameFileIdentityForCleanup(rootGuard.stat, root.rootIdentity))
         throw rootPathChangedError();
     if (parentPath === root.rootReal) {
         const rootAssertion = createRemovalDirectoryAssertion(rootGuard.dir, rootGuard.stat, rootGuard.realPath);
@@ -56419,7 +56477,7 @@ async function removePathInRootFallback(root, targetPath, options, receipts) {
     });
     let examined = 0;
     const rootGuard = await directory_guard_createAsyncDirectoryGuard(root.rootReal, { bigint: true });
-    if (!file_identity_sameFileIdentityForCleanup(rootGuard.stat, root.rootIdentity))
+    if (!sameFileIdentityForCleanup(rootGuard.stat, root.rootIdentity))
         throw rootPathChangedError();
     const guards = [
         createRemovalDirectoryAssertion(rootGuard.dir, rootGuard.stat, rootGuard.realPath),
@@ -56496,7 +56554,7 @@ async function removePathInRootFallback(root, targetPath, options, receipts) {
                 throw normalizeRemovePathError(error, details(target, "inspect"));
             }
             if (!isPathInside(directoryGuard.realPath, target) || !isPathInside(target, directoryGuard.realPath) ||
-                !file_identity_sameFileIdentityForCleanup(directoryGuard.stat, initial)) {
+                !sameFileIdentityForCleanup(directoryGuard.stat, initial)) {
                 throw new errors_FsSafeError("path-mismatch", "removal directory changed during operation");
             }
             guards.push(createRemovalDirectoryAssertion(directoryGuard.dir, directoryGuard.stat, directoryGuard.realPath));
@@ -57171,7 +57229,7 @@ async function finishRootFallbackWrite(params) {
                 // identity without reading bytes; a different object must still fail.
                 await verify();
             }
-            else if (!file_identity_sameFileIdentityForCleanup(current, identity)) {
+            else if (!sameFileIdentityForCleanup(current, identity)) {
                 const opened = await params.openForCompatibility();
                 accepted = handle = opened.opened.handle;
                 identity = opened.identity;

package/package.json

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