codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/webrtc-service.js

@@ -0,0 +1,413 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var webrtc_service_exports = {};
+__export(webrtc_service_exports, {
+  broadcastToAllPeers: () => broadcastToAllPeers,
+  connectWithAnswer: () => connectWithAnswer,
+  connectedPeerCount: () => connectedPeerCount,
+  createAnswer: () => createAnswer,
+  createOffer: () => createOffer,
+  discardPendingOffer: () => discardPendingOffer,
+  disconnectAllPeers: () => disconnectAllPeers,
+  disconnectPeer: () => disconnectPeer,
+  getPeerConnection: () => getPeerConnection,
+  getPeerConnections: () => getPeerConnections,
+  onChannelMessage: () => onChannelMessage,
+  onConnectionStateChange: () => onConnectionStateChange,
+  sendToPeer: () => sendToPeer
+});
+module.exports = __toCommonJS(webrtc_service_exports);
+var import_werift = require("werift");
+var import_node_crypto = require("node:crypto");
+var import_types = require("../../shared/types");
+const DEFAULT_STUN_SERVERS = [
+  "stun:stun.l.google.com:19302",
+  "stun:stun1.l.google.com:19302"
+];
+const HEARTBEAT_INTERVAL_MS = 1e4;
+const MAX_MISSED_HEARTBEATS = 3;
+const STALE_PEER_MS = 4 * HEARTBEAT_INTERVAL_MS;
+const ICE_GATHERING_TIMEOUT_MS = 1e4;
+const peers = /* @__PURE__ */ new Map();
+const connectionListeners = /* @__PURE__ */ new Set();
+const messageListeners = /* @__PURE__ */ new Map();
+let pendingOfferPc = null;
+async function discardPendingOffer() {
+  if (pendingOfferPc) {
+    try {
+      await pendingOfferPc.close();
+    } catch {
+    }
+    pendingOfferPc = null;
+  }
+}
+async function createOffer() {
+  await discardPendingOffer();
+  const pc = new import_werift.RTCPeerConnection({
+    iceServers: DEFAULT_STUN_SERVERS.map((url) => ({ urls: url }))
+  });
+  pc.createDataChannel("_init");
+  const offer = await pc.createOffer();
+  await pc.setLocalDescription(offer);
+  const candidates = await gatherIceCandidates(pc);
+  const finalOfferSdp = pc.localDescription?.sdp ?? offer.sdp;
+  const fingerprint = extractFingerprint(pc);
+  pendingOfferPc = pc;
+  return {
+    offer: finalOfferSdp,
+    iceCandidates: candidates,
+    fingerprint
+  };
+}
+async function connectWithAnswer(offerSdp, answerSdp, peerIceCandidates, peerFingerprint, alias, deviceType) {
+  let pc;
+  let reusingPending = false;
+  if (pendingOfferPc) {
+    pc = pendingOfferPc;
+    pendingOfferPc = null;
+    reusingPending = true;
+    console.log("[WebRTC] Reusing pending offer PC (same DTLS certificate)");
+  } else {
+    console.warn("[WebRTC] No pending offer PC \u2014 creating fresh connection (fingerprint may differ)");
+    pc = new import_werift.RTCPeerConnection({
+      iceServers: DEFAULT_STUN_SERVERS.map((url) => ({ urls: url }))
+    });
+  }
+  const entry = {
+    fingerprint: peerFingerprint,
+    alias,
+    deviceType,
+    pc,
+    channels: /* @__PURE__ */ new Map(),
+    state: "connecting",
+    connectedAt: null,
+    lastHeartbeat: Date.now(),
+    missedHeartbeats: 0,
+    heartbeatTimer: null
+  };
+  peers.set(peerFingerprint, entry);
+  emitConnectionState(peerFingerprint, "connecting");
+  for (const channelName of Object.values(import_types.DATA_CHANNELS)) {
+    createChannel(entry, channelName);
+  }
+  if (!reusingPending) {
+    await pc.setLocalDescription(
+      new import_werift.RTCSessionDescription(offerSdp, "offer")
+    );
+  }
+  await pc.setRemoteDescription(
+    new import_werift.RTCSessionDescription(answerSdp, "answer")
+  );
+  if (peerIceCandidates.length > 0) {
+    console.log(`[WebRTC] Adding ${peerIceCandidates.length} remote ICE candidates`);
+    for (const candidateJson of peerIceCandidates) {
+      try {
+        const candidate = typeof candidateJson === "string" ? JSON.parse(candidateJson) : candidateJson;
+        if (candidate.candidate) {
+          await pc.addIceCandidate(candidate);
+        }
+      } catch (err) {
+        console.warn("[WebRTC] Failed to add remote ICE candidate:", err);
+      }
+    }
+  }
+  pc.connectionStateChange.subscribe((state) => {
+    handleConnectionStateChange(entry, state);
+  });
+  startHeartbeat(entry);
+  return entry;
+}
+async function createAnswer(offerSdp, _offerIceCandidates) {
+  const pc = new import_werift.RTCPeerConnection({
+    iceServers: DEFAULT_STUN_SERVERS.map((url) => ({ urls: url }))
+  });
+  await pc.setRemoteDescription(
+    new import_werift.RTCSessionDescription(offerSdp, "offer")
+  );
+  const answer = await pc.createAnswer();
+  await pc.setLocalDescription(answer);
+  const candidates = await gatherIceCandidates(pc);
+  const fingerprint = extractFingerprint(pc);
+  await pc.close();
+  return {
+    answer: answer.sdp,
+    iceCandidates: candidates,
+    fingerprint
+  };
+}
+function sendToPeer(fingerprint, channelName, data) {
+  const entry = peers.get(fingerprint);
+  if (!entry || entry.state !== "connected") {
+    if (channelName === "ui") {
+      console.warn(`[WebRTC] sendToPeer(ui): peer ${fingerprint.slice(0, 12)}\u2026 not found or not connected (entry=${!!entry}, state=${entry?.state})`);
+    }
+    return false;
+  }
+  const wrapper = entry.channels.get(channelName);
+  if (!wrapper) {
+    if (channelName === "ui") {
+      console.warn(`[WebRTC] sendToPeer(ui): no channel wrapper for ${channelName}`);
+    }
+    return false;
+  }
+  if (wrapper.channel.readyState !== "open") {
+    console.warn(`[WebRTC] Channel ${channelName} not open (state=${wrapper.channel.readyState}) for ${fingerprint.slice(0, 12)}\u2026`);
+    return false;
+  }
+  try {
+    if (typeof data === "string") {
+      wrapper.channel.send(Buffer.from(data, "utf-8"));
+    } else {
+      wrapper.channel.send(data);
+    }
+    return true;
+  } catch (err) {
+    console.warn(`[WebRTC] Failed to send on ${channelName} to ${fingerprint.slice(0, 12)}:`, err);
+    return false;
+  }
+}
+function broadcastToAllPeers(channelName, data) {
+  let sent = 0;
+  for (const [fp] of peers) {
+    if (sendToPeer(fp, channelName, data)) sent++;
+  }
+  return sent;
+}
+function onChannelMessage(channelName, cb) {
+  let set = messageListeners.get(channelName);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    messageListeners.set(channelName, set);
+  }
+  set.add(cb);
+  return () => {
+    set.delete(cb);
+  };
+}
+function onConnectionStateChange(cb) {
+  connectionListeners.add(cb);
+  return () => {
+    connectionListeners.delete(cb);
+  };
+}
+function getPeerConnections() {
+  return Array.from(peers.values()).map((entry) => {
+    const channelStates = {};
+    for (const [name, wrapper] of entry.channels) {
+      channelStates[name] = wrapper.channel.readyState;
+    }
+    return {
+      fingerprint: entry.fingerprint,
+      alias: entry.alias,
+      state: entry.state,
+      deviceType: entry.deviceType,
+      connectedAt: entry.connectedAt?.toISOString() ?? null,
+      latencyMs: null,
+      openChannels: Array.from(entry.channels.keys()),
+      channelStates
+    };
+  });
+}
+function getPeerConnection(fingerprint) {
+  const entry = peers.get(fingerprint);
+  if (!entry) return void 0;
+  return {
+    fingerprint: entry.fingerprint,
+    alias: entry.alias,
+    state: entry.state,
+    deviceType: entry.deviceType,
+    connectedAt: entry.connectedAt?.toISOString() ?? null,
+    latencyMs: null,
+    openChannels: Array.from(entry.channels.keys())
+  };
+}
+async function disconnectPeer(fingerprint) {
+  const entry = peers.get(fingerprint);
+  if (!entry) return;
+  stopHeartbeat(entry);
+  try {
+    await entry.pc.close();
+  } catch {
+  }
+  entry.state = "disconnected";
+  emitConnectionState(fingerprint, "disconnected");
+  peers.delete(fingerprint);
+  console.log(`[WebRTC] Disconnected peer: ${entry.alias} (${fingerprint.slice(0, 12)}\u2026)`);
+}
+async function disconnectAllPeers() {
+  const fingerprints = Array.from(peers.keys());
+  await Promise.all(fingerprints.map((fp) => disconnectPeer(fp)));
+}
+function connectedPeerCount() {
+  let count = 0;
+  for (const entry of peers.values()) {
+    if (entry.state === "connected") count++;
+  }
+  return count;
+}
+function createChannel(entry, name) {
+  const channel = entry.pc.createDataChannel(name, {
+    ordered: true
+  });
+  const wrapper = {
+    name,
+    channel,
+    onMessage: /* @__PURE__ */ new Set()
+  };
+  channel.onMessage.subscribe((data) => {
+    entry.lastHeartbeat = Date.now();
+    entry.missedHeartbeats = 0;
+    const listeners = messageListeners.get(name);
+    if (listeners) {
+      for (const cb of listeners) {
+        try {
+          cb(entry.fingerprint, data);
+        } catch {
+        }
+      }
+    }
+    for (const cb of wrapper.onMessage) {
+      try {
+        cb(data);
+      } catch {
+      }
+    }
+  });
+  channel.stateChanged.subscribe((state) => {
+    if (state === "open") {
+      console.log(`[WebRTC] Channel ${name} opened for ${entry.alias}`);
+      emitConnectionState(entry.fingerprint, "connected");
+    }
+  });
+  entry.channels.set(name, wrapper);
+}
+function handleConnectionStateChange(entry, state) {
+  const prevState = entry.state;
+  const prevConnectedAt = entry.connectedAt;
+  const fp = entry.fingerprint.slice(0, 12);
+  const heldFor = prevConnectedAt && prevState === "connected" ? Math.round((Date.now() - prevConnectedAt.getTime()) / 1e3) : null;
+  const heldStr = heldFor !== null ? ` heldFor=${heldFor}s` : "";
+  switch (state) {
+    case "connected":
+      entry.state = "connected";
+      entry.connectedAt = /* @__PURE__ */ new Date();
+      console.log(`[WebRTC][Lifecycle] connected peer=${entry.alias} (${fp}\u2026) prev=${prevState}`);
+      break;
+    case "disconnected":
+    case "closed":
+      entry.state = "disconnected";
+      stopHeartbeat(entry);
+      console.log(`[WebRTC][Lifecycle] disconnected peer=${entry.alias} (${fp}\u2026) prev=${prevState}${heldStr} missedHeartbeats=${entry.missedHeartbeats} ice=${state}`);
+      break;
+    case "failed":
+      entry.state = "failed";
+      stopHeartbeat(entry);
+      console.log(`[WebRTC][Lifecycle] failed peer=${entry.alias} (${fp}\u2026) prev=${prevState}${heldStr} missedHeartbeats=${entry.missedHeartbeats}`);
+      break;
+  }
+  emitConnectionState(entry.fingerprint, entry.state);
+}
+function startHeartbeat(entry) {
+  stopHeartbeat(entry);
+  entry.heartbeatTimer = setInterval(() => {
+    if (entry.state !== "connected" && entry.state !== "connecting") {
+      stopHeartbeat(entry);
+      return;
+    }
+    if (Date.now() - entry.lastHeartbeat > STALE_PEER_MS) {
+      console.warn(`[WebRTC] ${entry.alias}: no inbound for ${Math.round(STALE_PEER_MS / 1e3)}s \u2014 reaping dead peer`);
+      void disconnectPeer(entry.fingerprint);
+      return;
+    }
+    const pingId = (0, import_node_crypto.randomBytes)(4).toString("hex");
+    const sent = sendToPeer(
+      entry.fingerprint,
+      import_types.DATA_CHANNELS.CONTROL,
+      JSON.stringify({ type: "ping", id: pingId, ts: Date.now() })
+    );
+    if (!sent) {
+      entry.missedHeartbeats++;
+    }
+    if (entry.missedHeartbeats >= MAX_MISSED_HEARTBEATS) {
+      console.warn(`[WebRTC] ${entry.alias}: ${MAX_MISSED_HEARTBEATS} heartbeats missed \u2014 connection presumed dead`);
+      void disconnectPeer(entry.fingerprint);
+    }
+  }, HEARTBEAT_INTERVAL_MS);
+}
+function stopHeartbeat(entry) {
+  if (entry.heartbeatTimer) {
+    clearInterval(entry.heartbeatTimer);
+    entry.heartbeatTimer = null;
+  }
+}
+function emitConnectionState(fingerprint, state) {
+  for (const cb of connectionListeners) {
+    try {
+      cb(fingerprint, state);
+    } catch {
+    }
+  }
+}
+async function gatherIceCandidates(pc) {
+  const candidates = [];
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      resolve(candidates);
+    }, ICE_GATHERING_TIMEOUT_MS);
+    pc.onIceCandidate.subscribe((candidate) => {
+      if (candidate) {
+        candidates.push(JSON.stringify(candidate));
+      }
+    });
+    const checkComplete = () => {
+      if (pc.iceGatheringState === "complete") {
+        clearTimeout(timeout);
+        resolve(candidates);
+      }
+    };
+    const interval = setInterval(checkComplete, 100);
+    setTimeout(() => clearInterval(interval), ICE_GATHERING_TIMEOUT_MS);
+  });
+}
+function extractFingerprint(pc) {
+  try {
+    const desc = pc.localDescription;
+    if (desc?.sdp) {
+      const match = desc.sdp.match(/a=fingerprint:sha-256\s+([0-9A-Fa-f:]+)/);
+      if (match) return match[1];
+    }
+  } catch {
+  }
+  return (0, import_node_crypto.randomBytes)(32).toString("hex").replace(/(.{2})/g, "$1:").slice(0, -1).toUpperCase();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  broadcastToAllPeers,
+  connectWithAnswer,
+  connectedPeerCount,
+  createAnswer,
+  createOffer,
+  discardPendingOffer,
+  disconnectAllPeers,
+  disconnectPeer,
+  getPeerConnection,
+  getPeerConnections,
+  onChannelMessage,
+  onConnectionStateChange,
+  sendToPeer
+});

package/src/backend/services/work-changes.js

@@ -0,0 +1,59 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var work_changes_exports = {};
+__export(work_changes_exports, {
+  baseRef: () => baseRef,
+  changedFiles: () => changedFiles
+});
+module.exports = __toCommonJS(work_changes_exports);
+var import_node_child_process = require("node:child_process");
+const git = (root, args) => {
+  try {
+    return (0, import_node_child_process.execFileSync)("git", ["-C", root, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+  } catch {
+    return null;
+  }
+};
+const lines = (s) => (s ?? "").split("\n").map((x) => x.trim()).filter(Boolean);
+function baseRef(root, given, env) {
+  const exists = (ref) => git(root, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]) !== null;
+  if (given) return exists(given) ? given : null;
+  if (env.GITHUB_BASE_REF && exists(`origin/${env.GITHUB_BASE_REF}`)) return `origin/${env.GITHUB_BASE_REF}`;
+  const head = git(root, ["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"])?.trim();
+  if (head && exists(head)) return head;
+  for (const ref of ["origin/main", "origin/master"]) if (exists(ref)) return ref;
+  return null;
+}
+function changedFiles(root, given, env) {
+  if (given && baseRef(root, given, env) === null) throw new Error(`${given} is not a commit in this repository (a shallow clone? use fetch-depth: 0)`);
+  const base = baseRef(root, given, env);
+  const since = base ? git(root, ["merge-base", base, "HEAD"])?.trim() || null : null;
+  const out = /* @__PURE__ */ new Set([
+    ...since ? lines(git(root, ["diff", "--name-only", since, "HEAD"])) : [],
+    ...lines(git(root, ["diff", "--name-only", "HEAD"])),
+    ...lines(git(root, ["ls-files", "--others", "--exclude-standard"]))
+  ]);
+  const files = [...out].filter((f) => !f.startsWith(".codetrellis/")).sort();
+  const rulebook = [...out].some((f) => f.startsWith(".codetrellis/rules/") || f === ".codetrellis/config.json" || f === ".codetrellis/pipeline.yaml");
+  return { base, since, files, rulebook };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  baseRef,
+  changedFiles
+});

package/src/backend/services/workstream-binding.js

@@ -0,0 +1,82 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var workstream_binding_exports = {};
+__export(workstream_binding_exports, {
+  candidateWorkstreamRoots: () => candidateWorkstreamRoots,
+  firstWorkstreamRoot: () => firstWorkstreamRoot,
+  matchWorkstreamRoot: () => matchWorkstreamRoot
+});
+module.exports = __toCommonJS(workstream_binding_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_trusted_roots = require("./trusted-roots");
+var import_worktree_service = require("./worktree-service");
+function matchWorkstreamRoot(reported, candidates, realpath = import_node_fs.default.realpathSync.native) {
+  if (typeof reported !== "string" || !reported || reported.includes("\0") || !import_node_path.default.isAbsolute(reported)) return null;
+  let target;
+  try {
+    target = realpath(reported);
+  } catch {
+    return null;
+  }
+  let best = null;
+  for (const listed of candidates) {
+    let canonical;
+    try {
+      canonical = realpath(listed);
+    } catch {
+      continue;
+    }
+    const inside = target === canonical || target.startsWith(canonical.endsWith(import_node_path.default.sep) ? canonical : canonical + import_node_path.default.sep);
+    if (inside && (!best || canonical.length > best.canonical.length)) best = { listed, canonical };
+  }
+  return best?.listed ?? null;
+}
+function candidateWorkstreamRoots() {
+  const roots = /* @__PURE__ */ new Set();
+  for (const root of (0, import_trusted_roots.listTrustedRoots)()) {
+    roots.add(root);
+    for (const w of (0, import_worktree_service.listWorktrees)(root)) {
+      if (!w.bare && !w.prunable) roots.add(w.path);
+    }
+  }
+  return [...roots];
+}
+function firstWorkstreamRoot(reported, candidates = candidateWorkstreamRoots()) {
+  for (const r of reported) {
+    const hit = matchWorkstreamRoot(r, candidates);
+    if (hit) return hit;
+  }
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  candidateWorkstreamRoots,
+  firstWorkstreamRoot,
+  matchWorkstreamRoot
+});

package/src/backend/services/workstream-commits.js

@@ -0,0 +1,116 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var workstream_commits_exports = {};
+__export(workstream_commits_exports, {
+  MAX_COMMITS: () => MAX_COMMITS,
+  commitsByWorkstream: () => commitsByWorkstream,
+  commitsOf: () => commitsOf,
+  forgetKeptCommits: () => forgetKeptCommits,
+  parseCommits: () => parseCommits
+});
+module.exports = __toCommonJS(workstream_commits_exports);
+var import_node_child_process = require("node:child_process");
+var import_git_safety = require("./git-safety");
+const MAX_COMMITS = 50;
+const SHA = /^[0-9a-f]{40}$/;
+const RS = "";
+const US = "";
+const FORMAT = `--format=%H${US}%P${US}%cI${US}%aN${US}%s${US}%b${RS}`;
+function git(folder, args) {
+  try {
+    return (0, import_node_child_process.execFileSync)("git", ["-C", folder, ...args], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5e3,
+      maxBuffer: 4 * 1024 * 1024
+    });
+  } catch {
+    return null;
+  }
+}
+function parseCommits(raw) {
+  return raw.split(RS).map((r) => r.replace(/^\n+/, "")).filter(Boolean).flatMap((record) => {
+    const [sha, parents, at, author, subject, body = ""] = record.split(US);
+    if (!sha || !SHA.test(sha.trim())) return [];
+    const agent = body.match(/^agent:\s*(\S+)/m)?.[1] ?? null;
+    return [{
+      sha: sha.trim(),
+      at: Date.parse(at),
+      author: author ?? "",
+      subject: subject ?? "",
+      merge: (parents ?? "").trim().split(/\s+/).filter(Boolean).length > 1,
+      agent
+    }];
+  });
+}
+function commitsOf(w, mainPath, sinceMs) {
+  const since = `--since=@${Math.floor(sinceMs / 1e3)}`;
+  const common = [since, `--max-count=${MAX_COMMITS}`, FORMAT];
+  let raw;
+  if (w.main) {
+    raw = git(w.root, ["log", "HEAD", ...common]);
+  } else if (w.root.startsWith("branch:")) {
+    const head = w.head && SHA.test(w.head) ? w.head : null;
+    const base = w.changes?.base && SHA.test(w.changes.base) ? w.changes.base : null;
+    if (!head) {
+      if (!w.ref || !(0, import_git_safety.isSafeGitRef)(w.ref)) return [];
+      raw = git(mainPath, ["log", w.ref, ...common]);
+    } else {
+      raw = git(mainPath, ["log", base ? `${base}..${head}` : head, ...common]);
+    }
+  } else {
+    const base = w.changes?.base && SHA.test(w.changes.base) ? w.changes.base : null;
+    raw = git(w.root, ["log", base ? `${base}..HEAD` : "HEAD", ...common]);
+  }
+  return raw ? parseCommits(raw) : [];
+}
+const KEEP_MS = 6e4;
+const kept = /* @__PURE__ */ new Map();
+function keyOf(w) {
+  const head = w.head && SHA.test(w.head) ? w.head : null;
+  return head ? `${w.root}\0${head}\0${w.changes?.base ?? ""}` : null;
+}
+function commitsByWorkstream(workstreams, sinceMs, now = Date.now()) {
+  const main = workstreams.find((w) => w.main);
+  const out = {};
+  if (!main) return out;
+  for (const w of workstreams) {
+    const key = keyOf(w);
+    const hit = key ? kept.get(key) : void 0;
+    if (hit && now - hit.at < KEEP_MS && hit.sinceMs <= sinceMs) {
+      out[w.root] = hit.commits.filter((c) => c.at >= sinceMs);
+      continue;
+    }
+    const commits = commitsOf(w, main.root, sinceMs);
+    if (key) kept.set(key, { at: now, sinceMs, commits });
+    out[w.root] = commits;
+  }
+  if (kept.size > 500) kept.clear();
+  return out;
+}
+function forgetKeptCommits() {
+  kept.clear();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MAX_COMMITS,
+  commitsByWorkstream,
+  commitsOf,
+  forgetKeptCommits,
+  parseCommits
+});