@iseoane/agent-depot 0.6.8 → 0.6.9

package/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.6.9] - 2026-11-04
+
+### Fixed
+
+- Catalog and Installations now read cached Git Source manifests in a bounded
+  batch instead of starting a Git process per file. Readers share small immutable
+  snapshots for the same repository, directory scope and commit, while resolving
+  the current ref again on every read. Host state and operation safety checks
+  remain fresh; opening a view does not refresh its Sources.
+
 ## [0.6.8] - 2026-11-04
 
 ### Fixed

package/dist/src/git-source.js

@@ -5,6 +5,7 @@ import path from "node:path";
 import { isLockContention } from "./atomic-file.js";
 import { assertNoSymlinkPath } from "./path-safety.js";
 import { runProcess } from "./process-runner.js";
+import { decodeSnapshotBatch, reuseSourceSnapshot, SOURCE_SNAPSHOT_LIMITS } from "./source-snapshot.js";
 export const SKILL_TREE_LIMITS = Object.freeze({
     maxFiles: 256,
     maxFileBytes: 2 * 1024 * 1024,
@@ -62,11 +63,14 @@ class NodeGitSnapshotCommandRunner {
     async runBinary(command, args, options = {}) {
         const result = await runProcess(command, args, {
             captureStdout: true,
+            ...(options.stdin === undefined ? {} : { stdin: options.stdin, timeoutMs: 30_000, maxStderrBytes: 64 * 1024 }),
             ...(options.maxOutputBytes === undefined ? {} : { maxOutputBytes: options.maxOutputBytes }),
         });
         if (result.outputTooLarge) {
             throw new Error("git command output exceeds the safe size limit");
         }
+        if (result.timedOut)
+            throw new Error("git command timed out");
         if (result.code !== 0) {
             throw new Error(`git command failed: ${gitFailureDetail(result)}`);
         }
@@ -168,12 +172,13 @@ function parseSkillTreeRecord(record, relativeSkillPath) {
     }
     return { relativePath, objectId, executable: mode === "100755" };
 }
+const defaultSnapshotRunner = new NodeGitSnapshotCommandRunner();
 export class GitSourceSnapshotAccess {
     cachePath;
     runner;
     constructor(options = {}) {
         this.cachePath = options.cachePath ?? defaultGitSourceCachePath();
-        this.runner = options.runner ?? new NodeGitSnapshotCommandRunner();
+        this.runner = options.runner ?? defaultSnapshotRunner;
     }
     async requireMirror(source) {
         const destination = cachePathForSource(this.cachePath, source);
@@ -278,37 +283,46 @@ export class GitSourceSnapshotAccess {
     }
     async readSnapshot(source) {
         const destination = await this.requireMirror(source);
+        // Resolve on every read, even on a cache hit: refs can change outside Agent Depot.
         const commit = await this.readResolvedCommit(source);
         const directory = gitSourceLocation(source.url).directory;
-        const tree = await this.runner.run("git", [
-            "--git-dir", destination, "ls-tree", "-r", "-z", commit,
-            ...(directory === undefined ? [] : ["--", directory]),
-        ]);
-        const files = [];
-        for (const record of tree.split("\0")) {
-            if (!record) {
-                continue;
-            }
-            const separator = record.indexOf("\t");
-            if (separator < 0) {
-                continue;
+        const key = JSON.stringify([path.resolve(destination), commit, directory]);
+        return reuseSourceSnapshot(this.runner, key, async () => {
+            const tree = await this.runner.run("git", [
+                "--no-replace-objects", "--git-dir", destination, "ls-tree", "-r", "-z", commit,
+                ...(directory === undefined ? [] : ["--", directory]),
+            ], { maxOutputBytes: SKILL_TREE_LIMITS.maxListingBytes });
+            if (tree !== "" && !tree.endsWith("\0"))
+                throw new Error("Truncated Git snapshot listing");
+            const entries = [];
+            for (const record of tree.split("\0")) {
+                if (!record)
+                    continue;
+                const separator = record.indexOf("\t");
+                if (separator < 0)
+                    throw new Error("Malformed Git snapshot listing");
+                const [mode, type, objectId] = record.slice(0, separator).split(" ");
+                const relativePath = record.slice(separator + 1);
+                if (mode === "120000" || type !== "blob" || !relativePath
+                    || (directory !== undefined && !relativePath.startsWith(`${directory}/`))
+                    || !isSourceSnapshotFile(relativePath, directory)
+                    || relativePath.split("/").slice(0, -1).some(segment => EXCLUDED_LIFECYCLE_SEGMENTS.has(segment)))
+                    continue;
+                if (!/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u.test(objectId)
+                    || !["100644", "100755"].includes(mode))
+                    throw new Error("Unsafe Git snapshot entry");
+                entries.push({ path: relativePath, objectId });
+                if (entries.length > SOURCE_SNAPSHOT_LIMITS.maxFiles)
+                    throw new Error("Git snapshot exceeds file count limit");
             }
-            const metadata = record.slice(0, separator).split(" ");
-            const relativePath = record.slice(separator + 1);
-            if (metadata[0] === "120000"
-                || metadata[1] !== "blob"
-                || !relativePath
-                || (directory !== undefined && !relativePath.startsWith(`${directory}/`))
-                || !isSourceSnapshotFile(relativePath, directory)
-                || relativePath.split("/").slice(0, -1).some((segment) => EXCLUDED_LIFECYCLE_SEGMENTS.has(segment))) {
-                continue;
-            }
-            files.push({
-                path: relativePath,
-                content: await this.runner.run("git", ["--git-dir", destination, "show", `${commit}:${relativePath}`]),
+            if (entries.length === 0)
+                return Object.freeze([]);
+            const output = await this.runner.runBinary("git", ["--no-replace-objects", "--git-dir", destination, "cat-file", "--batch"], {
+                stdin: Buffer.from(entries.map(entry => `${entry.objectId}\n`).join("")),
+                maxOutputBytes: SOURCE_SNAPSHOT_LIMITS.maxTotalBytes + entries.length * 130,
             });
-        }
-        return Object.freeze(files);
+            return decodeSnapshotBatch(output, entries);
+        });
     }
     /** File paths at or under `root`, from the same immutable commit as the other reads. */
     async listFiles(source, root) {

package/dist/src/process-runner.js

@@ -151,6 +151,10 @@ function signalProcesses(pids, signal) {
  */
 export function runProcess(command, args, options = {}) {
     return new Promise((resolve, reject) => {
+        if (options.stdin !== undefined && options.stdin.byteLength > 1024 * 1024) {
+            reject(new Error("Process stdin exceeds the safe size limit"));
+            return;
+        }
         const invocation = spawnInvocation(command, args);
         const sink = childOutputSinks.getStore();
         const child = spawn(invocation.command, [...invocation.args], {
@@ -158,7 +162,7 @@ export function runProcess(command, args, options = {}) {
             shell: false,
             windowsVerbatimArguments: invocation.windowsVerbatimArguments,
             // Without a capture, stdout is piped only for a sink, and then discarded after it is shown.
-            stdio: ["ignore", options.captureStdout || sink !== undefined ? "pipe" : "ignore", "pipe"],
+            stdio: [options.stdin === undefined ? "ignore" : "pipe", options.captureStdout || sink !== undefined ? "pipe" : "ignore", "pipe"],
         });
         const stdout = [];
         let stdoutBytes = 0;
@@ -189,6 +193,7 @@ export function runProcess(command, args, options = {}) {
         };
         // A surviving descendant keeps the pipes open, so `close` may never come: give up on them.
         const giveUp = () => {
+            child.stdin?.destroy();
             child.stdout?.destroy();
             child.stderr?.destroy();
             settle(child.exitCode, child.signalCode);
@@ -263,5 +268,11 @@ export function runProcess(command, args, options = {}) {
         });
         child.on("error", reject);
         child.on("close", settle);
+        child.stdin?.on("error", (error) => {
+            // Windows reports EOF when a child exits with input still pending.
+            if (error.code !== "EPIPE" && error.code !== "EOF")
+                reject(error);
+        });
+        child.stdin?.end(options.stdin);
     });
 }

package/dist/src/source-snapshot.js

@@ -0,0 +1,59 @@
+export const SOURCE_SNAPSHOT_LIMITS = Object.freeze({
+    maxFiles: 4096, maxFileBytes: 2 * 1024 * 1024, maxTotalBytes: 32 * 1024 * 1024,
+});
+/** Git batch payloads are byte framed: contents may themselves contain newlines or NULs. */
+export function decodeSnapshotBatch(output, entries) {
+    const bytes = Buffer.from(output);
+    let offset = 0;
+    let total = 0;
+    const files = entries.map(entry => {
+        const end = bytes.indexOf(10, offset);
+        if (end < offset || end - offset > 128)
+            throw new Error("Malformed Git batch header");
+        const header = bytes.subarray(offset, end).toString("utf8").split(" ");
+        const size = Number(header[2]);
+        if (header.length !== 3 || header[0] !== entry.objectId || header[1] !== "blob"
+            || !/^\d+$/u.test(header[2]) || !Number.isSafeInteger(size) || size > SOURCE_SNAPSHOT_LIMITS.maxFileBytes) {
+            throw new Error("Invalid Git batch object or size limit");
+        }
+        total += size;
+        if (total > SOURCE_SNAPSHOT_LIMITS.maxTotalBytes)
+            throw new Error("Git snapshot exceeds total size limit");
+        offset = end + 1;
+        if (offset + size >= bytes.length || bytes[offset + size] !== 10)
+            throw new Error("Truncated Git batch object");
+        const content = bytes.subarray(offset, offset + size).toString("utf8");
+        offset += size + 1;
+        return Object.freeze({ path: entry.path, content });
+    });
+    if (offset !== bytes.length)
+        throw new Error("Unexpected trailing Git batch output");
+    return Object.freeze(files);
+}
+// Default readers share immutable work; injected runners have separate cache domains.
+// Only small results are retained, with at most eight entries per runner (32 MiB of UTF-8 data).
+const caches = new WeakMap();
+export function reuseSourceSnapshot(owner, key, load) {
+    let cache = caches.get(owner);
+    if (!cache) {
+        cache = new Map();
+        caches.set(owner, cache);
+    }
+    const hit = cache.get(key);
+    if (hit) {
+        cache.delete(key);
+        cache.set(key, hit);
+        return hit;
+    }
+    const pending = load();
+    const remove = () => { if (cache.get(key) === pending)
+        cache.delete(key); };
+    cache.set(key, pending);
+    if (cache.size > 8)
+        cache.delete(cache.keys().next().value);
+    void pending.then(files => {
+        if (files.reduce((size, file) => size + Buffer.byteLength(file.content, "utf8"), 0) > 4 * 1024 * 1024)
+            remove();
+    }, remove);
+    return pending;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iseoane/agent-depot",
-  "version": "0.6.8",
+  "version": "0.6.9",
   "description": "A cross-platform catalog for reusable coding-agent skills.",
   "license": "MIT",
   "author": "iseoane",