@toon-protocol/rig 4.4.0 → 4.6.0

package/dist/{chunk-RL5XUWR4.js → chunk-DCGV6ALH.js}

@@ -1,15 +1,18 @@
 import {
   ARWEAVE_FETCH_TIMEOUT_MS,
   ARWEAVE_GATEWAYS,
+  MAINTAINERS_TAG,
+  MAX_ARWEAVE_TAGS_PER_EVENT,
   MissingIdentityError,
+  PAYOUT_TAG,
   authorizedStatusAuthors,
-  buildRepoAnnouncement,
   buildRepoRefs,
   defaultWebSocketFactory,
   isValidArweaveTxId,
+  parseMaintainers,
   queryRelay,
   resolveIdentity
-} from "./chunk-GWA3CSUR.js";
+} from "./chunk-JBFBD7HV.js";
 import {
   defaultDaemonPort,
   standaloneForced,
@@ -65,6 +68,203 @@ function createGitTag(opts) {
   return hashGitObject("tag", Buffer.from(lines.join("\n"), "utf-8"));
 }
 
+// src/repo-announcement.ts
+import { REPOSITORY_ANNOUNCEMENT_KIND } from "@toon-protocol/core/nip34";
+var RELAYS_TAG = "relays";
+var WEB_TAG = "web";
+var EARLIEST_UNIQUE_COMMIT_MARKER = "euc";
+function multiValueTag(name, values2) {
+  const kept = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values2) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0 || seen.has(trimmed)) continue;
+    seen.add(trimmed);
+    kept.push(trimmed);
+  }
+  return kept.length > 0 ? [[name, ...kept]] : [];
+}
+var named = (name) => (tag) => tag[0] === name;
+var SLOTS = /* @__PURE__ */ new Map([
+  ["d", { matches: named("d"), rewrite: (e) => [["d", e.repoId]] }],
+  [
+    "name",
+    {
+      matches: named("name"),
+      rewrite: (e) => e.name === void 0 ? null : [["name", e.name]]
+    }
+  ],
+  [
+    "description",
+    {
+      matches: named("description"),
+      rewrite: (e) => e.description === void 0 ? null : [["description", e.description]]
+    }
+  ],
+  [
+    "maintainers",
+    {
+      matches: named(MAINTAINERS_TAG),
+      rewrite: (e) => {
+        if (e.maintainers === void 0) return null;
+        const declared = parseMaintainers([
+          [MAINTAINERS_TAG, ...e.maintainers]
+        ]);
+        return declared.length > 0 ? [[MAINTAINERS_TAG, ...declared]] : [];
+      }
+    }
+  ],
+  [
+    "payout",
+    {
+      matches: named(PAYOUT_TAG),
+      rewrite: (e) => e.payout === void 0 ? null : e.payout ? [[PAYOUT_TAG, e.payout.chain, e.payout.address]] : []
+    }
+  ],
+  [
+    "relays",
+    {
+      matches: named(RELAYS_TAG),
+      rewrite: (e) => e.relays === void 0 ? null : e.relays ? multiValueTag(RELAYS_TAG, e.relays) : []
+    }
+  ],
+  [
+    "web",
+    {
+      matches: named(WEB_TAG),
+      rewrite: (e) => e.web === void 0 ? null : e.web ? multiValueTag(WEB_TAG, e.web) : []
+    }
+  ],
+  [
+    "euc",
+    {
+      // Only the euc marker is ours. Every other `r` tag is someone else's.
+      matches: (tag) => tag[0] === "r" && tag[2] === EARLIEST_UNIQUE_COMMIT_MARKER,
+      rewrite: (e) => e.earliestUniqueCommit === void 0 ? null : e.earliestUniqueCommit ? [["r", e.earliestUniqueCommit, EARLIEST_UNIQUE_COMMIT_MARKER]] : []
+    }
+  ]
+]);
+function slotOf(tag) {
+  for (const [slot, spec] of SLOTS) {
+    if (spec.matches(tag)) return slot;
+  }
+  return null;
+}
+function rewrittenSlots(edits) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [slot, spec] of SLOTS) {
+    const next = spec.rewrite(edits);
+    if (next !== null) out.set(slot, next);
+  }
+  return out;
+}
+function amendRepoAnnouncement(current, edits) {
+  const rewritten = rewrittenSlots(edits);
+  const tags = [["d", edits.repoId]];
+  const emitted = /* @__PURE__ */ new Set(["d"]);
+  for (const tag of current?.tags ?? []) {
+    const slot = slotOf(tag);
+    const replacement = slot === null ? void 0 : rewritten.get(slot);
+    if (slot === null || replacement === void 0) {
+      tags.push([...tag]);
+      continue;
+    }
+    if (emitted.has(slot)) continue;
+    for (const next of replacement) tags.push([...next]);
+    emitted.add(slot);
+  }
+  for (const [slot, replacement] of rewritten) {
+    if (emitted.has(slot)) continue;
+    for (const next of replacement) tags.push([...next]);
+    emitted.add(slot);
+  }
+  return {
+    kind: REPOSITORY_ANNOUNCEMENT_KIND,
+    content: current?.content ?? "",
+    tags,
+    created_at: Math.floor(Date.now() / 1e3)
+  };
+}
+function buildRepoAnnouncement(repoId, name, description, maintainers = [], payout) {
+  return amendRepoAnnouncement(null, {
+    repoId,
+    name,
+    description,
+    maintainers,
+    payout: payout ?? null
+  });
+}
+async function earliestUniqueCommit(reader) {
+  const all = await reader.rootCommits();
+  if (all.length === 0) return null;
+  if (all.length === 1) return all[0] ?? null;
+  const onDefaultBranch = await reader.rootCommits("HEAD");
+  const candidates = onDefaultBranch.length > 0 ? onDefaultBranch : all;
+  return [...candidates].sort()[0] ?? null;
+}
+function announcedEuc(current) {
+  for (const tag of current?.tags ?? []) {
+    if (tag[0] === "r" && tag[2] === EARLIEST_UNIQUE_COMMIT_MARKER) {
+      const sha = tag[1];
+      if (sha !== void 0 && sha.length > 0) return sha;
+    }
+  }
+  return null;
+}
+function unionValues(current, name, additions) {
+  const existing = [];
+  for (const tag of current?.tags ?? []) {
+    if (tag[0] === name) existing.push(...tag.slice(1));
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of [...existing, ...additions]) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0 || seen.has(trimmed)) continue;
+    seen.add(trimmed);
+    out.push(trimmed);
+  }
+  return out;
+}
+function conformanceEdits(current, facts) {
+  const edits = {};
+  const relays = unionValues(current, RELAYS_TAG, facts.relays);
+  if (relays.length > 0) edits.relays = relays;
+  const web = unionValues(current, WEB_TAG, facts.web === null ? [] : [facts.web]);
+  if (web.length > 0) edits.web = web;
+  if (announcedEuc(current) === null && facts.earliestUniqueCommit !== null) {
+    edits.earliestUniqueCommit = facts.earliestUniqueCommit;
+  }
+  return edits;
+}
+function tagKey(tag) {
+  return JSON.stringify(tag);
+}
+function diffAnnouncementTags(current, next) {
+  const remaining = /* @__PURE__ */ new Map();
+  for (const tag of current?.tags ?? []) {
+    remaining.set(tagKey(tag), (remaining.get(tagKey(tag)) ?? 0) + 1);
+  }
+  const added = [];
+  for (const tag of next.tags) {
+    const key = tagKey(tag);
+    const count = remaining.get(key) ?? 0;
+    if (count > 0) remaining.set(key, count - 1);
+    else added.push([...tag]);
+  }
+  const removed = [];
+  for (const [key, count] of remaining) {
+    for (let i = 0; i < count; i += 1) {
+      removed.push(JSON.parse(key));
+    }
+  }
+  return {
+    added,
+    removed,
+    unchanged: added.length === 0 && removed.length === 0
+  };
+}
+
 // src/repo-reader.ts
 import { execFile, spawn } from "child_process";
 import { promisify } from "util";
@@ -261,6 +461,140 @@ var GitRepoReader = class {
     }
     return objects;
   }
+  /**
+   * Run git and hand each stdout line to `visit` as it arrives, never holding
+   * the whole output in memory. Returning `false` from `visit` ends the walk:
+   * the child is killed and the promise resolves with what was seen.
+   *
+   * Every other git call here buffers into one `execFile` string, which is
+   * fine for bounded output. These object walks are not bounded — they grow
+   * with the size of the repository — so on a repo big enough to need the
+   * object-map cap they would be the thing that breaks (#162).
+   */
+  streamLines(args, visit) {
+    return new Promise((resolve, reject) => {
+      const child = spawn("git", args, {
+        cwd: this.repoPath,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let pending = "";
+      let stderr = "";
+      let settled = false;
+      const finish = (err) => {
+        if (settled) return;
+        settled = true;
+        if (err) reject(err);
+        else resolve();
+      };
+      child.stdout.setEncoding("utf-8");
+      child.stdout.on("data", (chunk) => {
+        if (settled) return;
+        pending += chunk;
+        let idx = pending.indexOf("\n");
+        while (idx !== -1) {
+          const line = pending.slice(0, idx);
+          pending = pending.slice(idx + 1);
+          if (line && !visit(line)) {
+            child.kill("SIGTERM");
+            return finish();
+          }
+          idx = pending.indexOf("\n");
+        }
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk.toString("utf-8");
+      });
+      child.on("error", (err) => {
+        finish(
+          new GitError(
+            `failed to spawn git ${args[0]}: ${err.message}`,
+            void 0,
+            ""
+          )
+        );
+      });
+      child.on("close", (code) => {
+        if (settled) return;
+        if (code !== 0) {
+          return finish(
+            new GitError(
+              `git ${args[0]} failed (exit ${code}): ${stderr.trim()}`,
+              code ?? void 0,
+              stderr.trim()
+            )
+          );
+        }
+        if (pending) visit(pending);
+        finish();
+      });
+    });
+  }
+  /**
+   * Every object SHA in the local object database, in no particular order
+   * (`git cat-file --batch-all-objects --batch-check`, no bodies read).
+   *
+   * This is the honest answer to "what does this repository already have",
+   * which `rig fetch` needs to compute its delta. It deliberately does NOT
+   * consult the remote's kind:30618 `arweave` map: that map is capped (#162)
+   * and is a hint cache, never an index of local presence.
+   *
+   * Streamed, so the listing never has to fit in one buffer.
+   */
+  async listAllObjectShas() {
+    const shas = [];
+    await this.streamLines(
+      [
+        "cat-file",
+        "--batch-check=%(objectname)",
+        "--batch-all-objects",
+        "--unordered"
+      ],
+      (line) => {
+        shas.push(line);
+        return true;
+      }
+    );
+    return shas;
+  }
+  /**
+   * SHAs of every object reachable from `tips`, newest first: commits in
+   * reverse-chronological order, each commit immediately followed by the
+   * trees and blobs it is the first to reference
+   * (`git rev-list --objects --in-commit-order`).
+   *
+   * Used to rank the kind:30618 object map when it exceeds
+   * `MAX_ARWEAVE_TAGS_PER_EVENT` (#162): the entries most likely to be wanted
+   * by the next clone or fetch are the ones nearest the tips. Tips that do
+   * not resolve locally (a remote ref we never fetched) are dropped rather
+   * than failing the walk.
+   *
+   * `limit` stops the walk once that many SHAs have been seen — the ranking
+   * caller never needs more than the cap, and a full walk of a repository big
+   * enough to hit the cap is exactly the work worth not doing. The walk is
+   * streamed, so neither its output nor this array is ever bigger than that.
+   */
+  async reachableObjectsNewestFirst(tips, limit = Infinity) {
+    for (const tip of tips) assertRevision(tip, "tip");
+    const known = await this.filterExisting([...new Set(tips)]);
+    if (known.length === 0 || limit < 1) return [];
+    const shas = [];
+    await this.streamLines(
+      [
+        "rev-list",
+        "--objects",
+        "--in-commit-order",
+        ...known,
+        "--"
+        // nothing user-supplied can become a pathspec
+      ],
+      (line) => {
+        const spaceIdx = line.indexOf(" ");
+        shas.push(spaceIdx === -1 ? line : line.slice(0, spaceIdx));
+        return shas.length < limit;
+      }
+    );
+    return shas;
+  }
   /**
    * List every blob (file) reachable from a ref's root tree, recursively,
    * with the path it is served at (#368: the ar.io site manifest join key).
@@ -485,6 +819,46 @@ var GitRepoReader = class {
     }
     return parents;
   }
+  /**
+   * SHAs of the repo's ROOT commits — the parentless commits a history starts
+   * from — via `git rev-list --max-parents=0`.
+   *
+   * The repo's *earliest unique commit* (NIP-34's `euc` fork-identity tag) is
+   * chosen from these; the choosing rule lives in `repo-announcement.ts`.
+   *
+   * @param rev - Consider only roots reachable from this revision. Omit for
+   *   every root in the repository (`--all`).
+   * @returns The roots in `rev-list` order, or `[]` when the revision does not
+   *   resolve — an unborn `HEAD` in a repo with no commits is not an error.
+   */
+  async rootCommits(rev) {
+    const args = ["rev-list", "--max-parents=0"];
+    if (rev === void 0) {
+      args.push("--all");
+    } else {
+      assertRevision(rev, "rev");
+      args.push(rev);
+    }
+    args.push("--");
+    const { stdout, exitCode } = await this.git(args, {
+      allowExitCodes: [128]
+    });
+    if (exitCode !== 0) return [];
+    const roots = [];
+    for (const line of stdout.split("\n")) {
+      const sha = line.trim();
+      if (!sha) continue;
+      if (!FULL_SHA_RE.test(sha)) {
+        throw new GitError(
+          `unexpected rev-list --max-parents=0 line: ${JSON.stringify(line)}`,
+          void 0,
+          ""
+        );
+      }
+      roots.push(sha);
+    }
+    return roots;
+  }
   /**
    * Resolve a ref/revision to a full SHA via `git rev-parse --verify`.
    * Throws {@link GitError} when the name doesn't resolve.
@@ -1140,6 +1514,7 @@ async function planPush(options) {
     if (refname !== headSymref) newRefs[refname] = sha;
   }
   const announceNeeded = !remoteState.announced;
+  const euc = announceNeeded ? await earliestUniqueCommit(repoReader) : null;
   const totalObjectBytes = objects.reduce((sum, o) => sum + o.size, 0);
   const uploadFee = objects.reduce(
     (sum, o) => sum + uploadChargeFor(feeRates, o.size),
@@ -1158,7 +1533,9 @@ async function planPush(options) {
     announceNeeded,
     announcement: {
       name: options.announcement?.name ?? repoId,
-      description: options.announcement?.description ?? ""
+      description: options.announcement?.description ?? "",
+      ...options.announcement?.web ? { web: options.announcement.web } : {},
+      ...euc ? { earliestUniqueCommit: euc } : {}
     },
     estimate: {
       objectCount: objects.length,
@@ -1172,6 +1549,32 @@ async function planPush(options) {
   };
 }
 var READ_BATCH_SIZE = 100;
+async function boundObjectMap(merged, plan, repoReader) {
+  if (merged.size <= MAX_ARWEAVE_TAGS_PER_EVENT) return merged;
+  const kept = /* @__PURE__ */ new Map();
+  const take = (sha) => {
+    if (kept.size >= MAX_ARWEAVE_TAGS_PER_EVENT || kept.has(sha)) return;
+    const txId = merged.get(sha);
+    if (txId !== void 0) kept.set(sha, txId);
+  };
+  for (const object of plan.objects) take(object.sha);
+  if (kept.size < MAX_ARWEAVE_TAGS_PER_EVENT) {
+    const tips = [...new Set(Object.values(plan.newRefs))];
+    const reachable = await repoReader.reachableObjectsNewestFirst(
+      tips,
+      MAX_ARWEAVE_TAGS_PER_EVENT
+    );
+    for (const sha of reachable) {
+      if (kept.size >= MAX_ARWEAVE_TAGS_PER_EVENT) break;
+      take(sha);
+    }
+  }
+  for (const [sha, txId] of merged) {
+    if (kept.size >= MAX_ARWEAVE_TAGS_PER_EVENT) break;
+    if (!kept.has(sha)) kept.set(sha, txId);
+  }
+  return kept;
+}
 async function executePush(options) {
   const { plan, publisher, remoteState, repoReader, relayUrls } = options;
   const merged = new Map([...remoteState.shaToTxId, ...plan.knownShaToTxId]);
@@ -1230,18 +1633,22 @@ async function executePush(options) {
   }
   let announceReceipt = null;
   if (plan.announceNeeded && !remoteState.announced) {
-    const announceEvent = buildRepoAnnouncement(
-      plan.repoId,
-      plan.announcement.name,
-      plan.announcement.description
-    );
+    const announceEvent = amendRepoAnnouncement(null, {
+      repoId: plan.repoId,
+      name: plan.announcement.name,
+      description: plan.announcement.description,
+      relays: relayUrls,
+      ...plan.announcement.web ? { web: [plan.announcement.web] } : {},
+      ...plan.announcement.earliestUniqueCommit ? { earliestUniqueCommit: plan.announcement.earliestUniqueCommit } : {}
+    });
     announceReceipt = await publisher.publishEvent(announceEvent, relayUrls);
     totalFeePaid += announceReceipt.feePaid;
   }
+  const published = await boundObjectMap(merged, plan, repoReader);
   const refsEvent = buildRepoRefs(
     plan.repoId,
     plan.newRefs,
-    Object.fromEntries(merged)
+    Object.fromEntries(published)
   );
   const refsReceipt = await publisher.publishEvent(refsEvent, relayUrls);
   totalFeePaid += refsReceipt.feePaid;
@@ -1256,7 +1663,7 @@ async function executePush(options) {
     uploads,
     announceReceipt,
     refsReceipt,
-    arweaveMap: merged,
+    arweaveMap: published,
     totalFeePaid
   };
 }
@@ -2098,14 +2505,17 @@ function validateSecretUpdate(plain, outer) {
     );
   }
 }
-function encryptSecretUpdate(plain, senderSecretKey, recipientPubkey) {
-  const checked = assertSecretUpdateShape(plain);
-  const json = JSON.stringify(checked);
+function serializeSecretUpdate(plain) {
+  const json = JSON.stringify(assertSecretUpdateShape(plain));
   if (utf8Bytes(json) > MAX_SECRET_PLAINTEXT_BYTES) {
     throw new Error(
       `secret update plaintext exceeds ${MAX_SECRET_PLAINTEXT_BYTES} bytes`
     );
   }
+  return json;
+}
+function encryptSecretUpdate(plain, senderSecretKey, recipientPubkey) {
+  const json = serializeSecretUpdate(plain);
   const key = nip44.utils.getConversationKey(senderSecretKey, recipientPubkey);
   return nip44.encrypt(json, key);
 }
@@ -2154,6 +2564,36 @@ function effectiveSecrets(inventory) {
   }
   return out;
 }
+var MIN_REDACTED_BYTES = 4;
+function redactionTargets(values2) {
+  const targets = /* @__PURE__ */ new Set();
+  const add = (s) => {
+    if (utf8Bytes(s) >= MIN_REDACTED_BYTES) targets.add(s);
+  };
+  for (const value of values2) {
+    const pieces = [value, ...value.split(/\r?\n/).map((line) => line.trim())];
+    for (const piece of pieces) {
+      if (piece === "") continue;
+      add(piece);
+      add(encodeURIComponent(piece));
+      add(JSON.stringify(piece).slice(1, -1));
+    }
+  }
+  return [...targets].sort((a, b) => b.length - a.length);
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function redactSecretValues(text, values2) {
+  const targets = redactionTargets(values2);
+  if (targets.length === 0) return text;
+  const pattern = new RegExp(targets.map(escapeRegExp).join("|"), "g");
+  return text.replace(pattern, "***");
+}
+function containsSecretValue(bytes, values2) {
+  const buf = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  return redactionTargets(values2).some((t) => buf.includes(t, 0, "utf-8"));
+}
 function generateSecretsKey() {
   const secretKey = generateSecretKey();
   return { secretKey, pubkey: getPublicKey(secretKey) };
@@ -2853,7 +3293,7 @@ function emitCliError(io, json, command, err) {
 
 // src/cli/ci-status.ts
 import { parseArgs as parseArgs2 } from "util";
-import { REPOSITORY_ANNOUNCEMENT_KIND } from "@toon-protocol/core/nip34";
+import { REPOSITORY_ANNOUNCEMENT_KIND as REPOSITORY_ANNOUNCEMENT_KIND2 } from "@toon-protocol/core/nip34";
 
 // src/cli/git-config.ts
 import { execFile as execFile3 } from "child_process";
@@ -3508,7 +3948,7 @@ async function runCiStatus(args, deps) {
           "#a": [repoAddr]
         },
         {
-          kinds: [REPOSITORY_ANNOUNCEMENT_KIND],
+          kinds: [REPOSITORY_ANNOUNCEMENT_KIND2],
           authors: [owner],
           "#d": [repoId]
         }
@@ -3517,7 +3957,7 @@ async function runCiStatus(args, deps) {
     );
     let announce = null;
     for (const ev of events) {
-      if (ev.kind !== REPOSITORY_ANNOUNCEMENT_KIND || ev.pubkey.toLowerCase() !== owner)
+      if (ev.kind !== REPOSITORY_ANNOUNCEMENT_KIND2 || ev.pubkey.toLowerCase() !== owner)
         continue;
       if (!ev.tags.some((t) => t[0] === "d" && t[1] === repoId)) continue;
       if (announce === null || ev.created_at > announce.created_at || ev.created_at === announce.created_at && ev.id < announce.id) {
@@ -3613,6 +4053,14 @@ export {
   createGitTree,
   createGitCommit,
   createGitTag,
+  RELAYS_TAG,
+  WEB_TAG,
+  EARLIEST_UNIQUE_COMMIT_MARKER,
+  amendRepoAnnouncement,
+  buildRepoAnnouncement,
+  earliestUniqueCommit,
+  conformanceEdits,
+  diffAnnouncementTags,
   GitError,
   GitRepoReader,
   DEFAULT_CONCURRENCY,
@@ -3684,10 +4132,13 @@ export {
   MAX_SECRET_CIPHERTEXT_BYTES,
   assertSecretUpdateShape,
   validateSecretUpdate,
+  serializeSecretUpdate,
   encryptSecretUpdate,
   decryptSecretUpdate,
   applySecretUpdate,
   effectiveSecrets,
+  redactSecretValues,
+  containsSecretValue,
   generateSecretsKey,
   CI_TRUST_ORDER,
   isCiTrustLevel,
@@ -3723,4 +4174,4 @@ export {
   assembleCiStatus,
   runCiStatus
 };
-//# sourceMappingURL=chunk-RL5XUWR4.js.map
+//# sourceMappingURL=chunk-DCGV6ALH.js.map