opencode-swarm 7.136.1 → 7.136.2

package/dist/cli/index-y8552snf.js

@@ -0,0 +1,264 @@
+// @bun
+// src/evaluation/hashing.ts
+import { createHash } from "crypto";
+import { lstatSync, realpathSync } from "fs";
+import { lstat, opendir, readFile, realpath } from "fs/promises";
+import * as path from "path";
+function canonicalize(value, ancestors) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value))
+      throw new TypeError("canonical JSON rejects non-finite numbers");
+    return Object.is(value, -0) ? 0 : value;
+  }
+  if (value === undefined)
+    return;
+  if (typeof value !== "object") {
+    throw new TypeError(`canonical JSON cannot encode ${typeof value}`);
+  }
+  if (ancestors.has(value))
+    throw new TypeError("canonical JSON rejects cyclic values");
+  ancestors.add(value);
+  try {
+    if (Array.isArray(value)) {
+      return value.map((entry) => {
+        const encoded = canonicalize(entry, ancestors);
+        return encoded === undefined ? null : encoded;
+      });
+    }
+    const record = value;
+    const result = {};
+    for (const key of Object.keys(record).sort()) {
+      const encoded = canonicalize(record[key], ancestors);
+      if (encoded !== undefined)
+        result[key] = encoded;
+    }
+    return result;
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function canonicalJson(value) {
+  return JSON.stringify(canonicalize(value, new Set));
+}
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function canonicalHash(value) {
+  return sha256(canonicalJson(value));
+}
+function contentHashWithout(value, keys) {
+  const copy = { ...value };
+  for (const key of keys)
+    delete copy[key];
+  return canonicalHash(copy);
+}
+function computeTaskContentHash(task) {
+  return contentHashWithout(task, ["contentHash"]);
+}
+async function computeCandidateInputContentHash(projectRoot, candidate) {
+  const payload = await hashTree(projectRoot, candidate.payloadPath, createHashBudget({ maxFiles: 5000, maxBytes: 50 * 1024 * 1024 }));
+  return canonicalHash({
+    candidate: JSON.parse(canonicalJson({ ...candidate, contentHash: undefined })),
+    payload
+  });
+}
+function createHashBudget(limits) {
+  return { entries: 0, bytes: 0, limits };
+}
+function chargeHashEntry(budget) {
+  budget.entries++;
+  if (budget.entries > budget.limits.maxFiles) {
+    throw new Error("evaluation input exceeds the canonical hashing budget");
+  }
+}
+async function closeDirectory(directory) {
+  try {
+    await directory.close();
+  } catch (error) {
+    if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "ERR_DIR_CLOSED") {
+      throw error;
+    }
+  }
+}
+function resolveTaskInputHashLimits(limits) {
+  const bounded = {
+    maxFiles: limits.maxFiles ?? 5000,
+    maxBytes: limits.maxBytes ?? 50 * 1024 * 1024
+  };
+  if (!Number.isSafeInteger(bounded.maxFiles) || bounded.maxFiles <= 0 || !Number.isSafeInteger(bounded.maxBytes) || bounded.maxBytes <= 0) {
+    throw new Error("task input hash limits must be positive safe integers");
+  }
+  return bounded;
+}
+async function hashTree(projectRoot, relativePath, budget) {
+  const target = await resolveContainedExistingPathAsync(projectRoot, relativePath);
+  const canonicalRoot = await _internals.realpath(projectRoot);
+  const entries = [];
+  const visit = async (absolutePath, entryAlreadyCharged = false) => {
+    const stat = await _internals.lstat(absolutePath);
+    if (stat.isSymbolicLink()) {
+      throw new Error(`evaluation input contains a symlink or reparse point: ${relativePath}`);
+    }
+    if (!entryAlreadyCharged)
+      chargeHashEntry(budget);
+    const relative2 = path.relative(canonicalRoot, absolutePath).replace(/\\/g, "/");
+    if (stat.isDirectory()) {
+      entries.push({ path: relative2, type: "directory" });
+      const children = [];
+      const directory = await _internals.opendir(absolutePath);
+      try {
+        while (true) {
+          const child = await directory.read();
+          if (!child)
+            break;
+          chargeHashEntry(budget);
+          children.push(child.name);
+        }
+      } finally {
+        await closeDirectory(directory);
+      }
+      for (const child of children.sort()) {
+        await visit(path.join(absolutePath, child), true);
+      }
+      return;
+    }
+    if (!stat.isFile()) {
+      throw new Error(`evaluation input must contain only regular files: ${relative2}`);
+    }
+    budget.bytes += stat.size;
+    if (budget.bytes > budget.limits.maxBytes) {
+      throw new Error("evaluation input exceeds the canonical hashing budget");
+    }
+    const content = await _internals.readFile(absolutePath);
+    entries.push({
+      path: relative2,
+      type: "file",
+      bytes: content.byteLength,
+      sha256: sha256(content)
+    });
+  };
+  await visit(target);
+  return entries;
+}
+async function computeTaskInputContentHash(projectRoot, task, limits = {}) {
+  const bounded = resolveTaskInputHashLimits(limits);
+  const budget = createHashBudget(bounded);
+  const inputTrees = [
+    ...await hashTree(projectRoot, task.instructionPath, budget),
+    ...await hashTree(projectRoot, task.environment.path, budget)
+  ];
+  if (task.scorer.kind === "project" && task.scorer.argv[0]) {
+    inputTrees.push(...await hashTree(projectRoot, task.scorer.argv[0], budget));
+  }
+  return canonicalHash({
+    task: JSON.parse(canonicalJson({ ...task, contentHash: undefined })),
+    inputs: inputTrees.sort((left, right) => `${left.path}\x00${left.type}`.localeCompare(`${right.path}\x00${right.type}`))
+  });
+}
+async function computeTaskLineageInputHash(projectRoot, task, limits = {}) {
+  const bounded = resolveTaskInputHashLimits(limits);
+  const budget = createHashBudget(bounded);
+  const normalizedTree = async (relativePath) => {
+    const canonicalRoot = await _internals.realpath(projectRoot);
+    const target = await resolveContainedExistingPathAsync(projectRoot, relativePath);
+    const targetRelative = path.relative(canonicalRoot, target).replace(/\\/g, "/");
+    return (await hashTree(projectRoot, relativePath, budget)).map((entry) => ({
+      ...entry,
+      path: path.posix.relative(targetRelative, entry.path) || "."
+    }));
+  };
+  const scorerArgv = [...task.scorer.argv];
+  const projectScorer = task.scorer.kind === "project" && scorerArgv[0] ? await normalizedTree(scorerArgv[0]) : undefined;
+  if (projectScorer)
+    scorerArgv[0] = "<project-scorer>";
+  return canonicalHash({
+    instruction: await normalizedTree(task.instructionPath),
+    environment: {
+      kind: task.environment.kind,
+      tree: await normalizedTree(task.environment.path)
+    },
+    scorer: {
+      kind: task.scorer.kind,
+      argv: scorerArgv,
+      timeoutMs: task.scorer.timeoutMs,
+      scoreRange: task.scorer.scoreRange,
+      projectScorer
+    }
+  });
+}
+function computeTaskSetContentHash(snapshot) {
+  return contentHashWithout(snapshot, ["contentHash", "createdAt"]);
+}
+function computeRunIntegrityHash(run) {
+  return contentHashWithout(run, [
+    "integrityHash"
+  ]);
+}
+function computeManifestContentHash(manifest) {
+  return contentHashWithout(manifest, ["contentHash"]);
+}
+function isWithin(root, candidate) {
+  const relative2 = path.relative(root, candidate);
+  return relative2 === "" || !relative2.startsWith("..") && !path.isAbsolute(relative2);
+}
+function resolveContainedExistingPath(root, relativePath) {
+  if (path.isAbsolute(relativePath) || /^(?:[A-Za-z]:[\\/]|[\\/]{1,2})/.test(relativePath) || relativePath.includes("\x00")) {
+    throw new Error("evaluation path must be a non-NUL relative path");
+  }
+  const segments = relativePath.replace(/\\/g, "/").split("/").filter(Boolean);
+  if (segments.length === 0 || segments.some((segment) => segment === "..")) {
+    throw new Error("evaluation path traversal is not allowed");
+  }
+  const canonicalRoot = realpathSync(root);
+  let cursor = canonicalRoot;
+  for (const segment of segments) {
+    if (segment === ".")
+      continue;
+    cursor = path.join(cursor, segment);
+    const stat = lstatSync(cursor);
+    if (stat.isSymbolicLink()) {
+      throw new Error(`evaluation path contains a symlink or reparse point: ${relativePath}`);
+    }
+  }
+  const canonicalCandidate = realpathSync(cursor);
+  if (!isWithin(canonicalRoot, canonicalCandidate)) {
+    throw new Error("evaluation path escapes its admitted root");
+  }
+  return canonicalCandidate;
+}
+async function resolveContainedExistingPathAsync(root, relativePath) {
+  if (path.isAbsolute(relativePath) || /^(?:[A-Za-z]:[\\/]|[\\/]{1,2})/.test(relativePath) || relativePath.includes("\x00")) {
+    throw new Error("evaluation path must be a non-NUL relative path");
+  }
+  const segments = relativePath.replace(/\\/g, "/").split("/").filter(Boolean);
+  if (segments.length === 0 || segments.some((segment) => segment === "..")) {
+    throw new Error("evaluation path traversal is not allowed");
+  }
+  const canonicalRoot = await _internals.realpath(root);
+  let cursor = canonicalRoot;
+  for (const segment of segments) {
+    if (segment === ".")
+      continue;
+    cursor = path.join(cursor, segment);
+    const stat = await _internals.lstat(cursor);
+    if (stat.isSymbolicLink()) {
+      throw new Error(`evaluation path contains a symlink or reparse point: ${relativePath}`);
+    }
+  }
+  const canonicalCandidate = await _internals.realpath(cursor);
+  if (!isWithin(canonicalRoot, canonicalCandidate)) {
+    throw new Error("evaluation path escapes its admitted root");
+  }
+  return canonicalCandidate;
+}
+var _internals = {
+  lstat,
+  opendir,
+  readFile,
+  realpath
+};
+
+export { canonicalJson, sha256, canonicalHash, contentHashWithout, computeTaskContentHash, computeCandidateInputContentHash, computeTaskInputContentHash, computeTaskLineageInputHash, computeTaskSetContentHash, computeRunIntegrityHash, computeManifestContentHash, resolveContainedExistingPath, resolveContainedExistingPathAsync, _internals };