@app-vitals/agent-admin 0.0.1 → 0.1.0

package/src/trial-expiry-sweeper.integration.test.ts

@@ -0,0 +1,318 @@
+/**
+ * admin/src/trial-expiry-sweeper.integration.test.ts
+ * Integration tests for TrialExpirySweeper against a real PostgreSQL DB —
+ * exercises the real AgentCronJobService.listEnabledWithExpiredTrial() join
+ * query and setEnabled() write path together (ATE-3.1).
+ *
+ * Requires DATABASE_URL_ADMIN_TEST to be set; skips otherwise (mirrors
+ * agent-cron-jobs.integration.test.ts).
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import type { PrismaClient } from "../prisma/client/client.ts";
+import { AgentCronJobService } from "./agent-cron-jobs.ts";
+import { FixedClock } from "./clock.ts";
+import { createAdminPrismaClient } from "./prisma-client.ts";
+import { TrialExpirySweeper } from "./trial-expiry-sweeper.ts";
+
+const TEST_DB = process.env.DATABASE_URL_ADMIN_TEST;
+
+const describeOrSkip = TEST_DB ? describe : describe.skip;
+
+function makePrisma(): PrismaClient {
+  // TEST_DB is guaranteed set — the describe block is skipped otherwise.
+  return createAdminPrismaClient(TEST_DB as string);
+}
+
+const NOW = new Date("2026-06-15T00:00:00.000Z");
+const PAST = new Date("2026-06-01T00:00:00.000Z"); // before NOW — expired
+const FUTURE = new Date("2026-07-01T00:00:00.000Z"); // after NOW — not expired
+
+async function createAgent(
+  prisma: PrismaClient,
+  opts: { name?: string; trialExpiresAt?: Date | null } = {},
+): Promise<string> {
+  const agent = await prisma.agent.create({
+    data: {
+      name: opts.name ?? "Test Agent",
+      typeName: "coding",
+      trialExpiresAt: opts.trialExpiresAt ?? null,
+    },
+  });
+  return agent.id;
+}
+
+async function createCron(
+  prisma: PrismaClient,
+  agentId: string,
+  opts: { enabled?: boolean; name?: string } = {},
+): Promise<string> {
+  const cron = await prisma.agentCronJob.create({
+    data: {
+      agentId,
+      schedule: "0 * * * *",
+      prompt: "test prompt",
+      channel: "C123456",
+      silent: false,
+      enabled: opts.enabled ?? true,
+      name: opts.name ?? null,
+    },
+  });
+  return cron.id;
+}
+
+async function getCronEnabled(
+  prisma: PrismaClient,
+  cronId: string,
+): Promise<boolean> {
+  const cron = await prisma.agentCronJob.findUniqueOrThrow({
+    where: { id: cronId },
+  });
+  return cron.enabled;
+}
+
+describeOrSkip("TrialExpirySweeper (integration)", () => {
+  let prisma: PrismaClient;
+  let sweeper: TrialExpirySweeper;
+
+  beforeEach(async () => {
+    prisma = makePrisma();
+    await prisma.agentToken.deleteMany();
+    await prisma.agentCronJob.deleteMany();
+    await prisma.agentTool.deleteMany();
+    await prisma.agentEnv.deleteMany();
+    await prisma.agent.deleteMany();
+
+    const agentCronJobService = new AgentCronJobService(prisma);
+    sweeper = new TrialExpirySweeper({
+      agentCronJobService,
+      clock: FixedClock(NOW),
+    });
+  });
+
+  afterEach(async () => {
+    await prisma.$disconnect();
+  });
+
+  // ─── AC1: expired trial → every enabled cron disabled ──────────────────────
+
+  it("disables every enabled cron for an agent whose trial has expired", async () => {
+    const agentId = await createAgent(prisma, { trialExpiresAt: PAST });
+    const cronA = await createCron(prisma, agentId, { enabled: true });
+    const cronB = await createCron(prisma, agentId, { enabled: true });
+
+    const result = await sweeper.tick();
+
+    expect(result.disabled).toBe(2);
+    expect(await getCronEnabled(prisma, cronA)).toBe(false);
+    expect(await getCronEnabled(prisma, cronB)).toBe(false);
+  });
+
+  it("leaves an already-disabled cron for an expired-trial agent untouched (not recounted)", async () => {
+    const agentId = await createAgent(prisma, { trialExpiresAt: PAST });
+    const enabledCron = await createCron(prisma, agentId, { enabled: true });
+    const disabledCron = await createCron(prisma, agentId, {
+      enabled: false,
+    });
+
+    const result = await sweeper.tick();
+
+    expect(result.disabled).toBe(1);
+    expect(await getCronEnabled(prisma, enabledCron)).toBe(false);
+    expect(await getCronEnabled(prisma, disabledCron)).toBe(false);
+  });
+
+  it("is idempotent — a second tick after the first finds nothing left to do", async () => {
+    const agentId = await createAgent(prisma, { trialExpiresAt: PAST });
+    await createCron(prisma, agentId, { enabled: true });
+
+    const first = await sweeper.tick();
+    const second = await sweeper.tick();
+
+    expect(first.disabled).toBe(1);
+    expect(second.disabled).toBe(0);
+  });
+
+  // ─── AC2: not-yet-expired / unset trial → no-op ─────────────────────────────
+
+  it("does not touch crons for an agent whose trial has not yet expired", async () => {
+    const agentId = await createAgent(prisma, { trialExpiresAt: FUTURE });
+    const cronId = await createCron(prisma, agentId, { enabled: true });
+
+    const result = await sweeper.tick();
+
+    expect(result.disabled).toBe(0);
+    expect(await getCronEnabled(prisma, cronId)).toBe(true);
+  });
+
+  it("does not touch crons for an agent with trialExpiresAt unset (null)", async () => {
+    const agentId = await createAgent(prisma, { trialExpiresAt: null });
+    const cronId = await createCron(prisma, agentId, { enabled: true });
+
+    const result = await sweeper.tick();
+
+    expect(result.disabled).toBe(0);
+    expect(await getCronEnabled(prisma, cronId)).toBe(true);
+  });
+
+  it("treats trialExpiresAt exactly equal to now as NOT yet expired", async () => {
+    const agentId = await createAgent(prisma, { trialExpiresAt: NOW });
+    const cronId = await createCron(prisma, agentId, { enabled: true });
+
+    const result = await sweeper.tick();
+
+    expect(result.disabled).toBe(0);
+    expect(await getCronEnabled(prisma, cronId)).toBe(true);
+  });
+
+  // ─── Edge cases ──────────────────────────────────────────────────────────
+
+  it("no-ops cleanly for an expired-trial agent with zero cron rows", async () => {
+    await createAgent(prisma, { trialExpiresAt: PAST });
+
+    const result = await sweeper.tick();
+
+    expect(result.disabled).toBe(0);
+  });
+
+  it("only disables crons for the expired agent, leaving a sibling not-yet-expired agent's crons alone", async () => {
+    const expiredAgentId = await createAgent(prisma, {
+      name: "Expired Agent",
+      trialExpiresAt: PAST,
+    });
+    const activeAgentId = await createAgent(prisma, {
+      name: "Active Agent",
+      trialExpiresAt: FUTURE,
+    });
+    const expiredCron = await createCron(prisma, expiredAgentId, {
+      enabled: true,
+    });
+    const activeCron = await createCron(prisma, activeAgentId, {
+      enabled: true,
+    });
+
+    const result = await sweeper.tick();
+
+    expect(result.disabled).toBe(1);
+    expect(await getCronEnabled(prisma, expiredCron)).toBe(false);
+    expect(await getCronEnabled(prisma, activeCron)).toBe(true);
+  });
+
+  it("a bad row does not abort the rest of the sweep (per-row try/catch)", async () => {
+    const agentId = await createAgent(prisma, { trialExpiresAt: PAST });
+    const badCronId = await createCron(prisma, agentId, { enabled: true });
+    const goodCronId = await createCron(prisma, agentId, { enabled: true });
+
+    // A fake service whose setEnabled() throws for one specific cron id but
+    // succeeds for the other — exercises the per-row try/catch directly
+    // against real listing data from the real service.
+    const realService = new AgentCronJobService(prisma);
+    const flaky = {
+      listEnabledWithExpiredTrial: (now: Date) =>
+        realService.listEnabledWithExpiredTrial(now),
+      setEnabled: async (agId: string, cronId: string, enabled: boolean) => {
+        if (cronId === badCronId) {
+          throw new Error("boom");
+        }
+        return realService.setEnabled(agId, cronId, enabled);
+      },
+    };
+    const flakySweeper = new TrialExpirySweeper({
+      agentCronJobService: flaky,
+      clock: FixedClock(NOW),
+    });
+
+    const result = await flakySweeper.tick();
+
+    expect(result.disabled).toBe(1);
+    expect(await getCronEnabled(prisma, badCronId)).toBe(true);
+    expect(await getCronEnabled(prisma, goodCronId)).toBe(false);
+  });
+
+  // ─── SSP-8.1: lockdown marker + restore ─────────────────────────────────────
+
+  it("stamps lockdownDisabledAt on swept crons but not on user-disabled ones", async () => {
+    const agentId = await createAgent(prisma, { trialExpiresAt: PAST });
+    const swept = await createCron(prisma, agentId, { enabled: true });
+    const userDisabled = await createCron(prisma, agentId, { enabled: false });
+
+    await sweeper.tick();
+
+    const sweptRow = await prisma.agentCronJob.findUniqueOrThrow({
+      where: { id: swept },
+    });
+    const userRow = await prisma.agentCronJob.findUniqueOrThrow({
+      where: { id: userDisabled },
+    });
+    expect(sweptRow.enabled).toBe(false);
+    expect(sweptRow.lockdownDisabledAt).not.toBeNull();
+    expect(userRow.lockdownDisabledAt).toBeNull();
+  });
+
+  it("restoreLockdownDisabled re-enables only lockdown-disabled crons and clears the marker", async () => {
+    const agentId = await createAgent(prisma, { trialExpiresAt: PAST });
+    const swept = await createCron(prisma, agentId, { enabled: true });
+    const userDisabled = await createCron(prisma, agentId, { enabled: false });
+    await sweeper.tick();
+
+    const service = new AgentCronJobService(prisma);
+    const restored = await service.restoreLockdownDisabled([agentId]);
+
+    expect(restored).toBe(1);
+    const sweptRow = await prisma.agentCronJob.findUniqueOrThrow({
+      where: { id: swept },
+    });
+    expect(sweptRow.enabled).toBe(true);
+    expect(sweptRow.lockdownDisabledAt).toBeNull();
+    expect(await getCronEnabled(prisma, userDisabled)).toBe(false);
+  });
+
+  it("restoreLockdownDisabled ignores agents not listed and empty input", async () => {
+    const agentId = await createAgent(prisma, { trialExpiresAt: PAST });
+    const other = await createAgent(prisma, { name: "Other" });
+    const cron = await createCron(prisma, agentId, { enabled: true });
+    await sweeper.tick();
+
+    const service = new AgentCronJobService(prisma);
+    expect(await service.restoreLockdownDisabled([])).toBe(0);
+    expect(await service.restoreLockdownDisabled([other])).toBe(0);
+    expect(await getCronEnabled(prisma, cron)).toBe(false);
+  });
+
+  it("a manual setEnabled call clears a stale lockdown marker", async () => {
+    const agentId = await createAgent(prisma, { trialExpiresAt: PAST });
+    const cron = await createCron(prisma, agentId, { enabled: true });
+    await sweeper.tick();
+
+    const service = new AgentCronJobService(prisma);
+    await service.setEnabled(agentId, cron, true);
+    const row = await prisma.agentCronJob.findUniqueOrThrow({
+      where: { id: cron },
+    });
+    expect(row.lockdownDisabledAt).toBeNull();
+  });
+
+  it("a content update() with an explicit enabled value clears the lockdown marker", async () => {
+    const agentId = await createAgent(prisma, { trialExpiresAt: PAST });
+    const cron = await createCron(prisma, agentId, { enabled: true });
+    await sweeper.tick();
+
+    const service = new AgentCronJobService(prisma);
+    const before = await prisma.agentCronJob.findUniqueOrThrow({
+      where: { id: cron },
+    });
+    await service.update(agentId, cron, {
+      schedule: before.schedule,
+      prompt: before.prompt,
+      channel: before.channel,
+      enabled: false,
+    });
+
+    const row = await prisma.agentCronJob.findUniqueOrThrow({
+      where: { id: cron },
+    });
+    expect(row.lockdownDisabledAt).toBeNull();
+    expect(await service.restoreLockdownDisabled([agentId])).toBe(0);
+    expect(await getCronEnabled(prisma, cron)).toBe(false);
+  });
+});

package/src/trial-expiry-sweeper.ts

@@ -0,0 +1,132 @@
+/**
+ * admin/src/trial-expiry-sweeper.ts
+ *
+ * TrialExpirySweeper — disables crons for agents whose trial has expired
+ * (ATE-3.1). Every tick it finds every enabled AgentCronJob belonging to an
+ * agent whose trialExpiresAt has passed and PATCHes each to enabled:false (stamping
+ * lockdownDisabledAt so the lockdown can later be undone) via
+ * AgentCronJobService.setEnabled() — the same service method the
+ * PATCH /agents/:id/crons/:cronId route itself calls (admin/src/agents-api.ts),
+ * invoked in-process rather than over HTTP (mirrors session-alert-sweeper.ts
+ * calling services directly instead of self-calling its own admin API).
+ *
+ * Deliberately does NOT deprovision the agent — no deleteAgentFully() call,
+ * no touching the K8s workload, tokens, or chat history. A trial that ends
+ * should not destroy the workspace, since the customer may convert to paid
+ * later. This sweeper only flips AgentCronJob.enabled; agent/src/runtime/slack.ts's
+ * isTrialExpired() gate is the other half of the lockdown, blocking inbound
+ * Slack messages.
+ *
+ * Naturally idempotent — once every cron for an expired-trial agent is
+ * disabled, listEnabledWithExpiredTrial() finds nothing for that agent on the
+ * next tick, so no extra "have I already swept this agent" state is needed
+ * (unlike session-alert-sweeper's SessionAlertState dedup). No re-entrancy
+ * guard either: overlapping ticks both disabling the same already-disabled
+ * row is harmless (setEnabled is idempotent), unlike the session sweeper's
+ * push-notification side effects.
+ *
+ * Structure mirrors session-alert-sweeper.ts: an injected Clock, a per-row
+ * try/catch so one bad cron can never abort the rest of the sweep, a counted
+ * return value, and registration via setInterval in main.ts (never inside an
+ * app factory, which must stay side-effect-free).
+ */
+
+import { type Clock, SystemClock } from "./clock.ts";
+
+/** The narrow slice of AgentCronJobService this sweeper touches. */
+export interface TrialExpiryCronJobServiceLike {
+  listEnabledWithExpiredTrial(
+    now: Date,
+  ): Promise<Array<{ id: string; agentId: string }>>;
+  setEnabled(
+    agentId: string,
+    cronId: string,
+    enabled: boolean,
+    opts?: { lockdown?: boolean },
+  ): Promise<unknown>;
+}
+
+export interface TrialExpirySweeperDeps {
+  agentCronJobService: TrialExpiryCronJobServiceLike;
+  clock?: Clock;
+  /** Line logger for per-row outcomes. Defaults to console.log. */
+  log?: (line: string) => void;
+}
+
+/** Per-tick counter, also the value `tick()` resolves to. */
+export interface TrialExpirySweepResult {
+  disabled: number;
+}
+
+/** Default cadence of the trial-expiry sweeper. */
+export const DEFAULT_TRIAL_EXPIRY_SWEEP_INTERVAL_MS = 60_000;
+
+/**
+ * Resolve the trial-expiry sweeper's tick interval from the environment.
+ * Reads SHIPWRIGHT_ADMIN_TRIAL_EXPIRY_SWEEP_INTERVAL_MS; anything unset,
+ * blank, non-numeric, or non-positive falls back to the default rather than
+ * producing a setInterval that spins (0/NaN) or never fires.
+ */
+export function resolveTrialExpirySweepIntervalMs(
+  env: Record<string, string | undefined>,
+): number {
+  const raw = env.SHIPWRIGHT_ADMIN_TRIAL_EXPIRY_SWEEP_INTERVAL_MS?.trim();
+  if (!raw) return DEFAULT_TRIAL_EXPIRY_SWEEP_INTERVAL_MS;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return DEFAULT_TRIAL_EXPIRY_SWEEP_INTERVAL_MS;
+  }
+  return parsed;
+}
+
+export class TrialExpirySweeper {
+  private readonly clock: Clock;
+  private readonly log: (line: string) => void;
+
+  constructor(private readonly deps: TrialExpirySweeperDeps) {
+    this.clock = deps.clock ?? SystemClock();
+    this.log = deps.log ?? ((line) => console.log(line));
+  }
+
+  /**
+   * One sweep: disables every enabled AgentCronJob belonging to an agent
+   * whose trial has expired. Never throws — a listing failure short-circuits
+   * to an all-zero result, and each row's setEnabled() call is individually
+   * try/caught so one bad row can't abort the rest.
+   */
+  async tick(): Promise<TrialExpirySweepResult> {
+    const now = this.clock.now();
+    let rows: Array<{ id: string; agentId: string }>;
+    try {
+      rows =
+        await this.deps.agentCronJobService.listEnabledWithExpiredTrial(now);
+    } catch (err) {
+      console.error("[trial-expiry-sweeper] listing failed:", err);
+      return { disabled: 0 };
+    }
+
+    let disabled = 0;
+    for (const row of rows) {
+      try {
+        await this.deps.agentCronJobService.setEnabled(
+          row.agentId,
+          row.id,
+          false,
+          { lockdown: true },
+        );
+        disabled++;
+      } catch (err) {
+        console.error(
+          `[trial-expiry-sweeper] disable cron ${row.id} (agent ${row.agentId}) failed:`,
+          err,
+        );
+      }
+    }
+
+    if (disabled > 0) {
+      this.log(`[trial-expiry-sweeper] disabled=${disabled}`);
+    }
+
+    return { disabled };
+  }
+}