@mycadet/assistant 0.12.11 → 0.13.0

package/src/background-wake/next-wake.test.ts

@@ -1,335 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-import { setConfig } from "../__tests__/helpers/set-config.js";
-import { hasSetConstructs } from "../schedule/recurrence-engine.js";
-
-type MockHeartbeatConfig = {
-  enabled: boolean;
-  intervalMs: number;
-  cronExpression: string | null;
-  timezone: string | null;
-  activeHoursStart: number | null;
-  activeHoursEnd: number | null;
-  maxConsecutiveRuns: number | null;
-};
-
-type MockSchedule = {
-  id: string;
-  nextRunAt: number;
-  enabled: boolean;
-  mode: "notify" | "execute" | "script" | "wake";
-  createdBy: string;
-  status: "active" | "firing" | "fired" | "cancelled";
-  syntax: "cron" | "rrule";
-  expression: string | null;
-  timezone: string | null;
-  updatedAt: number;
-};
-
-let heartbeatConfig: MockHeartbeatConfig;
-let heartbeatNextRunAt: number | null;
-let heartbeatConsecutiveRunCapReached: boolean;
-let schedules: MockSchedule[];
-let computedCronNextRunAt: number;
-
-mock.module("../heartbeat/heartbeat-service.js", () => ({
-  HeartbeatService: {
-    getInstance: () =>
-      heartbeatNextRunAt == null
-        ? undefined
-        : {
-            nextRunAt: heartbeatNextRunAt,
-            isConsecutiveRunCapReached: heartbeatConsecutiveRunCapReached,
-          },
-  },
-}));
-
-mock.module("../schedule/recurrence-engine.js", () => ({
-  hasSetConstructs,
-  computeNextRunAt: () => computedCronNextRunAt,
-}));
-
-mock.module("../schedule/schedule-store.js", () => ({
-  listSchedules: (options?: { enabledOnly?: boolean }) =>
-    options?.enabledOnly
-      ? schedules.filter((schedule) => schedule.enabled)
-      : schedules,
-}));
-
-const { computeNextBackgroundWakeIntent } = await import("./next-wake.js");
-
-// Seed the current heartbeat config for real before invoking the intent
-// computer, mirroring the per-call read the old getConfig mock provided.
-function computeWakeIntent(now: number) {
-  setConfig("heartbeat", heartbeatConfig);
-  return computeNextBackgroundWakeIntent(now);
-}
-
-const NOW = 1_800_000_000_000;
-
-describe("computeNextBackgroundWakeIntent", () => {
-  beforeEach(() => {
-    heartbeatConfig = {
-      enabled: true,
-      intervalMs: 30 * 60_000,
-      cronExpression: null,
-      timezone: null,
-      activeHoursStart: 8,
-      activeHoursEnd: 22,
-      maxConsecutiveRuns: 3,
-    };
-    heartbeatNextRunAt = null;
-    heartbeatConsecutiveRunCapReached = false;
-    schedules = [];
-    computedCronNextRunAt = NOW + 3_600_000;
-    setConfig("ui", {});
-  });
-
-  test("returns heartbeat-only interval wake intent", () => {
-    const intent = computeWakeIntent(NOW);
-
-    expect(intent).not.toBeNull();
-    expect(intent!.nextWakeAt).toBe(NOW + heartbeatConfig.intervalMs);
-    expect(intent!.actualNextDueAt).toBe(NOW + heartbeatConfig.intervalMs);
-    expect(intent!.reason).toBe("heartbeat");
-    expect(intent!.sourcePayload.heartbeat).toMatchObject({
-      nextRunAt: NOW + heartbeatConfig.intervalMs,
-      mode: "interval",
-      intervalMs: heartbeatConfig.intervalMs,
-      cronExpression: null,
-    });
-    expect(intent!.sourcePayload.schedules).toEqual([]);
-  });
-
-  test("uses the running heartbeat service next run when available", () => {
-    heartbeatNextRunAt = NOW + 12_345;
-
-    const intent = computeWakeIntent(NOW);
-
-    expect(intent).not.toBeNull();
-    expect(intent!.nextWakeAt).toBe(heartbeatNextRunAt);
-    expect(intent!.actualNextDueAt).toBe(heartbeatNextRunAt);
-    expect(intent!.reason).toBe("heartbeat");
-  });
-
-  test("resolves heartbeat timezone from the user zone when unset", () => {
-    setConfig("ui", { detectedTimezone: "America/Los_Angeles" });
-    const intent = computeWakeIntent(NOW);
-    expect(intent).not.toBeNull();
-    expect(intent!.sourcePayload.heartbeat!.timezone).toBe(
-      "America/Los_Angeles",
-    );
-    setConfig("ui", {});
-  });
-
-  test("returns heartbeat-only cron wake intent", () => {
-    heartbeatConfig.cronExpression = "0 9 * * *";
-    heartbeatConfig.timezone = "America/New_York";
-    computedCronNextRunAt = NOW + 42_000;
-
-    const intent = computeWakeIntent(NOW);
-
-    expect(intent).not.toBeNull();
-    expect(intent!.nextWakeAt).toBe(computedCronNextRunAt);
-    expect(intent!.reason).toBe("heartbeat");
-    expect(intent!.sourcePayload.heartbeat).toMatchObject({
-      nextRunAt: computedCronNextRunAt,
-      mode: "cron",
-      cronExpression: "0 9 * * *",
-      timezone: "America/New_York",
-    });
-  });
-
-  test("returns schedule-only wake intent", () => {
-    heartbeatConfig.enabled = false;
-    schedules = [
-      scheduleFixture({
-        id: "schedule-later",
-        nextRunAt: NOW + 60_000,
-      }),
-      scheduleFixture({
-        id: "schedule-sooner",
-        nextRunAt: NOW + 30_000,
-      }),
-    ];
-
-    const intent = computeWakeIntent(NOW);
-
-    expect(intent).not.toBeNull();
-    expect(intent!.nextWakeAt).toBe(NOW + 30_000);
-    expect(intent!.actualNextDueAt).toBe(NOW + 30_000);
-    expect(intent!.reason).toBe("schedule");
-    expect(intent!.sourcePayload.heartbeat).toBeNull();
-    expect(intent!.sourcePayload.schedules.map((s) => s.id)).toEqual([
-      "schedule-sooner",
-      "schedule-later",
-    ]);
-  });
-
-  test("includes defer-created wake schedules", () => {
-    heartbeatConfig.enabled = false;
-    schedules = [
-      scheduleFixture({
-        id: "defer-wake",
-        nextRunAt: NOW + 10_000,
-        mode: "wake",
-        createdBy: "defer",
-      }),
-    ];
-
-    const intent = computeWakeIntent(NOW);
-
-    expect(intent).not.toBeNull();
-    expect(intent!.nextWakeAt).toBe(NOW + 10_000);
-    expect(intent!.sourcePayload.schedules).toEqual([
-      expect.objectContaining({
-        id: "defer-wake",
-        mode: "wake",
-        createdBy: "defer",
-      }),
-    ]);
-  });
-
-  test("returns mixed when heartbeat and schedule are co-due", () => {
-    heartbeatNextRunAt = NOW + 50_000;
-    schedules = [
-      scheduleFixture({
-        id: "co-due",
-        nextRunAt: NOW + 50_000,
-      }),
-    ];
-
-    const intent = computeWakeIntent(NOW);
-
-    expect(intent).not.toBeNull();
-    expect(intent!.nextWakeAt).toBe(NOW + 50_000);
-    expect(intent!.actualNextDueAt).toBe(NOW + 50_000);
-    expect(intent!.reason).toBe("mixed");
-  });
-
-  test("ignores disabled heartbeat and disabled schedules", () => {
-    heartbeatConfig.enabled = false;
-    schedules = [
-      scheduleFixture({
-        id: "disabled",
-        enabled: false,
-        nextRunAt: NOW + 10_000,
-      }),
-    ];
-
-    expect(computeWakeIntent(NOW)).toBeNull();
-  });
-
-  test("ignores inactive enabled schedules", () => {
-    heartbeatConfig.enabled = false;
-    schedules = [
-      scheduleFixture({
-        id: "fired",
-        status: "fired",
-        nextRunAt: NOW + 10_000,
-      }),
-      scheduleFixture({
-        id: "zero",
-        nextRunAt: 0,
-      }),
-    ];
-
-    expect(computeWakeIntent(NOW)).toBeNull();
-  });
-
-  test("reports far-future due work without applying storage horizon", () => {
-    heartbeatConfig.enabled = false;
-    const actualNextDueAt = NOW + 45 * 24 * 60 * 60 * 1000;
-    schedules = [
-      scheduleFixture({
-        id: "far-future",
-        nextRunAt: actualNextDueAt,
-      }),
-    ];
-
-    const intent = computeWakeIntent(NOW);
-
-    expect(intent).not.toBeNull();
-    expect(intent!.reason).toBe("schedule");
-    expect(intent!.actualNextDueAt).toBe(actualNextDueAt);
-    expect(intent!.nextWakeAt).toBe(actualNextDueAt);
-  });
-
-  test("sets computedAt to the local snapshot time", () => {
-    heartbeatConfig.enabled = false;
-    schedules = [
-      scheduleFixture({
-        id: "scheduled",
-        nextRunAt: NOW + 10_000,
-      }),
-    ];
-    const before = Date.now();
-
-    const intent = computeWakeIntent(NOW);
-
-    const after = Date.now();
-    expect(intent).not.toBeNull();
-    expect(intent!.computedAt).toBeGreaterThanOrEqual(before);
-    expect(intent!.computedAt).toBeLessThanOrEqual(after);
-  });
-
-  test("keeps sourceGeneration stable for unchanged sources", async () => {
-    heartbeatNextRunAt = NOW + 10_000;
-    schedules = [
-      scheduleFixture({
-        id: "scheduled",
-        nextRunAt: NOW + 20_000,
-      }),
-    ];
-
-    const first = computeWakeIntent(NOW);
-    await new Promise((resolve) => setTimeout(resolve, 2));
-    const second = computeWakeIntent(NOW);
-
-    expect(first).not.toBeNull();
-    expect(second).not.toBeNull();
-    expect(first!.computedAt).not.toBe(second!.computedAt);
-    expect(first!.sourceGeneration).toBe(second!.sourceGeneration);
-  });
-
-  test("returns null when heartbeat consecutive run cap is reached and no schedules", () => {
-    heartbeatNextRunAt = NOW + 30_000;
-    heartbeatConsecutiveRunCapReached = true;
-
-    expect(computeWakeIntent(NOW)).toBeNull();
-  });
-
-  test("returns schedule-only intent when heartbeat consecutive run cap is reached", () => {
-    heartbeatNextRunAt = NOW + 30_000;
-    heartbeatConsecutiveRunCapReached = true;
-    schedules = [
-      scheduleFixture({
-        id: "still-active",
-        nextRunAt: NOW + 60_000,
-      }),
-    ];
-
-    const intent = computeWakeIntent(NOW);
-
-    expect(intent).not.toBeNull();
-    expect(intent!.reason).toBe("schedule");
-    expect(intent!.sourcePayload.heartbeat).toBeNull();
-    expect(intent!.sourcePayload.schedules).toHaveLength(1);
-  });
-});
-
-function scheduleFixture(overrides: Partial<MockSchedule>): MockSchedule {
-  return {
-    id: "schedule",
-    nextRunAt: NOW + 60_000,
-    enabled: true,
-    mode: "execute",
-    createdBy: "agent",
-    status: "active",
-    syntax: "cron",
-    expression: "*/5 * * * *",
-    timezone: null,
-    updatedAt: NOW - 1_000,
-    ...overrides,
-  };
-}

package/src/background-wake/next-wake.ts

@@ -1,188 +0,0 @@
-import { createHash } from "node:crypto";
-
-import { getConfig } from "../config/loader.js";
-import { HeartbeatService } from "../heartbeat/heartbeat-service.js";
-import { computeNextRunAt } from "../schedule/recurrence-engine.js";
-import { listSchedules, type ScheduleJob } from "../schedule/schedule-store.js";
-import { resolveScheduleTimezone } from "../schedule/schedule-timezone.js";
-
-export type BackgroundWakeIntentReason = "heartbeat" | "schedule" | "mixed";
-
-export interface BackgroundWakeSourcePayload {
-  heartbeat: HeartbeatWakeSource | null;
-  schedules: ScheduleWakeSource[];
-}
-
-export interface BackgroundWakeIntent {
-  nextWakeAt: number;
-  actualNextDueAt: number;
-  reason: BackgroundWakeIntentReason;
-  sourceGeneration: string;
-  computedAt: number;
-  sourcePayload: BackgroundWakeSourcePayload;
-}
-
-interface HeartbeatWakeSource {
-  nextRunAt: number;
-  mode: "cron" | "interval";
-  intervalMs: number;
-  cronExpression: string | null;
-  timezone: string | null;
-  activeHoursStart: number | null;
-  activeHoursEnd: number | null;
-  maxConsecutiveRuns: number | null;
-}
-
-interface ScheduleWakeSource {
-  id: string;
-  nextRunAt: number;
-  mode: ScheduleJob["mode"];
-  createdBy: string;
-  status: ScheduleJob["status"];
-  updatedAt: number;
-}
-
-type WakeCandidate = {
-  nextRunAt: number;
-  source: "heartbeat" | "schedule";
-};
-
-export function computeNextBackgroundWakeIntent(
-  now = Date.now(),
-): BackgroundWakeIntent | null {
-  const heartbeat = getHeartbeatWakeSource(now);
-  const schedules = getScheduleWakeSources();
-  const computedAt = Date.now();
-  const candidates: WakeCandidate[] = [];
-
-  if (heartbeat) {
-    candidates.push({ nextRunAt: heartbeat.nextRunAt, source: "heartbeat" });
-  }
-  for (const schedule of schedules) {
-    candidates.push({ nextRunAt: schedule.nextRunAt, source: "schedule" });
-  }
-
-  if (candidates.length === 0) {
-    return null;
-  }
-
-  const actualNextDueAt = Math.min(...candidates.map((c) => c.nextRunAt));
-  const nextWakeAt = actualNextDueAt;
-  const dueSources = new Set(
-    candidates
-      .filter((candidate) => candidate.nextRunAt === actualNextDueAt)
-      .map((candidate) => candidate.source),
-  );
-  const reason =
-    dueSources.size > 1
-      ? "mixed"
-      : dueSources.has("heartbeat")
-        ? "heartbeat"
-        : "schedule";
-  const sourcePayload = { heartbeat, schedules };
-
-  return {
-    nextWakeAt,
-    actualNextDueAt,
-    reason,
-    sourceGeneration: computeSourceGeneration({
-      actualNextDueAt,
-      sourcePayload,
-    }),
-    computedAt,
-    sourcePayload,
-  };
-}
-
-function getHeartbeatWakeSource(now: number): HeartbeatWakeSource | null {
-  const config = getConfig().heartbeat;
-  if (!config.enabled) {
-    return null;
-  }
-
-  const service = HeartbeatService.getInstance();
-  if (service?.isConsecutiveRunCapReached) {
-    return null;
-  }
-  if (service?.isDailyCapReached) {
-    return null;
-  }
-
-  const serviceNextRunAt = service?.nextRunAt ?? null;
-  let nextRunAt = serviceNextRunAt;
-  const mode = config.cronExpression != null ? "cron" : "interval";
-  const timezone = resolveScheduleTimezone(config.timezone);
-
-  if (nextRunAt == null) {
-    if (config.cronExpression != null) {
-      try {
-        nextRunAt = computeNextRunAt(
-          {
-            syntax: "cron",
-            expression: config.cronExpression,
-            timezone,
-          },
-          now,
-        );
-      } catch {
-        nextRunAt = now + config.intervalMs;
-      }
-    } else {
-      nextRunAt = now + config.intervalMs;
-    }
-  }
-
-  if (!Number.isFinite(nextRunAt) || nextRunAt <= 0) {
-    return null;
-  }
-
-  return {
-    nextRunAt,
-    mode,
-    intervalMs: config.intervalMs,
-    cronExpression: config.cronExpression,
-    timezone,
-    activeHoursStart: config.activeHoursStart,
-    activeHoursEnd: config.activeHoursEnd,
-    maxConsecutiveRuns: config.maxConsecutiveRuns,
-  };
-}
-
-function getScheduleWakeSources(): ScheduleWakeSource[] {
-  return listSchedules({ enabledOnly: true })
-    .filter((schedule) => schedule.status === "active")
-    .filter((schedule) => Number.isFinite(schedule.nextRunAt))
-    .filter((schedule) => schedule.nextRunAt > 0)
-    .sort((a, b) => a.nextRunAt - b.nextRunAt || a.id.localeCompare(b.id))
-    .map((schedule) => ({
-      id: schedule.id,
-      nextRunAt: schedule.nextRunAt,
-      mode: schedule.mode,
-      createdBy: schedule.createdBy,
-      status: schedule.status,
-      updatedAt: schedule.updatedAt,
-    }));
-}
-
-function computeSourceGeneration(input: {
-  actualNextDueAt: number;
-  sourcePayload: BackgroundWakeSourcePayload;
-}): string {
-  return `bw1:${createHash("sha256")
-    .update(stableStringify(input))
-    .digest("hex")}`;
-}
-
-function stableStringify(value: unknown): string {
-  if (value == null || typeof value !== "object") {
-    return JSON.stringify(value);
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
-  }
-  const record = value as Record<string, unknown>;
-  return `{${Object.keys(record)
-    .sort()
-    .map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`)
-    .join(",")}}`;
-}

package/src/background-wake/publisher.ts

@@ -1,93 +0,0 @@
-import { getLogger } from "../util/logger.js";
-import {
-  clearBackgroundWakeIntent,
-  publishBackgroundWakeIntent,
-} from "./cloud-client.js";
-import {
-  type BackgroundWakeIntent,
-  computeNextBackgroundWakeIntent,
-} from "./next-wake.js";
-
-const log = getLogger("background-wake-publisher");
-const REFRESH_DEBOUNCE_MS = 250;
-
-let refreshTimer: ReturnType<typeof setTimeout> | null = null;
-let pendingReason: string | null = null;
-let inFlightRefresh: Promise<void> | null = null;
-let lastIntentSnapshot: BackgroundWakeIntent | null = null;
-
-export function refreshBackgroundWakeIntent(reason: string): void {
-  pendingReason = reason;
-  schedulePendingRefresh();
-}
-
-function schedulePendingRefresh(): void {
-  if (refreshTimer || inFlightRefresh) {
-    return;
-  }
-  refreshTimer = setTimeout(runPendingRefresh, REFRESH_DEBOUNCE_MS);
-  refreshTimer.unref?.();
-}
-
-function runPendingRefresh(): void {
-  if (refreshTimer) {
-    clearTimeout(refreshTimer);
-    refreshTimer = null;
-  }
-
-  const reason = pendingReason ?? "unspecified";
-  pendingReason = null;
-  const refresh = runRefresh(reason).finally(() => {
-    if (inFlightRefresh === refresh) {
-      inFlightRefresh = null;
-    }
-    if (pendingReason) {
-      schedulePendingRefresh();
-    }
-  });
-  inFlightRefresh = refresh;
-}
-
-async function runRefresh(reason: string): Promise<void> {
-  try {
-    const intent = computeNextBackgroundWakeIntent();
-    if (intent) {
-      const result = await publishBackgroundWakeIntent(intent);
-      lastIntentSnapshot = intent;
-      log.debug({ reason, result }, "Background wake intent refreshed");
-      return;
-    }
-
-    const result = await clearBackgroundWakeIntent(lastIntentSnapshot);
-    if (result.status === "cleared") {
-      lastIntentSnapshot = null;
-    }
-    log.debug({ reason, result }, "Background wake intent cleared");
-  } catch (err) {
-    log.warn({ err, reason }, "Failed to refresh background wake intent");
-  }
-}
-
-/** @internal Test helper. */
-export async function flushBackgroundWakeIntentRefreshForTest(): Promise<void> {
-  if (refreshTimer) {
-    runPendingRefresh();
-  }
-  if (inFlightRefresh) {
-    await inFlightRefresh;
-  }
-  if (refreshTimer) {
-    await flushBackgroundWakeIntentRefreshForTest();
-  }
-}
-
-/** @internal Test helper. */
-export function resetBackgroundWakeIntentPublisherForTest(): void {
-  if (refreshTimer) {
-    clearTimeout(refreshTimer);
-    refreshTimer = null;
-  }
-  pendingReason = null;
-  inFlightRefresh = null;
-  lastIntentSnapshot = null;
-}