@cronwatch/sdk 0.14.0 → 0.14.2

package/dist/index.cjs

@@ -722,7 +722,7 @@ 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 muteOpens(previous, next) {
   const muted = cloneState(next);
@@ -993,11 +993,15 @@ function stringify(part) {
   }
 }
 function createRecorder(run) {
+  const window = OUTPUT_CAP + REDACT_EDGE + 2;
+  const copy = (text) => JSON.parse(JSON.stringify(text));
   const lines = [];
   let size = 0;
   const head = [];
   let headSize = 0;
-  let dropped = false;
+  let whole = "";
+  let tail2 = "";
+  let logged = false;
   const metrics = {};
   const controller = new AbortController();
   const context = {
@@ -1006,16 +1010,23 @@ function createRecorder(run) {
     startedAt: run.startedAt,
     signal: controller.signal,
     log(...parts) {
-      const line = parts.map(stringify).join(" ");
+      let line = parts.map(stringify).join(" ");
+      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));
       if (headSize < OUTPUT_CAP) {
-        head.push(line);
+        head.push(copy(line.slice(0, OUTPUT_CAP - headSize)));
         headSize += line.length + 1;
       }
+      line = stripNul(line);
+      if (line.length >= window) {
+        line = copy(line.slice(-68609));
+      }
       lines.push(line);
       size += line.length + 1;
-      while (size > 64 * 1024 && lines.length > 1) {
+      while (size > window && lines.length > 1) {
         size -= lines.shift().length + 1;
-        dropped = true;
       }
     },
     metric(name, value) {
@@ -1032,10 +1043,8 @@ function createRecorder(run) {
     context,
     output: () => lines.length === 0 ? null : lines.join("\n"),
     expectText: () => {
-      if (lines.length === 0) return null;
-      const all = lines.join("\n");
-      if (!dropped && all.length <= 2 * OUTPUT_CAP) return all;
-      return head.join("\n").slice(0, OUTPUT_CAP) + "\n" + all.slice(-OUTPUT_CAP);
+      if (!logged) return null;
+      return whole ?? head.join("\n").slice(0, OUTPUT_CAP) + "\n" + tail2;
     },
     metrics: () => ({ ...metrics }),
     abort: () => controller.abort()
@@ -1209,7 +1218,7 @@ function staticAsset(path, base) {
 }
 
 // src/version.ts
-var VERSION = "0.14.0";
+var VERSION = "0.14.2";
 var API_VERSION = 1;
 
 // src/routes/timeline.ts
@@ -1999,6 +2008,7 @@ function stripBase(pathname, base) {
 }
 var MAX_REQUEST_BODY = 1 << 20;
 var TOO_LARGE = /* @__PURE__ */ Symbol("too large");
+var BAD_BODY = /* @__PURE__ */ Symbol("malformed body");
 async function readLimited(request) {
   const length = Number(request.headers.get("content-length"));
   if (Number.isFinite(length) && length > MAX_REQUEST_BODY) return TOO_LARGE;
@@ -2045,14 +2055,14 @@ async function readBody(request) {
   try {
     if (json2) {
       const data = await copy.json();
-      return typeof data === "object" && data !== null ? Object.fromEntries(Object.entries(data).map(([k, v]) => [k, String(v)])) : {};
+      return typeof data === "object" && data !== null && !Array.isArray(data) ? Object.fromEntries(Object.entries(data).map(([k, v]) => [k, String(v)])) : BAD_BODY;
     }
     const fields = await copy.formData();
     const out = {};
     for (const [k, v] of fields.entries()) out[k] = String(v);
     return out;
   } catch {
-    return {};
+    return BAD_BODY;
   }
 }
 function crossSite(request, publicOrigin) {
@@ -2118,6 +2128,7 @@ function buildRoutes(cw, options = {}) {
     const signInPage = () => generated ? html(messagePage("Sign in", "CRONWATCH_TOKEN is not set, so this development server made a token. The sign-in link is in the server log: open it once, or enter the token from it below, and this browser stays signed in.", base, true), 401) : html(messagePage("Sign in", "Enter your CRONWATCH_TOKEN and this browser stays signed in.", base, true), 401);
     if (token && method === "POST" && path === "/signin") {
       const body = await readBody(request);
+      if (body === BAD_BODY) return html(messagePage("Bad request", "Malformed request body", base), 400);
       const sent = body === TOO_LARGE ? void 0 : body.token;
       if (sent === void 0 || !constantTimeEqual(sent, token)) return signInPage();
       return redirect(signInReturn(request.headers.get("referer"), publicOrigin, base), { "set-cookie": await signInCookie() });
@@ -2175,6 +2186,7 @@ function buildRoutes(cw, options = {}) {
       if (parts[2] === "silence") {
         const body = await readBody(request);
         if (body === TOO_LARGE) return html(messagePage("Not silenced", "The request was too large.", base), 413);
+        if (body === BAD_BODY) return html(messagePage("Not silenced", "Malformed request body", base), 400);
         let duration;
         try {
           duration = silenceDuration(body.for);
@@ -2212,6 +2224,7 @@ function buildRoutes(cw, options = {}) {
         if (rest[2] === "silence") {
           const body = await readBody(request);
           if (body === TOO_LARGE) return api({ ok: false, error: "Request body too large" }, 413);
+          if (body === BAD_BODY) return api({ ok: false, error: "Malformed request body" }, 400);
           let duration;
           try {
             duration = silenceDuration(body.for ?? url.searchParams.get("for"));
@@ -2847,9 +2860,10 @@ var Cronwatch = class {
         if (stored.job !== run.job) return `belongs to job "${stored.job}"`;
       }
     }
+    const tracked = (await this.readState(run.job)).pendingRuns?.includes(run.id) ?? false;
     const claim = await this.claimFinish(run);
     if ("ignored" in claim) return claim.ignored;
-    if (!claim.lateAfterTimeout || run.status === "ok") await this.finishRun(toStored(definition), run, finishedAt);
+    if (!claim.lateAfterTimeout || run.status === "ok") await this.finishRun(toStored(definition), run, finishedAt, tracked && !claim.lateAfterTimeout);
     return null;
   }
   /** A conditional write (Store.updateRunIf), or for a store without one, a read then a plain write. */
@@ -3134,17 +3148,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" } : 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());
+    return this.recordOver(definition, inserted, run, true);
   }
   /** recordRun() for a run already stored. */
   async recordOver(definition, stored, run, evaluate) {
@@ -3152,7 +3165,16 @@ ${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) {
       this.report(new Error(`run ${run.id} of ${run.job} ${claim.ignored}; ignored`), `recording ${run.job}`);
@@ -3163,18 +3185,19 @@ ${id}`;
       return [];
     }
     if (claim.lateAfterTimeout && run.status !== "ok") return [];
-    return this.finishRun(definition, run, this.now());
+    return this.finishRun(definition, run, this.now(), tracked && !claim.lateAfterTimeout);
   }
   /**
    * Evaluate a finished run (ok, failed, or timed out by a check), already
    * written, against the job's state and send what that produces. The
    * alerts are written with that state (see outbox()). Never throws.
    */
-  async finishRun(definition, run, now) {
+  async finishRun(definition, run, now, pendingOnly = false) {
     let held;
     try {
       let history = null;
       ({ result: held } = await this.updateState(run.job, async (previous) => {
+        if (pendingOnly && !(previous.pendingRuns ?? []).includes(run.id)) return { state: previous, result: { alerts: [], dropped: 0 } };
         history ??= await this.history(run);
         const before = releaseRun(previous, run.id);
         return this.outbox(applySilence(before, onRunFinish(definition, run, before, history, now), now), definition, now);
@@ -3319,7 +3342,7 @@ ${id}`;
           continue;
         }
         if (run.status === "running" || typeof run.finishedAt !== "number" || run.finishedAt > now - SEND_LEASE_MS) continue;
-        alerts.push(...await this.finishRun(stored.definition, run, now));
+        alerts.push(...await this.finishRun(stored.definition, run, now, true));
       } catch (e) {
         this.onError(e, `evaluating run ${id} of ${stored.name}`);
       }