@cronwatch/sdk 0.14.1 → 0.14.3

package/dist/index.cjs

@@ -722,7 +722,10 @@ function onCheck(def, stored, lastRun, state, now) {
   return { state: next, alerts, nextExpectedAt, dueAt: exp.dueAt };
 }
 function isStuck(def, run, now) {
-  return run.status === "running" && now - run.startedAt > timeoutMs(def);
+  return run.status === "running" && run.finishedAt === null && now - run.startedAt > timeoutMs(def);
+}
+function isStranded(run, now) {
+  return run.status === "running" && run.finishedAt !== null && now - run.finishedAt > SEND_LEASE_MS;
 }
 function muteOpens(previous, next) {
   const muted = cloneState(next);
@@ -899,6 +902,10 @@ function constantTimeEqual(sent, secret) {
   for (let i = 0; i < sent.length; i++) diff |= sent.charCodeAt(i) ^ secret.charCodeAt(i % secret.length);
   return diff === 0;
 }
+function bearerToken(header) {
+  const match = header === null ? null : /^Bearer\s+([\s\S]*)$/i.exec(header);
+  return match ? match[1] : null;
+}
 
 // src/output.ts
 var OUTPUT_CAP = 16 * 1024;
@@ -992,15 +999,45 @@ function stringify(part) {
     return String(part);
   }
 }
+var LineWindow = class {
+  items = [];
+  start = 0;
+  size = 0;
+  get count() {
+    return this.items.length - this.start;
+  }
+  push(line) {
+    this.items.push(line);
+    this.size += line.length + 1;
+  }
+  /** Drops the oldest lines while over `max`, always keeping the newest. */
+  keepAtMost(max) {
+    while (this.size > max && this.count > 1) this.drop();
+  }
+  /** Drops the oldest lines only while what is left still holds `min`. */
+  keepAtLeast(min) {
+    while (this.count > 1 && this.size - (this.items[this.start].length + 1) > min) this.drop();
+  }
+  join() {
+    return this.items.slice(this.start).join("\n");
+  }
+  drop() {
+    this.size -= this.items[this.start].length + 1;
+    this.start += 1;
+    if (this.start >= 1024 && this.start * 2 >= this.items.length) {
+      this.items = this.items.slice(this.start);
+      this.start = 0;
+    }
+  }
+};
 function createRecorder(run) {
   const window = OUTPUT_CAP + REDACT_EDGE + 2;
   const copy = (text) => JSON.parse(JSON.stringify(text));
-  const lines = [];
-  let size = 0;
+  const lines = new LineWindow();
   const head = [];
   let headSize = 0;
   let whole = "";
-  let tail2 = "";
+  const raw = new LineWindow();
   let logged = false;
   const metrics = {};
   const controller = new AbortController();
@@ -1014,7 +1051,8 @@ function createRecorder(run) {
       const separator = logged ? "\n" : "";
       logged = true;
       if (whole !== null) whole = whole.length + separator.length + line.length <= 2 * OUTPUT_CAP ? whole + separator + line : null;
-      tail2 = copy((tail2 + separator + copy(line.slice(-OUTPUT_CAP))).slice(-OUTPUT_CAP));
+      raw.push(copy(line.slice(-OUTPUT_CAP)));
+      raw.keepAtLeast(OUTPUT_CAP);
       if (headSize < OUTPUT_CAP) {
         head.push(copy(line.slice(0, OUTPUT_CAP - headSize)));
         headSize += line.length + 1;
@@ -1024,10 +1062,7 @@ function createRecorder(run) {
         line = copy(line.slice(-68609));
       }
       lines.push(line);
-      size += line.length + 1;
-      while (size > window && lines.length > 1) {
-        size -= lines.shift().length + 1;
-      }
+      lines.keepAtMost(window);
     },
     metric(name, value) {
       if (typeof value !== "number" || !Number.isFinite(value)) {
@@ -1041,10 +1076,10 @@ function createRecorder(run) {
   };
   return {
     context,
-    output: () => lines.length === 0 ? null : lines.join("\n"),
+    output: () => lines.count === 0 ? null : lines.join(),
     expectText: () => {
       if (!logged) return null;
-      return whole ?? head.join("\n").slice(0, OUTPUT_CAP) + "\n" + tail2;
+      return whole ?? head.join("\n").slice(0, OUTPUT_CAP) + "\n" + raw.join().slice(-OUTPUT_CAP);
     },
     metrics: () => ({ ...metrics }),
     abort: () => controller.abort()
@@ -1218,7 +1253,7 @@ function staticAsset(path, base) {
 }
 
 // src/version.ts
-var VERSION = "0.14.1";
+var VERSION = "0.14.3";
 var API_VERSION = 1;
 
 // src/routes/timeline.ts
@@ -1985,10 +2020,6 @@ function forwardedOrigin(request, url) {
     return url.origin;
   }
 }
-function bearerToken(header) {
-  const match = header === null ? null : /^Bearer\s+([\s\S]*)$/i.exec(header);
-  return match ? match[1] : null;
-}
 function signInReturn(referer, publicOrigin, base) {
   if (referer === null || !referer.startsWith(publicOrigin + "/")) return `${base}/`;
   let url;
@@ -2157,13 +2188,14 @@ function buildRoutes(cw, options = {}) {
       return wantsHtml ? html(messagePage("Bad request", "The path is not valid.", base), 400) : api({ ok: false, error: "Bad path" }, 400);
     }
     const parts = decoded;
-    if (method === "GET" && path === "/") {
+    const reads = method === "GET" || method === "HEAD";
+    if (reads && path === "/") {
       const entries = await cw.jobsWithRuns(BOARD_PAGE_RUNS);
       const now = cw.now();
       const runsByJob = new Map(entries.map((entry) => [entry.job.name, entry.runs]));
       return html(dashboardPage(entries.map((entry) => entry.job), runsByJob, now, base, null, await boardLanes(cw, entries, now)));
     }
-    if (method === "GET" && parts[0] === "jobs" && parts.length === 2) {
+    if (reads && parts[0] === "jobs" && parts.length === 2) {
       const job = await cw.jobSummary(parts[1]);
       if (!job) return html(messagePage("No such job", `${parts[1]} is not in the store.`, base), 404);
       const now = cw.now();
@@ -2199,15 +2231,15 @@ function buildRoutes(cw, options = {}) {
     }
     if (parts[0] === "api") {
       const rest = parts.slice(1);
-      if (method === "GET" && rest.length === 0) {
+      if (reads && rest.length === 0) {
         return api({ ok: true, library: LIBRARY, language: LANGUAGE, version: VERSION, api: API_VERSION });
       }
-      if (method === "GET" && rest[0] === "jobs" && rest.length === 1) {
+      if (reads && rest[0] === "jobs" && rest.length === 1) {
         return api({ ok: true, jobs: await cw.jobs() });
       }
       if (rest[0] === "jobs" && rest.length === 2) {
         const name = rest[1];
-        if (method === "GET") {
+        if (reads) {
           const job = await cw.jobSummary(name);
           if (!job) return api({ ok: false, error: "No such job" }, 404);
           return api({ ok: true, job, runs: await cw.runs(name, runsLimit(url.searchParams.get("runs"))) });
@@ -2248,7 +2280,7 @@ function buildRoutes(cw, options = {}) {
           return api({ ok: true, ...result });
         }
       }
-      if (method === "GET" && rest[0] === "runs" && rest.length === 2) {
+      if (reads && rest[0] === "runs" && rest.length === 2) {
         const run = await cw.getRun(rest[1]);
         return run ? api({ ok: true, run }) : api({ ok: false, error: "No such run" }, 404);
       }
@@ -2263,7 +2295,8 @@ function buildRoutes(cw, options = {}) {
       const path = stripBase(url.pathname, base);
       if (path === null) return html(messagePage("Not found", url.pathname, base), 404);
       wantsHtml = !path.startsWith("/api");
-      return await serve(request, url, path, wantsHtml);
+      const response = await serve(request, url, path, wantsHtml);
+      return request.method.toUpperCase() === "HEAD" ? new Response(null, { status: response.status, headers: response.headers }) : response;
     } catch (e) {
       try {
         cw.onError(e, "routes");
@@ -2410,6 +2443,7 @@ var RETRY_BUDGET_MS = 2e4;
 var STATE_ATTEMPTS = 10;
 var HISTORY_PAGE = BASELINE_WINDOW + 5;
 var HISTORY_MAX = 200;
+var STRANDED_ERROR = "Imported, but its finish was never written; marked as timed out";
 function validateDefinition(def) {
   const name = def.name;
   if (def.schedule !== void 0) {
@@ -2586,8 +2620,8 @@ var Cronwatch = class {
             return json({ ok: false, error: "CRON_SECRET is not set, so this job will not run for an unauthenticated request. Set it, or pass secret: null to handler() to allow anyone." }, 503);
           }
           if (secret) {
-            const header = request.headers.get("authorization") ?? "";
-            if (!constantTimeEqual(header, `Bearer ${secret}`)) {
+            const sent = bearerToken(request.headers.get("authorization"));
+            if (sent === null || !constantTimeEqual(sent, secret)) {
               return json({ ok: false, error: "Unauthorized" }, 401);
             }
           }
@@ -3128,6 +3162,17 @@ ${id}`;
       throw new Error(`recordRun: run ids must be 1 to ${MAX_RUN_ID} characters (got ${got}; job "${input.job}")`);
     }
     if (input.id.includes("\0")) throw new Error(`recordRun: run ids cannot contain a NUL character (job "${input.job}")`);
+    const where = `job "${input.job}", run "${input.id}"`;
+    if (!["running", "ok", "failed", "timeout"].includes(input.status)) {
+      throw new Error(`recordRun: status must be "running", "ok", "failed", or "timeout" (${where})`);
+    }
+    if (!Number.isFinite(input.startedAt)) throw new Error(`recordRun: startedAt must be a finite number (${where})`);
+    if (input.finishedAt !== null && !Number.isFinite(input.finishedAt)) throw new Error(`recordRun: finishedAt must be a finite number or null (${where})`);
+    if (input.durationMs !== null && !Number.isFinite(input.durationMs)) throw new Error(`recordRun: durationMs must be a finite number or null (${where})`);
+    for (const field of ["error", "output"]) {
+      if (input[field] !== null && typeof input[field] !== "string") throw new Error(`recordRun: ${field} must be a string or null (${where})`);
+    }
+    if (typeof input.trigger !== "string") throw new Error(`recordRun: trigger must be a string (${where})`);
     for (const [metric, value] of Object.entries(input.metrics ?? {})) {
       if (typeof value !== "number" || !Number.isFinite(value)) {
         throw new Error(`recordRun: metric "${metric}" must be a finite number (job "${input.job}", run "${input.id}")`);
@@ -3148,17 +3193,16 @@ ${id}`;
     const definition = toStored(declared);
     const stored = await this.store.getRun(run.id);
     if (stored) return this.recordOver(definition, stored, run, evaluate);
+    const inserted = evaluate ? { ...run, status: "running", finishedAt: run.status === "running" ? null : this.now() } : run;
     try {
-      await this.store.insertRun(run);
+      await this.store.insertRun(inserted);
     } catch (e) {
       const again = await this.store.getRun(run.id).catch(() => null);
       if (again) return this.recordOver(definition, again, run, evaluate);
       throw e;
     }
     if (!evaluate) return [];
-    await this.updateState(run.job, (before) => ({ state: holdRun(onRunStart(definition, run, before, this.now()), run.id), result: void 0 }));
-    if (run.status === "running") return [];
-    return this.finishRun(definition, run, this.now(), true);
+    return this.recordOver(definition, inserted, run, true);
   }
   /** recordRun() for a run already stored. */
   async recordOver(definition, stored, run, evaluate) {
@@ -3166,7 +3210,15 @@ ${id}`;
       this.report(new Error(`run ${run.id} of ${run.job} belongs to job "${stored.job}"; ignored`), `recording ${run.job}`);
       return [];
     }
-    if (stored.status !== "running" && stored.status !== "timeout" || run.status === "running") return [];
+    if (stored.status !== "running" && stored.status !== "timeout") return [];
+    if (evaluate && stored.status === "running") {
+      await this.updateState(run.job, async (before) => {
+        const current = await this.store.getRun(run.id);
+        if (!current || current.job !== run.job || current.status !== "running" || before.pendingRuns?.includes(run.id)) return { state: before, result: void 0 };
+        return { state: holdRun(onRunStart(definition, run, before, this.now()), run.id), result: void 0 };
+      });
+    }
+    if (run.status === "running") return [];
     const tracked = (await this.readState(run.job)).pendingRuns?.includes(run.id) ?? false;
     const claim = await this.claimFinish(run);
     if ("ignored" in claim) {
@@ -3266,14 +3318,20 @@ ${id}`;
         const stored = found ? this.readJob(found) : null;
         if (stored) this.evaluable(stored);
         const definition = declared ? toStored(declared) : stored?.definition;
-        if (!definition || !isStuck(definition, listed, now)) continue;
+        const stranded = isStranded(listed, now);
+        if (!definition || !(stranded || isStuck(definition, listed, now))) continue;
         const run = await this.store.getRun(listed.id);
         if (!run || run.status !== "running" || run.job !== listed.job) continue;
-        const timeout = timeoutMs(definition);
         run.status = "timeout";
-        run.finishedAt = now;
-        run.durationMs = runDuration(run.startedAt, now);
-        run.error = `Still running after ${formatDuration(timeout)}; marked as timed out`;
+        if (stranded) {
+          run.durationMs ??= runDuration(run.startedAt, run.finishedAt);
+          run.error = STRANDED_ERROR + (run.error === null ? "" : `
+${run.error}`);
+        } else {
+          run.finishedAt = now;
+          run.durationMs = runDuration(run.startedAt, now);
+          run.error = `Still running after ${formatDuration(timeoutMs(definition))}; marked as timed out`;
+        }
         if (!await this.writeRunIf(run, ["running"])) continue;
         alerts.push(...await this.finishRun(definition, run, now));
       } catch (e) {