@toon-protocol/rig 4.3.0 → 4.4.0

package/dist/{ci-serve-ZVJBZ3W3.js → ci-serve-P4HOLAMP.js}

@@ -6,7 +6,7 @@ import {
   renderIdentityLine,
   rigVersion,
   withForcedStandalone
-} from "./chunk-5HFOPKAB.js";
+} from "./chunk-CTRP2UAQ.js";
 import {
   CI_MANUAL_TRIGGER_KIND,
   CI_SECRET_UPDATE_KIND,
@@ -39,7 +39,7 @@ import {
   selectServiceRequests,
   validateSecretUpdate,
   writeGitObjects
-} from "./chunk-3RWM7PBM.js";
+} from "./chunk-RL5XUWR4.js";
 import {
   REPOSITORY_STATE_KIND,
   authorizedStatusAuthors,
@@ -1108,6 +1108,7 @@ async function startCoordinator(opts) {
   await advertise();
   const queue = [];
   const activeAborts = /* @__PURE__ */ new Set();
+  const activeRuns = /* @__PURE__ */ new Set();
   let active = 0;
   let inflight = 0;
   const idleWaiters = [];
@@ -1135,13 +1136,22 @@ async function startCoordinator(opts) {
       jobs: []
     };
     const now = clock();
-    await publish(buildCiWorkflowResult({ ...base, conclusion }, now));
+    const resultEventId = await publish(
+      buildCiWorkflowResult({ ...base, conclusion }, now)
+    );
     await publish(
       buildCiWorkflowProgress(
         { ...base, status: "concluded", conclusion, expiresAt: now + adTtl },
         now
       )
     );
+    opts.onRunConcluded?.({
+      runId: run.runId,
+      repoAddr: run.repo.addr,
+      trigger: run.trigger,
+      conclusion,
+      resultEventId
+    });
   };
   const executeRun = async (run) => {
     const { repo, trigger, workflow } = run;
@@ -1210,6 +1220,7 @@ async function startCoordinator(opts) {
     scheduleRenew();
     const abort = new AbortController();
     activeAborts.add(abort);
+    run.abort = abort;
     let timedOut = false;
     const timeoutHandle = scheduler.setTimeout(() => {
       timedOut = true;
@@ -1261,7 +1272,8 @@ async function startCoordinator(opts) {
     }
     let conclusion = result.conclusion;
     if (timedOut) conclusion = "timed_out";
-    else if (stopping && abort.signal.aborted) conclusion = "cancelled";
+    else if (run.superseded || stopping && abort.signal.aborted)
+      conclusion = "cancelled";
     for (const job of result.jobs) {
       const { tail, omitted } = logTail(job.log);
       const logReceipt = await serial.run(
@@ -1325,7 +1337,7 @@ async function startCoordinator(opts) {
       await publish(progress("in_progress"));
     }
     const now = clock();
-    await publish(
+    const resultEventId = await publish(
       buildCiWorkflowResult(
         {
           trigger,
@@ -1341,17 +1353,26 @@ async function startCoordinator(opts) {
     );
     await publish(progress("concluded", conclusion));
     log(`[ci] ${label}: ${conclusion}`);
+    opts.onRunConcluded?.({
+      runId: run.runId,
+      repoAddr: repo.addr,
+      trigger,
+      conclusion,
+      resultEventId
+    });
   };
   const pump = () => {
     while (active < concurrency && queue.length > 0 && !stopping) {
       const run = queue.shift();
       active += 1;
       inflight += 1;
+      activeRuns.add(run);
       void executeRun(run).catch((err) => {
         log(
           `[ci] run ${run.runId.slice(0, 8)} failed: ${err instanceof Error ? err.message : String(err)}`
         );
       }).finally(async () => {
+        activeRuns.delete(run);
         active -= 1;
         inflight -= 1;
         await releaseCheckout(run.checkout);
@@ -1411,6 +1432,27 @@ async function startCoordinator(opts) {
     );
     pump();
   };
+  const supersedePrRuns = async (repo, prEventId, updateEventId) => {
+    const samePr = (run) => run.repo === repo && run.trigger.pr?.prEventId === prEventId;
+    const why = `superseded by PR update ${updateEventId.slice(0, 8)} \u2014 cancelled`;
+    for (const run of queue.filter(samePr)) {
+      queue.splice(queue.indexOf(run), 1);
+      run.superseded = true;
+      log(
+        `[ci] ${repo.repoId} ${run.workflow.path}@${run.trigger.commit.slice(0, 7)} [${run.runId.slice(0, 8)}]: queued run ${why}`
+      );
+      await concludeWithoutJobs(run, "cancelled", void 0);
+      await releaseCheckout(run.checkout);
+    }
+    for (const run of activeRuns) {
+      if (!samePr(run) || run.superseded) continue;
+      run.superseded = true;
+      log(
+        `[ci] ${repo.repoId} ${run.workflow.path}@${run.trigger.commit.slice(0, 7)} [${run.runId.slice(0, 8)}]: ${why}`
+      );
+      run.abort?.abort();
+    }
+  };
   let checkoutCounter = 0;
   const handleTrigger = async (t) => {
     const { repo } = t;
@@ -1672,6 +1714,7 @@ async function startCoordinator(opts) {
       );
       return;
     }
+    await supersedePrRuns(repo, pr.id, ev.id);
     await handleTrigger({
       repo,
       reason: "pull_request",
@@ -1975,6 +2018,9 @@ Options:
                          (default: ubuntu-latest=${DEFAULT_ACT_PLATFORMS["ubuntu-latest"]})
   --workdir <dir>        where commits are checked out for runs (default:
                          <state-dir>/work)
+  --once                 stop after the first run concludes (its Workflow
+                         Result and final progress marker are on the relay);
+                         ignored or refused triggers do not count
   --json                 emit ONE JSON document describing the coordinator
                          at start; everything else goes to stderr
   --standalone           accepted for symmetry; the coordinator always runs
@@ -2008,6 +2054,7 @@ function parseServeArgs(args) {
       "act-bin": { type: "string" },
       platform: { type: "string", multiple: true },
       workdir: { type: "string" },
+      once: { type: "boolean", default: false },
       json: { type: "boolean", default: false },
       standalone: { type: "boolean", default: false },
       "no-daemon": { type: "boolean", default: false },
@@ -2087,6 +2134,7 @@ function parseServeArgs(args) {
     ...values["act-bin"] !== void 0 ? { actBin: values["act-bin"] } : {},
     ...platforms ? { platforms } : {},
     ...values.workdir !== void 0 ? { workdir: values.workdir } : {},
+    once: values.once,
     json: values.json
   };
 }
@@ -2147,7 +2195,7 @@ function makeAffordabilityCheck(args) {
     return false;
   };
 }
-function untilStopRequested(signal) {
+function untilStopRequested(signal, firstRun) {
   return new Promise((resolve2) => {
     let settled = false;
     const finish = (reason) => {
@@ -2163,6 +2211,7 @@ function untilStopRequested(signal) {
     signal?.addEventListener("abort", () => finish("abort"), { once: true });
     process.once("SIGINT", onSigint);
     process.once("SIGTERM", onSigterm);
+    void firstRun?.then(finish);
   });
 }
 async function runCiServe(args, deps) {
@@ -2210,6 +2259,10 @@ async function runCiServe(args, deps) {
     const stateDir = forced.stateDir ?? defaultCoordinatorStateDir(forced.env, coordinator);
     const workdir = flags.workdir ?? join4(stateDir, "work");
     const version = rigVersion();
+    let concludeFirstRun = () => void 0;
+    const firstRun = flags.once ? new Promise((resolve2) => {
+      concludeFirstRun = resolve2;
+    }) : void 0;
     handle = await startCoordinator({
       coordinatorPubkey: coordinator,
       publisher: ctx.publisher,
@@ -2232,6 +2285,7 @@ async function runCiServe(args, deps) {
       ...forced.fetchFn ? { fetchFn: forced.fetchFn } : {},
       ...forced.resolveSha ? { resolveSha: forced.resolveSha } : {},
       ...forced.clock ? { clock: forced.clock } : {},
+      ...firstRun ? { onRunConcluded: (run) => concludeFirstRun(run) } : {},
       log: (line) => io.err(line)
     });
     const npub = hexToNpub(coordinator);
@@ -2252,6 +2306,7 @@ async function runCiServe(args, deps) {
         runner: { family: runner.family, selectors: runner.selectors },
         concurrency: flags.concurrency,
         timeoutSeconds: flags.timeoutMs / 1e3,
+        once: flags.once,
         stateDir,
         workdir,
         secretsKey: handle.secretsKeyPubkey,
@@ -2273,11 +2328,13 @@ async function runCiServe(args, deps) {
       io.out(`State:       ${stateDir}`);
       io.out("Maintainers authorize this coordinator with:");
       io.out(`  rig ci request ${npub}`);
-      io.out("Listening \u2014 press Ctrl-C to stop.");
+      io.out(
+        flags.once ? "Listening for one run \u2014 stops after it concludes (or Ctrl-C)." : "Listening \u2014 press Ctrl-C to stop."
+      );
     }
-    const reason = await untilStopRequested(forced.signal);
+    const reason = await untilStopRequested(forced.signal, firstRun);
     io.err(
-      `rig ci serve: ${reason} \u2014 stopping (active runs conclude cancelled)`
+      typeof reason === "string" ? `rig ci serve: ${reason} \u2014 stopping (active runs conclude cancelled)` : `rig ci serve: run ${reason.runId.slice(0, 8)} concluded ${reason.conclusion} (result ${reason.resultEventId.slice(0, 8)}) \u2014 --once, stopping`
     );
     await handle.stop();
     handle = void 0;
@@ -2300,4 +2357,4 @@ export {
   makeAffordabilityCheck,
   runCiServe
 };
-//# sourceMappingURL=ci-serve-ZVJBZ3W3.js.map
+//# sourceMappingURL=ci-serve-P4HOLAMP.js.map