@tangle-network/agent-runtime 0.94.5 → 0.94.7

package/dist/{chunk-KHLE3C5G.js → chunk-HKMKUESZ.js}

@@ -1442,8 +1442,23 @@ async function verifyMaterializedWorkspace(root, expected, options = {}) {
   const observed = await scanWorkspace(root, new Set(options.ignoredProtectedRootEntries ?? []));
   assertWorkspaceManifest(observed.manifest, expected);
 }
+async function captureMaterializedWorkspace(root, options = {}) {
+  const observed = await scanWorkspace(
+    root,
+    new Set(options.ignoredProtectedRootEntries ?? []),
+    options.limits
+  );
+  return {
+    manifest: observed.manifest,
+    files: observed.files.map((file) => ({
+      path: file.path,
+      mode: file.mode,
+      bytes: Uint8Array.from(file.bytes)
+    }))
+  };
+}
 async function readMaterializedWorkspaceFiles(root, expected, options = {}) {
-  const observed = await scanWorkspace(root, new Set(options.ignoredProtectedRootEntries ?? []));
+  const observed = await captureMaterializedWorkspace(root, options);
   assertWorkspaceManifest(observed.manifest, expected);
   return observed.files.map(
     (file) => Object.freeze({ path: file.path, mode: file.mode, bytes: Uint8Array.from(file.bytes) })
@@ -1469,7 +1484,7 @@ async function verifyMaterializedProfileWorkspace(root, expected) {
     throw new Error("profile staging files, modes, or bytes do not match the signed profile plan");
   }
 }
-async function scanWorkspace(root, ignoredProtectedRootEntries) {
+async function scanWorkspace(root, ignoredProtectedRootEntries, limits) {
   const absoluteRoot = resolve(root);
   const rootStats = await lstat(absoluteRoot);
   if (!rootStats.isDirectory() || rootStats.isSymbolicLink()) {
@@ -1480,6 +1495,7 @@ async function scanWorkspace(root, ignoredProtectedRootEntries) {
   }
   const files = [];
   const capturedFiles = [];
+  let totalBytes = 0;
   async function visit(directory) {
     const entries = await readdir(directory, { withFileTypes: true });
     entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
@@ -1503,6 +1519,9 @@ async function scanWorkspace(root, ignoredProtectedRootEntries) {
       if (!stats.isFile()) {
         throw new Error(`workspace contains a non-regular entry: ${relPath}`);
       }
+      if (limits && files.length >= limits.maxFiles) {
+        throw new Error("workspace exceeds maxFiles");
+      }
       const descriptor = await open(
         absolute,
         fsConstants.O_RDONLY | (typeof fsConstants.O_NOFOLLOW === "number" ? fsConstants.O_NOFOLLOW : 0)
@@ -1519,7 +1538,19 @@ async function scanWorkspace(root, ignoredProtectedRootEntries) {
         if (mode !== 420 && mode !== 493) {
           throw new Error(`workspace file has unsupported mode ${mode.toString(8)}: ${relPath}`);
         }
-        const bytes = await descriptor.readFile();
+        if (limits && openedStats.size > limits.maxFileBytes) {
+          throw new Error(`workspace file exceeds maxFileBytes: ${relPath}`);
+        }
+        const remainingBytes = limits ? limits.maxTotalFileBytes - totalBytes : void 0;
+        if (remainingBytes !== void 0 && openedStats.size > remainingBytes) {
+          throw new Error("workspace exceeds maxTotalFileBytes");
+        }
+        const bytes = await readBoundedFile(
+          descriptor,
+          limits ? Math.min(limits.maxFileBytes, remainingBytes ?? limits.maxFileBytes) : void 0,
+          relPath
+        );
+        totalBytes += bytes.byteLength;
         const supportedMode = mode;
         files.push({
           path: relPath,
@@ -1545,6 +1576,21 @@ async function scanWorkspace(root, ignoredProtectedRootEntries) {
     files: capturedFiles
   };
 }
+async function readBoundedFile(descriptor, maxBytes, path) {
+  if (maxBytes === void 0) return await descriptor.readFile();
+  const chunks = [];
+  let total = 0;
+  while (true) {
+    const remaining = maxBytes - total;
+    const chunk = Buffer.allocUnsafe(Math.min(64 * 1024, remaining + 1));
+    const { bytesRead } = await descriptor.read(chunk, 0, chunk.byteLength, null);
+    if (bytesRead === 0) break;
+    total += bytesRead;
+    if (total > maxBytes) throw new Error(`workspace file exceeds its capture limit: ${path}`);
+    chunks.push(chunk.subarray(0, bytesRead));
+  }
+  return Buffer.concat(chunks, total);
+}
 
 // src/candidate-execution/git-materialize.ts
 import { spawn } from "child_process";
@@ -1563,16 +1609,18 @@ async function verifyCandidateCode(code, repositories, patchBytes) {
   const temporary = await mkdtemp(join(tmpdir(), "agent-candidate-git-"));
   try {
     const indexFile = join(temporary, "index");
-    await git(repositoryRoot, ["read-tree", code.baseTree], void 0, {
+    await runCandidateGit(repositoryRoot, ["read-tree", code.baseTree], void 0, {
       GIT_INDEX_FILE: indexFile
     });
-    await git(
+    await runCandidateGit(
       repositoryRoot,
       ["apply", "--cached", "--binary", "--whitespace=nowarn", "-"],
       patchBytes,
       { GIT_INDEX_FILE: indexFile }
     );
-    const candidateTree = (await git(repositoryRoot, ["write-tree"], void 0, { GIT_INDEX_FILE: indexFile })).stdout.toString("utf8").trim();
+    const candidateTree = (await runCandidateGit(repositoryRoot, ["write-tree"], void 0, {
+      GIT_INDEX_FILE: indexFile
+    })).stdout.toString("utf8").trim();
     if (candidateTree !== code.candidateTree) {
       throw new Error(
         `git patch materialized tree ${candidateTree} does not match ${code.candidateTree}`
@@ -1586,11 +1634,11 @@ async function verifyCandidateCode(code, repositories, patchBytes) {
 }
 async function readCandidateGitHubResource(resource, repositories) {
   const repositoryRoot = await verifiedRepositoryRoot(resource.repository, repositories);
-  const commitType = (await git(repositoryRoot, ["cat-file", "-t", resource.commit])).stdout.toString("utf8").trim();
+  const commitType = (await runCandidateGit(repositoryRoot, ["cat-file", "-t", resource.commit])).stdout.toString("utf8").trim();
   if (commitType !== "commit") {
     throw new Error(`GitHub resource commit is not a commit object: ${resource.commit}`);
   }
-  const listing = (await git(repositoryRoot, ["ls-tree", "-z", resource.commit, "--", resource.path])).stdout;
+  const listing = (await runCandidateGit(repositoryRoot, ["ls-tree", "-z", resource.commit, "--", resource.path])).stdout;
   const entries = parseTreeEntries(listing);
   if (entries.length !== 1 || entries[0]?.path !== resource.path) {
     throw new Error(`GitHub resource path is not one exact file: ${resource.path}`);
@@ -1599,17 +1647,17 @@ async function readCandidateGitHubResource(resource, repositories) {
   if (!entry || entry.type !== "blob" || entry.mode !== "100644" && entry.mode !== "100755") {
     throw new Error(`GitHub resource path is not a regular Git blob: ${resource.path}`);
   }
-  const bytes = (await git(repositoryRoot, ["cat-file", "blob", entry.object])).stdout;
+  const bytes = (await runCandidateGit(repositoryRoot, ["cat-file", "blob", entry.object])).stdout;
   verifyBytes(bytes, resource.sha256, resource.byteLength, `GitHub resource ${resource.path}`);
   return Uint8Array.from(bytes);
 }
 async function verifyTaskCheckout(taskRoot, expected) {
   const root = resolve2(taskRoot);
-  const head = (await git(root, ["rev-parse", "HEAD"])).stdout.toString("utf8").trim();
+  const head = (await runCandidateGit(root, ["rev-parse", "HEAD"])).stdout.toString("utf8").trim();
   if (head !== expected.baseCommit) {
     throw new Error(`task checkout HEAD ${head} does not match ${expected.baseCommit}`);
   }
-  const tree = (await git(root, ["rev-parse", "HEAD^{tree}"])).stdout.toString("utf8").trim();
+  const tree = (await runCandidateGit(root, ["rev-parse", "HEAD^{tree}"])).stdout.toString("utf8").trim();
   if (tree !== expected.baseTree) {
     throw new Error(`task checkout base tree ${tree} does not match ${expected.baseTree}`);
   }
@@ -1618,7 +1666,7 @@ async function verifyTaskOutcomePatch(input) {
   const repositoryRoot = resolve2(input.repositoryRoot);
   await verifyTaskCheckout(repositoryRoot, input);
   const gitDir = resolve2(
-    (await git(repositoryRoot, ["rev-parse", "--absolute-git-dir"])).stdout.toString("utf8").trim()
+    (await runCandidateGit(repositoryRoot, ["rev-parse", "--absolute-git-dir"])).stdout.toString("utf8").trim()
   );
   if (await realpath2(gitDir) !== gitDir || gitDir.includes(":")) {
     throw new Error("task Git object store has an unsupported path");
@@ -1634,16 +1682,16 @@ async function verifyTaskOutcomePatch(input) {
       GIT_OBJECT_DIRECTORY: objectDirectory,
       GIT_ALTERNATE_OBJECT_DIRECTORIES: join(gitDir, "objects")
     };
-    await git(repositoryRoot, ["read-tree", input.baseTree], void 0, gitEnvironment);
+    await runCandidateGit(repositoryRoot, ["read-tree", input.baseTree], void 0, gitEnvironment);
     if (input.patch.byteLength > 0) {
-      await git(
+      await runCandidateGit(
         repositoryRoot,
         ["apply", "--cached", "--binary", "--whitespace=nowarn", "-"],
         input.patch,
         gitEnvironment
       );
     }
-    const resultTree = (await git(repositoryRoot, ["write-tree"], void 0, gitEnvironment)).stdout.toString("utf8").trim();
+    const resultTree = (await runCandidateGit(repositoryRoot, ["write-tree"], void 0, gitEnvironment)).stdout.toString("utf8").trim();
     if (resultTree !== input.resultTree) {
       throw new Error(
         `task outcome patch materialized tree ${resultTree} does not match ${input.resultTree}`
@@ -1656,7 +1704,7 @@ async function verifyTaskOutcomePatch(input) {
     )) {
       throw new Error("task outcome after-state does not match the materialized result tree");
     }
-    const resultCommit = (await git(
+    const resultCommit = (await runCandidateGit(
       repositoryRoot,
       ["commit-tree", resultTree, "-p", input.baseCommit],
       Buffer.from("candidate task outcome\n", "utf8"),
@@ -1670,7 +1718,12 @@ async function verifyTaskOutcomePatch(input) {
         GIT_COMMITTER_DATE: "2000-01-01T00:00:00Z"
       }
     )).stdout.toString("utf8").trim();
-    const committedTree = (await git(repositoryRoot, ["rev-parse", `${resultCommit}^{tree}`], void 0, gitEnvironment)).stdout.toString("utf8").trim();
+    const committedTree = (await runCandidateGit(
+      repositoryRoot,
+      ["rev-parse", `${resultCommit}^{tree}`],
+      void 0,
+      gitEnvironment
+    )).stdout.toString("utf8").trim();
     if (committedTree !== resultTree) {
       throw new Error("task outcome evaluator commit does not bind the verified result tree");
     }
@@ -1683,41 +1736,55 @@ async function verifiedRepositoryRoot(repository, repositories) {
   const repositoryRoot = resolve2(await repositories.resolve(repository));
   const rootStats = await stat(repositoryRoot);
   if (!rootStats.isDirectory()) throw new Error("candidate repository path is not a directory");
-  const origin = (await git(repositoryRoot, ["remote", "get-url", "origin"])).stdout.toString("utf8").trim();
+  const origin = (await runCandidateGit(repositoryRoot, ["remote", "get-url", "origin"])).stdout.toString("utf8").trim();
   const actual = parseGitHubRemote(origin);
   if (!actual || actual.owner !== repository.owner || actual.repo !== repository.repo) {
     throw new Error(
       `local repository origin ${origin || "<missing>"} does not match github.com/${repository.owner}/${repository.repo}`
     );
   }
-  const gitDirText = (await git(repositoryRoot, ["rev-parse", "--absolute-git-dir"])).stdout.toString("utf8").trim();
+  const gitDirText = (await runCandidateGit(repositoryRoot, ["rev-parse", "--absolute-git-dir"])).stdout.toString("utf8").trim();
   const gitDir = resolve2(gitDirText);
   await assertNoGitIndirection(repositoryRoot, gitDir, "candidate repository");
   return repositoryRoot;
 }
 async function assertNoGitIndirection(repositoryRoot, gitDir, label) {
-  const replacements = (await git(repositoryRoot, ["for-each-ref", "--format=%(refname)", "refs/replace"])).stdout.toString("utf8").trim();
+  const replacements = (await runCandidateGit(repositoryRoot, ["for-each-ref", "--format=%(refname)", "refs/replace"])).stdout.toString("utf8").trim();
   if (replacements) throw new Error(`${label} contains Git replace refs`);
-  for (const name of ["alternates", "http-alternates"]) {
-    const path = join(gitDir, "objects", "info", name);
-    try {
-      const contents = await readFile2(path, "utf8");
-      if (contents.trim()) throw new Error(`${label} uses forbidden Git ${name}`);
-    } catch (error) {
-      if (!isNoEntry(error)) throw error;
+  const commonDir = resolve2(
+    repositoryRoot,
+    (await runCandidateGit(repositoryRoot, ["rev-parse", "--git-common-dir"])).stdout.toString("utf8").trim()
+  );
+  if (await realpath2(commonDir) !== commonDir || commonDir.includes(":")) {
+    throw new Error(`${label} Git common directory has an unsupported path`);
+  }
+  for (const objectRoot of /* @__PURE__ */ new Set([gitDir, commonDir])) {
+    for (const name of ["alternates", "http-alternates"]) {
+      const path = join(objectRoot, "objects", "info", name);
+      try {
+        const contents = await readFile2(path, "utf8");
+        if (contents.trim()) throw new Error(`${label} uses forbidden Git ${name}`);
+      } catch (error) {
+        if (!isNoEntry(error)) throw error;
+      }
     }
   }
 }
 async function assertCommitAndBaseTree(repositoryRoot, commit, expectedTree) {
-  const type = (await git(repositoryRoot, ["cat-file", "-t", commit])).stdout.toString("utf8").trim();
+  const type = (await runCandidateGit(repositoryRoot, ["cat-file", "-t", commit])).stdout.toString("utf8").trim();
   if (type !== "commit") throw new Error(`candidate base object is not a commit: ${commit}`);
-  const actualTree = (await git(repositoryRoot, ["rev-parse", `${commit}^{tree}`])).stdout.toString("utf8").trim();
+  const actualTree = (await runCandidateGit(repositoryRoot, ["rev-parse", `${commit}^{tree}`])).stdout.toString("utf8").trim();
   if (actualTree !== expectedTree) {
     throw new Error(`candidate base commit tree ${actualTree} does not match ${expectedTree}`);
   }
 }
 async function assertSafeTree(repositoryRoot, tree, environment = {}) {
-  const listing = (await git(repositoryRoot, ["ls-tree", "-rz", "--full-tree", tree], void 0, environment)).stdout;
+  const listing = (await runCandidateGit(
+    repositoryRoot,
+    ["ls-tree", "-rz", "--full-tree", tree],
+    void 0,
+    environment
+  )).stdout;
   const entries = parseTreeEntries(listing);
   if (entries.length === 0) throw new Error("candidate Git tree cannot be empty");
   for (const entry of entries) {
@@ -1730,29 +1797,65 @@ async function assertSafeTree(repositoryRoot, tree, environment = {}) {
   }
 }
 async function workspaceManifestFromGitTree(repositoryRoot, tree, environment) {
-  const listing = (await git(repositoryRoot, ["ls-tree", "-rz", "--full-tree", tree], void 0, environment)).stdout;
-  const entries = parseTreeEntries(listing);
-  const files = await Promise.all(
-    entries.map(async (entry) => {
-      if (entry.type !== "blob" || entry.mode !== "100644" && entry.mode !== "100755") {
-        throw new Error(`task outcome tree contains a non-regular file: ${entry.path}`);
-      }
-      const bytes = (await git(repositoryRoot, ["cat-file", "blob", entry.object], void 0, environment)).stdout;
-      return {
-        path: entry.path,
-        mode: entry.mode === "100755" ? 493 : 420,
-        sha256: sha256Bytes(bytes),
-        byteLength: bytes.byteLength
-      };
+  const files = (await readCandidateGitTreeFiles(repositoryRoot, tree, environment)).map(
+    ({ path, mode, bytes }) => ({
+      path,
+      mode,
+      sha256: sha256Bytes(bytes),
+      byteLength: bytes.byteLength
     })
   );
-  files.sort((left, right) => left.path.localeCompare(right.path));
   return {
     schemaVersion: 1,
     kind: "agent-candidate-workspace-manifest",
     files
   };
 }
+async function readCandidateGitTreeFiles(repositoryRoot, tree, environment = {}, limits) {
+  const listing = (await runCandidateGit(
+    repositoryRoot,
+    ["ls-tree", "-rzl", "--full-tree", tree],
+    void 0,
+    environment
+  )).stdout;
+  const files = [];
+  const entries = parseTreeEntries(listing);
+  if (limits && entries.length > limits.maxFiles) {
+    throw new Error("candidate Git tree exceeds maxFiles");
+  }
+  let totalBytes = 0;
+  for (const entry of entries) {
+    if (entry.type !== "blob" || entry.mode !== "100644" && entry.mode !== "100755") {
+      throw new Error(`candidate Git tree contains a non-regular file: ${entry.path}`);
+    }
+    assertSafeGitPath(entry.path);
+    if (entry.size === void 0) {
+      throw new Error(`candidate Git tree is missing blob size: ${entry.path}`);
+    }
+    if (limits && entry.size > limits.maxFileBytes) {
+      throw new Error(`candidate Git tree file exceeds maxFileBytes: ${entry.path}`);
+    }
+    totalBytes += entry.size;
+    if (limits && totalBytes > limits.maxTotalFileBytes) {
+      throw new Error("candidate Git tree exceeds maxTotalFileBytes");
+    }
+    const bytes = (await runCandidateGit(
+      repositoryRoot,
+      ["cat-file", "blob", entry.object],
+      void 0,
+      environment
+    )).stdout;
+    if (bytes.byteLength !== entry.size) {
+      throw new Error(`candidate Git blob size changed: ${entry.path}`);
+    }
+    files.push({
+      path: entry.path,
+      mode: entry.mode === "100755" ? 493 : 420,
+      bytes: Uint8Array.from(bytes)
+    });
+  }
+  return files.sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
+}
 function parseTreeEntries(bytes) {
   const raw = Buffer.from(bytes);
   const decoded = raw.toString("utf8");
@@ -1762,13 +1865,17 @@ function parseTreeEntries(bytes) {
   const rows = decoded.split("\0").filter(Boolean);
   return rows.map((row) => {
     const tab = row.indexOf("	");
-    const header = row.slice(0, tab).split(" ");
+    const header = row.slice(0, tab).split(" ").filter(Boolean);
     const path = row.slice(tab + 1);
-    const [mode, type, object] = header;
+    const [mode, type, object, sizeText] = header;
     if (tab < 1 || !mode || !type || !object || !path) {
       throw new Error("malformed Git tree entry");
     }
-    return { mode, type, object, path };
+    const size = sizeText && /^\d+$/.test(sizeText) ? Number(sizeText) : void 0;
+    if (size !== void 0 && !Number.isSafeInteger(size)) {
+      throw new Error("candidate Git tree entry size exceeds the safe integer range");
+    }
+    return { mode, type, object, ...size === void 0 ? {} : { size }, path };
   });
 }
 function assertSafeGitPath(path) {
@@ -1790,7 +1897,7 @@ function parseGitHubRemote(value) {
   if (!match?.[1] || !match[2]) return void 0;
   return { owner: match[1], repo: match[2] };
 }
-async function git(repositoryRoot, args, input, extraEnv = {}) {
+async function runCandidateGit(repositoryRoot, args, input, extraEnv = {}) {
   const env = Object.fromEntries(
     Object.entries(process.env).filter(([name]) => !name.startsWith("GIT_"))
   );
@@ -1807,6 +1914,10 @@ async function git(repositoryRoot, args, input, extraEnv = {}) {
     "-c",
     "core.hooksPath=/dev/null",
     "-c",
+    "core.fsmonitor=false",
+    "-c",
+    "core.untrackedCache=false",
+    "-c",
     "protocol.file.allow=never",
     "-C",
     repositoryRoot,
@@ -5032,12 +5143,14 @@ function errorMessage2(error) {
 }
 
 export {
+  sha256Bytes,
   canonicalCandidateBytes,
   canonicalCandidateDigest,
   immutableCandidateValue,
   canonicalCandidateDocument,
   embeddedCandidateArtifact,
   omitTopLevelDigest,
+  deepFreezeCandidate,
   sealAgentCandidateBundle,
   freezeGenericAgentCandidateProfile,
   assertCandidateProfileBinding,
@@ -5063,6 +5176,12 @@ export {
   candidateCleanupTimeout,
   candidateCleanupDeadline,
   withinCandidateCleanupDeadline,
+  verifyBytes,
+  verifyMaterializedWorkspace,
+  captureMaterializedWorkspace,
+  assertNoGitIndirection,
+  readCandidateGitTreeFiles,
+  runCandidateGit,
   CANDIDATE_TRACE_TAGS,
   CANDIDATE_TRACE_ENV,
   assertPreparedCandidateIntegrity,
@@ -5081,4 +5200,4 @@ export {
   verifyAgentCandidateBundle,
   prepareAgentCandidateExecution
 };
-//# sourceMappingURL=chunk-KHLE3C5G.js.map
+//# sourceMappingURL=chunk-HKMKUESZ.js.map