@toon-protocol/rig 4.5.0 → 4.7.0

package/dist/{ci-serve-PYEHIBN7.js → ci-serve-T33FCQVT.js}

@@ -1,14 +1,15 @@
 import {
-  PREFERRED_GATEWAY,
   WS_URL_RE,
   identityReport,
   loadPaidSession,
   renderIdentityLine,
   rigVersion,
   withForcedStandalone
-} from "./chunk-UZZ2JKEC.js";
+} from "./chunk-J6Y3U645.js";
 import {
+  CI_LIVE_LOG_TAIL_INTERVAL_MS,
   CI_MANUAL_TRIGGER_KIND,
+  CI_RUNNER_CHANNEL_KEY,
   CI_SECRET_UPDATE_KIND,
   CI_SERVICE_REQUEST_KIND,
   CI_SERVICE_STOP_KIND,
@@ -16,6 +17,7 @@ import {
   applySecretUpdate,
   buildCiAdvertisement,
   buildCiJobResult,
+  buildCiLiveLogTail,
   buildCiWorkflowProgress,
   buildCiWorkflowResult,
   collectRepoObjects,
@@ -26,6 +28,8 @@ import {
   emitCliError,
   generateSecretsKey,
   hexToNpub,
+  liveLogTailBudget,
+  liveLogTailEventBudget,
   matchesPullRequest,
   matchesPush,
   missingObjectsMessage,
@@ -39,17 +43,24 @@ import {
   repoAddress,
   runGit,
   selectServiceRequests,
+  sliceLogTail,
   validateSecretUpdate,
   writeGitObjects
-} from "./chunk-S2BMLXAD.js";
+} from "./chunk-3IVO2MSZ.js";
+import {
+  PREFERRED_GATEWAY,
+  configuredGateway,
+  readGatewaysFor,
+  shaResolverFor
+} from "./chunk-XQ2AWNHQ.js";
 import {
-  ARWEAVE_GATEWAYS,
   REPOSITORY_STATE_KIND,
   authorizedStatusAuthors,
   defaultWebSocketFactory,
   fetchRemoteState,
+  parseStateRefTags,
   queryRelay
-} from "./chunk-HMED76GU.js";
+} from "./chunk-S3KKQ4IC.js";
 import {
   ChannelMapStore,
   channelStatus,
@@ -430,7 +441,11 @@ var ActRunner = class {
             const line = buffered.slice(0, nl);
             buffered = buffered.slice(nl + 1);
             const parsedLine = parseActJsonLine(line);
-            if (!parsedLine) continue;
+            if (!parsedLine) {
+              request.onLog?.(CI_RUNNER_CHANNEL_KEY, `${line}
+`);
+              continue;
+            }
             lines.push(parsedLine);
             if (request.onLog && parsedLine.exitCode === void 0) {
               request.onLog(
@@ -443,7 +458,11 @@ var ActRunner = class {
         });
         stream.on("end", () => {
           const parsedLine = parseActJsonLine(buffered);
-          if (parsedLine) lines.push(parsedLine);
+          if (parsedLine) {
+            lines.push(parsedLine);
+          } else if (buffered !== "") {
+            request.onLog?.(CI_RUNNER_CHANNEL_KEY, buffered);
+          }
         });
       };
       consume(child.stdout);
@@ -462,7 +481,7 @@ var ActRunner = class {
         startedAtMs,
         (note) => {
           this.options.warn?.(note);
-          request.onLog?.("runner", `${note}
+          request.onLog?.(CI_RUNNER_CHANNEL_KEY, `${note}
 `);
         }
       );
@@ -889,6 +908,10 @@ var DEFAULT_RUN_TIMEOUT_MS = 30 * 60 * 1e3;
 var DEFAULT_ADVERTISEMENT_TTL = 30 * 60;
 var RENEW_FRACTION = 5 / 6;
 var LOG_TAIL_BYTES = 4096;
+var LOG_UPLOAD_CAP_BYTES = 1024 * 1024;
+var LOG_UPLOAD_HEAD_BYTES = 512 * 1024;
+var LOG_UPLOAD_MARKER_BUDGET_BYTES = 256;
+var LOG_UPLOAD_TAIL_BYTES = 512 * 1024 - LOG_UPLOAD_MARKER_BUDGET_BYTES;
 var SECRETS_KEY_MAX_AGE = 86400;
 function nowSeconds() {
   return Math.floor(Date.now() / 1e3);
@@ -902,6 +925,20 @@ function logTail(log) {
     omitted: bytes.byteLength - LOG_TAIL_BYTES
   };
 }
+function boundLogForUpload(log) {
+  const bytes = Buffer.from(log, "utf-8");
+  if (bytes.byteLength <= LOG_UPLOAD_CAP_BYTES) return bytes;
+  const head = bytes.subarray(0, LOG_UPLOAD_HEAD_BYTES);
+  const tail = bytes.subarray(bytes.byteLength - LOG_UPLOAD_TAIL_BYTES);
+  const omitted = bytes.byteLength - head.byteLength - tail.byteLength;
+  const marker = Buffer.from(
+    `
+[... ${omitted} bytes omitted (log capped at ${LOG_UPLOAD_CAP_BYTES} bytes) ...]
+`,
+    "utf-8"
+  );
+  return Buffer.concat([head, marker, tail]);
+}
 function gatewayRawUrl(gatewayUrl, txId) {
   return `${gatewayUrl.replace(/\/+$/, "")}/raw/${txId}`;
 }
@@ -912,19 +949,6 @@ function movedRefs(before, after) {
   }
   return moved;
 }
-function parseRefsTags(ev) {
-  const refs = {};
-  let head = null;
-  for (const [name, v1, v2] of ev.tags) {
-    if (name === "r" && v1 && v2) {
-      if (v1 === "HEAD" && v2.startsWith("ref: ")) head = v2.slice(5);
-      else refs[v1] = v2;
-    } else if (name === "HEAD" && v1?.startsWith("ref: ")) {
-      head = v1.slice(5);
-    }
-  }
-  return { refs, head };
-}
 function tagValues(tags, name) {
   return tags.filter((t) => t[0] === name).map((t) => t[1] ?? "").filter((v) => v !== "");
 }
@@ -1222,6 +1246,62 @@ async function startCoordinator(opts) {
       );
     };
     scheduleRenew();
+    const secretValues = Object.values(run.secrets);
+    const streamed = /* @__PURE__ */ new Map();
+    const finishedJobs = /* @__PURE__ */ new Set();
+    let tailClosed = false;
+    const recordLog = (jobId, chunk) => {
+      if (tailClosed || chunk === "") return;
+      streamed.set(jobId, (streamed.get(jobId) ?? "") + chunk);
+    };
+    const publishLiveLogTail = async () => {
+      const live = [];
+      for (const [key, text] of streamed) {
+        if (key !== CI_RUNNER_CHANNEL_KEY && finishedJobs.has(key)) continue;
+        live.push([key, redactSecretValues(text, secretValues)]);
+      }
+      const budget = liveLogTailBudget(live.length);
+      const jobs = [];
+      let runnerChannel;
+      for (const [key, text] of live) {
+        const sliced = sliceLogTail(text, budget);
+        if (key === CI_RUNNER_CHANNEL_KEY) runnerChannel = sliced;
+        else jobs.push({ job: key, ...sliced });
+      }
+      const now2 = clock();
+      try {
+        await publish(
+          buildCiLiveLogTail(
+            {
+              trigger,
+              runId: run.runId,
+              jobs,
+              ...runnerChannel ? { runner: runnerChannel } : {},
+              expiresAt: now2 + adTtl
+            },
+            now2
+          )
+        );
+      } catch (err) {
+        log(
+          `[ci] ${label}: live log tail not published: ${redactSecretValues(
+            err instanceof Error ? err.message : String(err),
+            secretValues
+          )}`
+        );
+      }
+    };
+    let tailTimer = null;
+    let tailPublished = false;
+    const scheduleTail = () => {
+      tailTimer = scheduler.setTimeout(() => {
+        if (tailClosed) return;
+        tailPublished = true;
+        void publishLiveLogTail();
+        scheduleTail();
+      }, CI_LIVE_LOG_TAIL_INTERVAL_MS);
+    };
+    scheduleTail();
     const abort = new AbortController();
     activeAborts.add(abort);
     run.abort = abort;
@@ -1239,6 +1319,7 @@ async function startCoordinator(opts) {
           trigger,
           secrets: run.secrets,
           timeoutMs,
+          onLog: recordLog,
           signal: abort.signal
         }),
         new Promise((resolve2) => {
@@ -1272,19 +1353,19 @@ async function startCoordinator(opts) {
     } finally {
       scheduler.clearTimeout(timeoutHandle);
       scheduler.clearTimeout(renewTimer);
+      scheduler.clearTimeout(tailTimer);
       activeAborts.delete(abort);
     }
     let conclusion = result.conclusion;
     if (timedOut) conclusion = "timed_out";
     else if (run.superseded || stopping && abort.signal.aborted)
       conclusion = "cancelled";
-    const secretValues = Object.values(run.secrets);
     for (const job of result.jobs) {
       const jobLog = redactSecretValues(job.log, secretValues);
       const { tail, omitted } = logTail(jobLog);
       const logReceipt = await serial.run(
         () => uploadBlob({
-          body: Buffer.from(jobLog, "utf-8"),
+          body: boundLogForUpload(jobLog),
           contentType: "text/plain; charset=utf-8",
           repoId: repo.repoId
         })
@@ -1346,8 +1427,11 @@ async function startCoordinator(opts) {
         pubkey: me,
         jobId: job.jobId
       });
+      finishedJobs.add(job.jobId);
       await publish(progress("in_progress"));
     }
+    if (tailPublished) await publishLiveLogTail();
+    tailClosed = true;
     const now = clock();
     const resultEventId = await publish(
       buildCiWorkflowResult(
@@ -1628,8 +1712,9 @@ async function startCoordinator(opts) {
   const handleRepoState = async (repo, ev) => {
     const cursor = repo.cursor;
     if (repoSeen(repo, ev) || ev.created_at < cursor.lastCreatedAt) return;
-    const { refs, head } = parseRefsTags(ev);
-    if (head) repo.defaultBranch = head;
+    const { refs: refMap, headSymref } = parseStateRefTags(ev.tags);
+    const refs = Object.fromEntries(refMap);
+    if (headSymref) repo.defaultBranch = headSymref;
     const moved = movedRefs(cursor.refs, refs);
     cursor.refs = refs;
     markRepoProcessed(repo, ev);
@@ -2032,6 +2117,11 @@ Options:
   --act-bin <path>       the act executable (default: RIG_ACT_BIN, else PATH)
   --platform <label=img> runs-on label \u2192 Docker image; repeatable
                          (default: ubuntu-latest=${DEFAULT_ACT_PLATFORMS["ubuntu-latest"]})
+  --pull                 pull the runner image before each run (act's default)
+  --no-pull              never pull: run the image already on this host \u2014
+                         what a locally built or otherwise private runner
+                         image needs, since act cannot pull it (act's own
+                         spelling, --pull=false, is accepted too)
   --workdir <dir>        where commits are checked out for runs (default:
                          <state-dir>/work)
   --once                 stop after the first run concludes (its Workflow
@@ -2057,9 +2147,18 @@ half-published (story 15).
 Stop with Ctrl-C (SIGINT) or SIGTERM: active runs conclude \`cancelled\`.`;
 var ServeUsageError = class extends Error {
 };
+function pullSpelling(arg) {
+  if (!arg.startsWith("--pull=")) return arg;
+  const value = arg.slice("--pull=".length);
+  if (value === "false") return "--no-pull";
+  if (value === "true") return "--pull";
+  throw new ServeUsageError(
+    `--pull takes no value \u2014 use --pull or --no-pull, got ${JSON.stringify(arg)}`
+  );
+}
 function parseServeArgs(args) {
   const { values } = parseArgs({
-    args,
+    args: args.map(pullSpelling),
     options: {
       relay: { type: "string" },
       repo: { type: "string", multiple: true },
@@ -2069,6 +2168,8 @@ function parseServeArgs(args) {
       gateway: { type: "string" },
       "act-bin": { type: "string" },
       platform: { type: "string", multiple: true },
+      pull: { type: "boolean" },
+      "no-pull": { type: "boolean" },
       workdir: { type: "string" },
       once: { type: "boolean", default: false },
       json: { type: "boolean", default: false },
@@ -2144,6 +2245,10 @@ function parseServeArgs(args) {
       platforms[spec.slice(0, eq)] = spec.slice(eq + 1);
     }
   }
+  if (values.pull && values["no-pull"]) {
+    throw new ServeUsageError("--pull and --no-pull cannot both be given");
+  }
+  const pull = values.pull ? true : values["no-pull"] ? false : void 0;
   return {
     relay: values.relay,
     repos,
@@ -2153,18 +2258,26 @@ function parseServeArgs(args) {
     ...values.gateway !== void 0 ? { gateway: values.gateway } : {},
     ...values["act-bin"] !== void 0 ? { actBin: values["act-bin"] } : {},
     ...platforms ? { platforms } : {},
+    ...pull !== void 0 ? { pull } : {},
     ...values.workdir !== void 0 ? { workdir: values.workdir } : {},
     once: values.once,
     json: values.json
   };
 }
-function estimateRunCost(estimate) {
-  return BigInt(estimate.events) * estimate.rates.eventFee + BigInt(estimate.uploads) * uploadChargeFor(estimate.rates, 64 * 1024);
+function actRunnerOptions(flags) {
+  return {
+    ...flags.actBin !== void 0 ? { actBin: flags.actBin } : {},
+    ...flags.platforms ? { platforms: flags.platforms } : {},
+    ...flags.pull !== void 0 ? { pull: flags.pull } : {}
+  };
+}
+function estimateRunCost(estimate, runTimeoutMs) {
+  return BigInt(estimate.events) * estimate.rates.eventFee + BigInt(estimate.uploads) * uploadChargeFor(estimate.rates, LOG_UPLOAD_CAP_BYTES) + BigInt(liveLogTailEventBudget(runTimeoutMs)) * estimate.rates.eventFee;
 }
 function makeAffordabilityCheck(args) {
-  const { ctx, env, log } = args;
+  const { ctx, env, log, runTimeoutMs } = args;
   return async (estimate) => {
-    const cost = estimateRunCost(estimate);
+    const cost = estimateRunCost(estimate, runTimeoutMs);
     const store = new ChannelMapStore(resolveChannelPaths(env));
     const mine = store.list().filter(
       (record) => record.identity.toLowerCase() === ctx.ownerPubkey.toLowerCase() && record.supersededAt === void 0
@@ -2250,16 +2363,13 @@ async function runCiServe(args, deps) {
     io.err(CI_SERVE_USAGE);
     return 2;
   }
-  const gateway = (flags.gateway ?? forced.env["RIG_ARWEAVE_GATEWAY"] ?? PREFERRED_GATEWAY).replace(/\/+$/, "");
-  const readGateways = [`${gateway}/raw`, ...ARWEAVE_GATEWAYS];
+  const gateway = configuredGateway(flags.gateway, forced.env) ?? PREFERRED_GATEWAY;
+  const readGateways = readGatewaysFor(gateway);
   let runner;
   if (forced.runner) {
     runner = forced.runner;
   } else {
-    const act = new ActRunner({
-      ...flags.actBin !== void 0 ? { actBin: flags.actBin } : {},
-      ...flags.platforms ? { platforms: flags.platforms } : {}
-    });
+    const act = new ActRunner(actRunnerOptions(flags));
     if (act.binary(forced.env) === null) {
       io.err(
         "rig ci serve: the act executable was not found \u2014 install nektos/act (https://github.com/nektos/act) on this host, or point --act-bin / RIG_ACT_BIN at it. Nothing was started or paid."
@@ -2302,11 +2412,14 @@ async function runCiServe(args, deps) {
       canAfford: forced.canAfford ?? makeAffordabilityCheck({
         ctx,
         env: forced.env,
-        log: (line) => io.err(line)
+        log: (line) => io.err(line),
+        runTimeoutMs: flags.timeoutMs
       }),
       ...forced.webSocketFactory ? { webSocketFactory: forced.webSocketFactory } : {},
       ...forced.fetchFn ? { fetchFn: forced.fetchFn } : {},
-      ...forced.resolveSha ? { resolveSha: forced.resolveSha } : {},
+      // SHAs the object map does not cover are resolved against the SAME
+      // permaweb the objects are read from, not arweave.net (#183).
+      resolveSha: forced.resolveSha ?? shaResolverFor(flags.gateway, forced.env),
       ...forced.clock ? { clock: forced.clock } : {},
       ...firstRun ? { onRunConcluded: (run) => concludeFirstRun(run) } : {},
       log: (line) => io.err(line)
@@ -2376,8 +2489,10 @@ async function runCiServe(args, deps) {
 }
 export {
   CI_SERVE_USAGE,
+  actRunnerOptions,
   estimateRunCost,
   makeAffordabilityCheck,
+  parseServeArgs,
   runCiServe
 };
-//# sourceMappingURL=ci-serve-PYEHIBN7.js.map
+//# sourceMappingURL=ci-serve-T33FCQVT.js.map