eve-hub 0.16.43 → 0.16.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve-hub",
-  "version": "0.16.43",
+  "version": "0.16.44",
   "license": "Apache-2.0",
   "description": "Bot-side code shared by every hub agent: registry tools, the roster hook, the eve channel, the host sandbox and browser, and model helpers.",
   "type": "module",

package/schedules/track.d.mts

@@ -0,0 +1,3 @@
+export const SCHEDULE_BOT: "main";
+/** Runs `fn` as one run of the kit schedule `id` in the hub's run history; `fn` gets the run's id, undefined on a hub that keeps no history. A paused schedule's `fn` doesn't run. */
+export function trackRun<T>(id: string, fn: (run: string | undefined) => Promise<T> | T, options?: { bot?: string; fetchImpl?: typeof fetch; base?: string; log?: Pick<Console, "log" | "error">; hosted?: boolean }): Promise<T | undefined>;

package/schedules/track.mjs

@@ -0,0 +1,38 @@
+// Reports one dispatch of a kit schedule to the hub's run history (the Schedules pane reads it): the hub is told the run started
+// (POST /api/schedules/<bot>/<id>/runs answers with the run's id and whether the schedule is paused, which skips `fn`) and how it
+// ended (.../runs/<run>/end, with the error when `fn` threw). A commit that carries the id adds its posts to the run
+// (PUT .../state { run }). A hub that keeps no run history (the local one) answers 404 to the start, and `fn` runs untracked; on the hosted hub
+// (`VERCEL` set) a 404 means the schedule is unknown, which throws so the run is not lost silently.
+//
+// Plain JS on purpose: the schedules (TypeScript, bundled by eve) and the tests (plain node) import the same module.
+import { registryFetch } from "../registry-fetch.mjs";
+
+// The kit's schedules are installed on the coordinator, which the hub's own schedule paths already call `main`.
+export const SCHEDULE_BOT = "main";
+
+const path = (bot, id) => `/api/schedules/${encodeURIComponent(bot)}/${id.split("/").map(encodeURIComponent).join("/")}/runs`;
+
+export async function trackRun(id, fn, { bot = SCHEDULE_BOT, fetchImpl = fetch, base, log = console, hosted = Boolean(process.env.VERCEL) } = {}) {
+  const call = async (suffix, body) => {
+    const res = await registryFetch(`${path(bot, id)}${suffix}`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) }, { deadlineMs: 10_000, fetchImpl, ...(base === undefined ? {} : { base }) });
+    if (res.status === 404 && !hosted) return null;
+    if (!res.ok) throw new Error(`POST ${path(bot, id)}${suffix}: ${res.status} ${(await res.text()).slice(0, 300)}`);
+    return res.json();
+  };
+  const started = await call("", {});
+  if (!started) return fn(undefined);
+  if (started.paused) {
+    log.log(`schedule ${bot}/${id} skipped: paused`);
+    return;
+  }
+  const end = `/${encodeURIComponent(started.run)}/end`;
+  let result;
+  try {
+    result = await fn(started.run);
+  } catch (error) {
+    await call(end, { error: (String(error?.message ?? error) || "the run failed").slice(0, 2000) }).catch((endError) => log.error(`schedule ${bot}/${id}: the run's end was not recorded: ${endError.message}`));
+    throw error;
+  }
+  await call(end, {});
+  return result;
+}

package/schedules/tracker-prs.d.ts

@@ -1,5 +1,5 @@
 declare const _default: {
     cron: string;
-    run(): Promise<void>;
+    run: () => Promise<void | undefined>;
 };
 export default _default;

package/schedules/tracker-prs.js

@@ -2,11 +2,12 @@
 // and to Dropped when it closed (schedules/tracker-prs-run.mjs).
 import { defineSchedule } from "eve/schedules";
 import { runTrackerPrs } from "./tracker-prs-run.mjs";
+import { trackRun } from "./track.mjs";
 export default defineSchedule({
     cron: "*/10 * * * *",
-    async run() {
+    run: () => trackRun("tracker-prs", async () => {
         const { asked, moved } = await runTrackerPrs();
         if (moved)
             console.log(`[hub:tracker-prs] ${moved} of ${asked} rows moved`);
-    },
+    }),
 });

package/schedules/workspace-review.d.ts

@@ -4,13 +4,15 @@ export declare const workspaceReviewPost: (now: number) => {
     text: string;
     clientId: string;
 };
-export declare function fireWorkspaceReview({ fetchImpl, base, now }?: {
+/** `run` is the id trackRun got for this firing, so the post counts toward that run. */
+export declare function fireWorkspaceReview({ fetchImpl, base, now, run }?: {
     fetchImpl?: typeof fetch;
     base?: string;
     now?: number;
+    run?: string;
 }): Promise<void>;
 declare const _default: {
     cron: string;
-    run: () => Promise<void>;
+    run: () => Promise<void | undefined>;
 };
 export default _default;

package/schedules/workspace-review.js

@@ -6,19 +6,21 @@
 // schedule in the app stops the post. The post is keyed on the UTC day, so a retry of the same firing posts once.
 import { defineSchedule } from "eve/schedules";
 import { registryFetch } from "../registry-fetch.mjs";
+import { SCHEDULE_BOT, trackRun } from "./track.mjs";
 export const WORKSPACE_REVIEW_PROMPT = "Load the `workspace-review` skill and follow it: score the last 7 days against the week before, open the draft PRs for the human's profile and memory and for the bots and schedules, and post the scorecard and proposals here.";
 /** The one post a firing commits: to main, keyed on the day it fired. */
 export const workspaceReviewPost = (now) => ({ text: `@main ${WORKSPACE_REVIEW_PROMPT}`, clientId: `workspace-review:${new Date(now).toISOString().slice(0, 10)}` });
-export async function fireWorkspaceReview({ fetchImpl = fetch, base, now = Date.now() } = {}) {
-    const res = await registryFetch("/api/schedules/main/workspace-review/state", {
+/** `run` is the id trackRun got for this firing, so the post counts toward that run. */
+export async function fireWorkspaceReview({ fetchImpl = fetch, base, now = Date.now(), run } = {}) {
+    const res = await registryFetch(`/api/schedules/${SCHEDULE_BOT}/workspace-review/state`, {
         method: "PUT",
         headers: { "content-type": "application/json" },
-        body: JSON.stringify({ posts: [workspaceReviewPost(now)] }),
+        body: JSON.stringify({ posts: [workspaceReviewPost(now)], ...(run === undefined ? {} : { run }) }),
     }, { fetchImpl, deadlineMs: 10_000, ...(base === undefined ? {} : { base }) });
     if (!res.ok)
         throw new Error(`PUT /api/schedules/main/workspace-review/state: ${res.status} ${(await res.text()).slice(0, 300)}`);
 }
 export default defineSchedule({
     cron: "0 8 * * 1",
-    run: () => fireWorkspaceReview(),
+    run: () => trackRun("workspace-review", (run) => fireWorkspaceReview({ run })),
 });