toolcraft 0.0.765 → 0.0.767

package/composition.json

@@ -133,7 +133,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.765",
+      "version": "0.0.767",
       "license": "MIT"
     },
     {
@@ -143,7 +143,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.765",
+      "version": "0.0.767",
       "license": "MIT"
     },
     {

package/dist/composition.json

@@ -133,7 +133,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.765",
+      "version": "0.0.767",
       "license": "MIT"
     },
     {
@@ -143,7 +143,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.765",
+      "version": "0.0.767",
       "license": "MIT"
     },
     {

package/node_modules/@poe-code/safe-fs/README.md

@@ -86,10 +86,11 @@ cause. Preserve cancellation/control exceptions separately. Cross-family
 | Change the namespace | `mkdir`, `rm`, `rename`, `copyFile` |
 | Remove an empty directory | Optional `rmdir`; never a recursive-delete fallback |
 | Links and metadata | Optional `readlink`, `symlink`, `link`, `chmod`, `utimes`, `truncate` |
-| Enumerate directories lazily | Optional `iterateDirectory`; memory and native backends, with readonly/quota/device/scoped delegation; backend order, no sorted-array fallback |
+| Enumerate directories lazily | Optional `iterateDirectory`; memory and native backends, with mount/overlay/readonly/quota/device/scoped delegation; backend order, no sorted-array fallback |
 | Stream bytes | Optional `readStream`, `writeStream`, using async iterables of byte chunks |
 | Retain an open file | Optional `open` with positioned I/O and synchronization; memory and real backends support `noFollow: true` to atomically refuse a final symlink |
 | Publish immutable objects atomically | Optional `publishFileConditional` with opaque identity/version stats and authoritative compare-and-publish |
+| Publish a checked source set | Optional `publishStagedFileSet` publishes a staged file and retires sibling entries in one backend commit; mount views require all entries on the same supporting backend |
 | Compare backing entries | Optional `compareEntry`, returning `same`, `distinct`, or `unknown` |
 
 All required methods must exist, but a backend may reject an operation with `FsError`, such as `EROFS` for a write or `ENOTSUP` for unsupported semantics. Check optional methods and `capabilities` rather than assuming every backend behaves like a local disk. Errors expose `code` and may include `syscall`, `path`, `dest`, and `cause`.

package/node_modules/@poe-code/safe-fs/dist/fs/mount/index.d.ts

@@ -1,4 +1,4 @@
-import type { AppendFileOptions, CapabilityQueryOptions, CopyFileOptions, DirectoryEntry, FileReadHandle, FileResizeHandle, FileResizeOperation, FileResizeOptions, FileStat, FileSystem, OpenReadFileOptions, OpenResizeFileOptions, FileSystemCapabilities, FsOptions, ChmodOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions, ConditionalFilePublicationOptions, ConditionalWriteFileOptions, ConditionalRemoveFileOptions, ConditionalRemoveEntryOptions, ConditionalRemoveEntryReceiptOptions, CreateStagedFileOptions, FileStaging, FileStagingEntry, FileStagingResolution, PublishStagedFileOptions, PrepareDirectoryOptions, StagedFileContent } from "../../contracts/filesystem.js";
+import type { AppendFileOptions, CapabilityQueryOptions, CopyFileOptions, DirectoryEntry, FileReadHandle, FileResizeHandle, FileResizeOperation, FileResizeOptions, FileStat, FileSystem, OpenReadFileOptions, OpenResizeFileOptions, FileSystemCapabilities, FsOptions, ChmodOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions, ConditionalFilePublicationOptions, ConditionalWriteFileOptions, ConditionalRemoveFileOptions, ConditionalRemoveEntryOptions, ConditionalRemoveEntryReceiptOptions, CreateStagedFileOptions, FileStaging, FileStagingEntry, FileStagingResolution, PublishStagedFileOptions, PublishStagedFileSetOptions, PrepareDirectoryOptions, StagedFileContent } from "../../contracts/filesystem.js";
 import type { ByteSource } from "../../contracts/io.js";
 import type { FileDescriptor, OpenFileOptions } from "../../contracts/descriptor.js";
 export interface MountFileSystemOptions {
@@ -40,6 +40,7 @@ export declare class MountFileSystem implements FileSystem {
     stat(path: string, options?: FsOptions): Promise<FileStat>;
     lstat(path: string, options?: FsOptions): Promise<FileStat>;
     readdir(path: string, options?: ReadDirectoryOptions): Promise<DirectoryEntry[]>;
+    iterateDirectory(path: string, options?: FsOptions): AsyncIterable<DirectoryEntry>;
     mkdir(path: string, options?: MkdirOptions): Promise<void>;
     rmdir(path: string, options?: FsOptions): Promise<void>;
     unlink(path: string, options?: FsOptions): Promise<void>;
@@ -55,6 +56,7 @@ export declare class MountFileSystem implements FileSystem {
     removeTreeConditional(path: string, options: ConditionalRemoveEntryOptions): Promise<void>;
     createStagedFile(path: string, name: string, content: StagedFileContent, options: CreateStagedFileOptions): Promise<FileStaging>;
     publishStagedFile(staging: FileStaging, destination: string, options: PublishStagedFileOptions): Promise<void>;
+    publishStagedFileSet(staging: FileStaging, destination: string, supplied: PublishStagedFileSetOptions): Promise<FileStat>;
     removeStagedFile(staging: FileStaging, options?: FsOptions): Promise<void>;
     prepareDirectory(path: string, options: PrepareDirectoryOptions): Promise<FileStat>;
     rename(source: string, destination: string, options?: RenameOptions): Promise<void>;

package/node_modules/@poe-code/safe-fs/dist/fs/mount/index.js

@@ -483,7 +483,7 @@ export class MountFileSystem {
             release = await this.acquireNamespace(options, [
                 "rename", "symlink", "link", "unlink", "rm", "rmdir",
                 "removeEntryConditional", "removeFileConditional", "removeTreeConditional",
-                "publishStagedFile", "removeStagedFile",
+                "publishStagedFile", "publishStagedFileSet", "removeStagedFile",
             ].includes(syscall));
             const result = await action();
             if (!preserveReceipt)
@@ -802,6 +802,76 @@ export class MountFileSystem {
             return [...entries.values()].sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
         });
     }
+    async *iterateDirectory(path, options = {}) {
+        try {
+            const location = await this.operation("iterateDirectory", path, options, async () => {
+                const resolved = await this.resolve(path, options);
+                if (resolved.stat?.type !== "directory")
+                    fail("ENOTDIR");
+                return resolved;
+            });
+            // Only configured mount children are retained, never backend entries.
+            const mounted = new Set();
+            for (const mount of this.mounts) {
+                if (mount.path !== location.path && within(location.path, mount.path)) {
+                    const suffix = mount.path.slice(location.path === "/" ? 1 : location.path.length + 1);
+                    mounted.add(suffix.split("/")[0]);
+                }
+            }
+            const admit = async () => {
+                const current = await this.resolve(path, options);
+                if (current.path !== location.path || current.mount !== location.mount ||
+                    current.local !== location.local || current.synthetic !== location.synthetic ||
+                    current.stat?.type !== "directory")
+                    fail("EBUSY");
+            };
+            if (!location.synthetic) {
+                const iterator = await this.operation("iterateDirectory", path, options, async () => {
+                    await admit();
+                    const backend = location.mount.backend;
+                    if (!backend.iterateDirectory)
+                        fail("ENOTSUP");
+                    return backend.iterateDirectory(location.local, options)[Symbol.asyncIterator]();
+                }, undefined, true); // Transfer ownership before checking cancellation on the first pull.
+                // Admission covers each backend pull, but never a consumer pause. In
+                // particular, caller-backed traversal may publish scratch files between pulls.
+                let complete = false, failed = false;
+                try {
+                    while (true) {
+                        const result = await this.operation("iterateDirectory", path, options, async () => {
+                            await admit();
+                            return iterator.next();
+                        });
+                        if (result.done) {
+                            complete = true;
+                            break;
+                        }
+                        const { name, type } = result.value;
+                        if (!name || name === "." || name === ".." || name.includes("/") || name.includes("\0"))
+                            fail("EIO");
+                        if (!mounted.has(name))
+                            yield { name, type };
+                    }
+                }
+                catch (error) {
+                    failed = true;
+                    throw error;
+                }
+                finally {
+                    if (!complete)
+                        await finishCleanup(() => iterator.return?.(), failed);
+                }
+            }
+            for (const name of mounted) {
+                await this.operation("iterateDirectory", path, options, admit);
+                yield { name, type: "directory" };
+            }
+            options.signal?.throwIfAborted();
+        }
+        catch (error) {
+            throw this.error(error, "iterateDirectory", path, options);
+        }
+    }
     mkdir(path, options = {}) {
         return this.operation("mkdir", path, options, async () => {
             const directories = new Map();
@@ -1069,6 +1139,83 @@ export class MountFileSystem {
             });
         }, destination, true);
     }
+    async publishStagedFileSet(staging, destination, supplied) {
+        const entry = (value) => ({ path: value.path, stat: snapshotStat(value.stat) });
+        staging = { parent: entry(staging.parent), directory: entry(staging.directory), file: entry(staging.file) };
+        const options = {
+            ...supplied, parent: snapshotStat(supplied.parent),
+            destination: supplied.destination === null ? null : snapshotStat(supplied.destination),
+            companions: supplied.companions.map(value => ({ ...value, expected: value.expected === null ? null : snapshotStat(value.expected) })),
+            ...(supplied.ancestors === undefined ? {} : { ancestors: snapshotDirectoryAncestry(supplied.ancestors) }),
+        };
+        return this.operation("publishStagedFileSet", staging.file.path, options, async () => {
+            validatePath(destination);
+            if (normalizePath(globalPath(destination)) !== destination || destination === "/")
+                fail("EINVAL");
+            const parent = destination.slice(0, destination.lastIndexOf("/")) || "/";
+            const paths = new Set([destination]);
+            for (const companion of options.companions) {
+                validatePath(companion.path);
+                if (normalizePath(globalPath(companion.path)) !== companion.path || paths.has(companion.path) ||
+                    (companion.path.slice(0, companion.path.lastIndexOf("/")) || "/") !== parent)
+                    fail("EINVAL");
+                paths.add(companion.path);
+            }
+            const ancestors = options.ancestors;
+            if (ancestors && ancestors.at(-1)?.path !== parent)
+                fail("EINVAL");
+            const guard = ancestors ? await this.prepareAncestry(ancestors, options) : undefined;
+            const local = await this.localStaging(staging, options);
+            const target = await this.resolve(destination, options, { followFinal: false, entry: true, allowMissing: true });
+            if (this.protected(target.path))
+                fail("EBUSY");
+            if (local.mount !== target.mount)
+                fail("EXDEV");
+            if (ancestors && target.path !== destination)
+                fail("EAGAIN");
+            this.mutable(target);
+            const backend = local.mount.backend;
+            if (!backend.publishStagedFileSet)
+                fail("ENOTSUP");
+            await requireOwnedMutation(backend, local.staging.directory.path, "atomicFileStaging", options);
+            await requireOwnedMutation(backend, target.local, "atomicFileStaging", options, options.destination === null);
+            const companions = [];
+            for (const companion of options.companions) {
+                const resolved = await this.resolve(companion.path, options, { followFinal: false, entry: true, allowMissing: true });
+                if (this.protected(resolved.path))
+                    fail("EBUSY");
+                if (resolved.mount !== target.mount)
+                    fail("EXDEV");
+                this.mutable(resolved);
+                companions.push({ ...companion, path: resolved.local });
+            }
+            let localAncestors;
+            if (ancestors) {
+                const first = ancestors.findIndex(value => value.path === target.mount.path);
+                if (first < 0)
+                    fail("EINVAL");
+                localAncestors = ancestors.slice(first).map(value => ({
+                    path: target.mount.path === "/" ? value.path : value.path.slice(target.mount.path.length) || "/", stat: value.stat,
+                }));
+            }
+            const callerGuard = options.commitGuard;
+            if (guard || callerGuard !== undefined)
+                await requireOwnedMutation(backend, target.local, "guardedStagingPublication", options, options.destination === null);
+            // One backend performs all version checks and the indivisible commit.
+            // The namespace lock covers admission through its committed receipt.
+            return snapshotStat(await backend.publishStagedFileSet(local.staging, target.local, {
+                ...options, companions,
+                ...(localAncestors === undefined ? {} : { ancestors: localAncestors }),
+                ...(guard || callerGuard !== undefined ? { commitGuard: () => {
+                        if (callerGuard !== undefined)
+                            runStagingGuard(callerGuard);
+                        if (guard)
+                            runStagingGuard(guard);
+                        return true;
+                    } } : {}),
+            }));
+        }, destination, true);
+    }
     removeStagedFile(staging, options = {}) {
         return this.operation("removeStagedFile", staging.directory.path, options, async () => {
             const local = await this.localStaging(staging, options);

package/node_modules/@poe-code/safe-fs/dist/fs/overlay/index.d.ts

@@ -64,6 +64,7 @@ export declare class OverlayFileSystem implements FileSystem {
     lstat(path: string, options?: FsOptions): Promise<FileStat>;
     compareEntry(path: string, peer: FileSystem, peerPath: string, options?: FsOptions): Promise<import("../../contracts/filesystem.js").EntryComparison>;
     readdir(path: string, options?: ReadDirectoryOptions): Promise<DirectoryEntry[]>;
+    iterateDirectory(path: string, options?: FsOptions): AsyncIterable<DirectoryEntry>;
     realpath(path: string, options?: FsOptions): Promise<string>;
     access(path: string, requestedMode?: number, options?: FsOptions): Promise<void>;
     mkdir(path: string, options?: MkdirOptions): Promise<void>;

package/node_modules/@poe-code/safe-fs/dist/fs/overlay/index.js

@@ -760,6 +760,72 @@ export class OverlayFileSystem {
         const limit = directoryEntryLimit(options, path);
         return this.run(options, async () => this.listing(await this.required(path, options), options, limit), false);
     }
+    async *iterateDirectory(path, options = {}) {
+        const directory = await this.run(options, async () => {
+            const entry = await this.required(path, options);
+            if (entry.stat.type !== "directory")
+                fail("ENOTDIR", path);
+            this.permission(entry, 4);
+            return entry.path;
+        }, false);
+        const admit = async () => {
+            const current = await this.required(path, options);
+            if (current.path !== directory || current.stat.type !== "directory")
+                fail("EBUSY", path);
+            this.permission(current, 4);
+        };
+        for (const backend of [this.#upper, this.#lower]) {
+            const iterator = await this.run(options, async () => {
+                await admit();
+                if (backend === this.#lower && (!await this.lowerVisible(directory, options) || this.opaque.has(directory)))
+                    return undefined;
+                if ((await this.maybeStat(backend, directory, options))?.type !== "directory")
+                    return undefined;
+                if (!backend.iterateDirectory)
+                    fail("ENOTSUP", directory);
+                return backend.iterateDirectory(directory, options)[Symbol.asyncIterator]();
+            }, false);
+            if (!iterator)
+                continue;
+            let complete = false, failed = false;
+            try {
+                while (true) {
+                    const result = await this.run(options, async () => {
+                        await admit();
+                        if (backend === this.#lower && (!await this.lowerVisible(directory, options) || this.opaque.has(directory)))
+                            fail("EBUSY", path);
+                        const next = await iterator.next();
+                        options.signal?.throwIfAborted();
+                        if (next.done)
+                            return { done: true };
+                        const name = next.value.name;
+                        if (!name || name === "." || name === ".." || name.includes("/") || name.includes("\0"))
+                            fail("EIO", directory, "invalid backend directory entry");
+                        const child = await this.lookup(directory === "/" ? `/${name}` : `${directory}/${name}`, options);
+                        options.signal?.throwIfAborted();
+                        // A lower name shadowed by upper storage is skipped by lookup,
+                        // without retaining a directory-sized set of previously seen names.
+                        return { done: false, entry: child?.backend === backend ? { name, type: child.stat.type } : undefined };
+                    }, false);
+                    if (result.done) {
+                        complete = true;
+                        break;
+                    }
+                    if (result.entry)
+                        yield result.entry;
+                }
+            }
+            catch (error) {
+                failed = true;
+                throw error;
+            }
+            finally {
+                if (!complete)
+                    await finishCleanup(() => iterator.return?.(), failed);
+            }
+        }
+        options.signal?.throwIfAborted();
+    }
     async realpath(path, options = {}) {
         return this.run(options, async () => (await this.required(path, options)).path, false);
     }

package/node_modules/tiny-stdio-mcp-server/dist/composition.json

@@ -8,7 +8,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.765",
+      "version": "0.0.767",
       "license": "MIT"
     }
   ]

package/node_modules/toolcraft-schema/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft-schema",
-  "version": "0.0.765",
+  "version": "0.0.767",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft",
-  "version": "0.0.765",
+  "version": "0.0.767",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
@@ -175,7 +175,7 @@
     "@poe-code/terminal-text"
   ],
   "optionalDependencies": {
-    "toolcraft-schema": "0.0.765",
+    "toolcraft-schema": "0.0.767",
     "toolcraft-design": "*",
     "@poe-code/frontmatter": "*",
     "@poe-code/agent-mcp-config": "*",