@app-vitals/agent-admin 0.0.1 → 0.1.0

package/src/account-trial-expiry-sweeper.ts

@@ -0,0 +1,85 @@
+/**
+ * admin/src/account-trial-expiry-sweeper.ts
+ *
+ * AccountTrialExpirySweeper (SSP-8.2) — the account-level counterpart of
+ * trial-expiry-sweeper.ts (which keeps handling per-agent trialExpiresAt,
+ * unchanged). Every tick:
+ *
+ *   1. Flips every *active* account whose trialExpiresAt is strictly in the
+ *      past to 'trial_expired' (conditional write — a concurrent admin
+ *      reactivation/extension wins).
+ *   2. Runs AccountLifecycle.lockDown() across all locked accounts
+ *      (suspended or trial_expired): every enabled cron of their agents is
+ *      disabled with the SSP-8.1 lockdown marker. This both locks down the
+ *      accounts expired in step 1 and self-heals any cron re-enabled (or
+ *      created) while its account is locked — mirroring how the per-agent
+ *      sweeper continuously re-applies its lockdown.
+ *
+ * Idempotent by construction: once an account is trial_expired and its crons
+ * are disabled, neither query matches anything, so a re-run writes nothing.
+ * Never deletes anything (no deleteAgentFully call). Registered via setInterval
+ * in main.ts, flag-gated on self-serve.
+ */
+
+import type { AccountLifecycle } from "./account-lifecycle.ts";
+import type { AccountService } from "./accounts.ts";
+import { type Clock, SystemClock } from "./clock.ts";
+
+interface AccountTrialExpirySweeperDeps {
+  accounts: Pick<AccountService, "listExpiredActiveIds" | "expireTrial">;
+  lifecycle: Pick<AccountLifecycle, "lockDown">;
+  clock?: Clock;
+  log?: (line: string) => void;
+}
+
+interface AccountTrialExpirySweepResult {
+  /** Accounts flipped active → trial_expired this tick. */
+  expired: number;
+  /** Crons disabled (lockdown-marked) this tick. */
+  disabled: number;
+}
+
+export class AccountTrialExpirySweeper {
+  private readonly clock: Clock;
+  private readonly log: (line: string) => void;
+
+  constructor(private readonly deps: AccountTrialExpirySweeperDeps) {
+    this.clock = deps.clock ?? SystemClock();
+    this.log = deps.log ?? ((line) => console.log(line));
+  }
+
+  /** One sweep. Never throws; per-account failures are logged and skipped. */
+  async tick(): Promise<AccountTrialExpirySweepResult> {
+    const now = this.clock.now();
+    let expired = 0;
+    try {
+      const ids = await this.deps.accounts.listExpiredActiveIds(now);
+      for (const id of ids) {
+        try {
+          if (await this.deps.accounts.expireTrial(id, now)) expired++;
+        } catch (err) {
+          console.error(
+            `[account-trial-expiry-sweeper] expire account ${id} failed:`,
+            err,
+          );
+        }
+      }
+    } catch (err) {
+      console.error("[account-trial-expiry-sweeper] listing failed:", err);
+    }
+
+    let disabled = 0;
+    try {
+      disabled = await this.deps.lifecycle.lockDown();
+    } catch (err) {
+      console.error("[account-trial-expiry-sweeper] lockdown failed:", err);
+    }
+
+    if (expired > 0 || disabled > 0) {
+      this.log(
+        `[account-trial-expiry-sweeper] expired=${expired} disabled=${disabled}`,
+      );
+    }
+    return { expired, disabled };
+  }
+}

package/src/account-trial-warning-sweeper.integration.test.ts

@@ -0,0 +1,228 @@
+/**
+ * admin/src/account-trial-warning-sweeper.integration.test.ts
+ * AccountTrialWarningSweeper (SSP-8.2) against real Postgres fixture accounts
+ * and agents, with an injected AgentEnvService double (per-agent Slack
+ * config), an injected Slack-send double and a FixedClock. No real Slack.
+ *
+ * Requires DATABASE_URL_ADMIN_TEST to be set; skips otherwise.
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import type { PrismaClient } from "../prisma/client/client.ts";
+import {
+  AccountTrialWarningSweeper,
+  type AccountTrialWarningSweeperDeps,
+} from "./account-trial-warning-sweeper.ts";
+import { AccountService } from "./accounts.ts";
+import { FixedClock } from "./clock.ts";
+import { createAdminPrismaClient } from "./prisma-client.ts";
+import type { SendSlackWarningParams } from "./trial-expiry-warning-sweeper.ts";
+
+const TEST_DB = process.env.DATABASE_URL_ADMIN_TEST;
+const describeOrSkip = TEST_DB ? describe : describe.skip;
+
+const DAY = 24 * 60 * 60 * 1000;
+const NOW = new Date("2026-10-08T12:00:00.000Z");
+const days = (n: number) => new Date(NOW.getTime() + n * DAY);
+
+describeOrSkip("AccountTrialWarningSweeper (integration)", () => {
+  let prisma: PrismaClient;
+  let accounts: AccountService;
+  let sends: SendSlackWarningParams[];
+  /** agentId → Slack env; absent → no config bundle. */
+  let slackEnv: Map<string, Record<string, string>>;
+  let sendOk: (p: SendSlackWarningParams) => boolean;
+
+  beforeEach(async () => {
+    prisma = createAdminPrismaClient(TEST_DB as string);
+    await prisma.agentToken.deleteMany();
+    await prisma.agentCronJob.deleteMany();
+    await prisma.agentTool.deleteMany();
+    await prisma.agentEnv.deleteMany();
+    await prisma.agent.deleteMany();
+    await prisma.accountInvite.deleteMany();
+    await prisma.accountMember.deleteMany();
+    await prisma.account.deleteMany();
+    accounts = new AccountService(prisma);
+    sends = [];
+    slackEnv = new Map();
+    sendOk = () => true;
+  });
+
+  afterEach(async () => {
+    await prisma.$disconnect();
+  });
+
+  function makeSweeper(
+    overrides: Partial<AccountTrialWarningSweeperDeps> = {},
+  ): AccountTrialWarningSweeper {
+    return new AccountTrialWarningSweeper({
+      accounts,
+      agentEnvService: {
+        getConfigBundle: async (agentId) => {
+          const env = slackEnv.get(agentId);
+          return env ? { env, agentId, allowedTools: [] } : null;
+        },
+      },
+      sendSlackMessage: async (p) => {
+        sends.push(p);
+        return sendOk(p);
+      },
+      clock: FixedClock(NOW),
+      warningDays: 3,
+      log: () => {},
+      ...overrides,
+    });
+  }
+
+  async function makeAccount(
+    opts: {
+      name?: string;
+      status?: string;
+      trialExpiresAt?: Date | null;
+      trialExpiryWarnedAt?: Date | null;
+    } = {},
+  ): Promise<string> {
+    const a = await prisma.account.create({
+      data: {
+        name: opts.name ?? "Acme",
+        status: opts.status ?? "active",
+        trialExpiresAt: opts.trialExpiresAt ?? null,
+        trialExpiryWarnedAt: opts.trialExpiryWarnedAt ?? null,
+      },
+    });
+    return a.id;
+  }
+
+  async function makeAgent(
+    accountId: string | null,
+    slack = true,
+    name = "bot",
+  ): Promise<string> {
+    const a = await prisma.agent.create({
+      data: { name, typeName: "coding", accountId },
+    });
+    if (slack) {
+      slackEnv.set(a.id, {
+        SLACK_BOT_TOKEN: `xoxb-${a.id}`,
+        SLACK_ALERT_CHANNEL: `#alerts-${a.id}`,
+      });
+    }
+    return a.id;
+  }
+
+  const warnedAt = async (id: string) =>
+    (await prisma.account.findUniqueOrThrow({ where: { id } }))
+      .trialExpiryWarnedAt;
+
+  it("2 days away with a 3-day window -> exactly one warning across repeated sweeps", async () => {
+    const acc = await makeAccount({
+      name: "Acme Co",
+      trialExpiresAt: days(2),
+    });
+    const agent = await makeAgent(acc);
+    const sweeper = makeSweeper();
+
+    const first = await sweeper.tick();
+    expect(first.warned).toBe(1);
+    expect(sends).toHaveLength(1);
+    expect(sends[0]).toMatchObject({
+      botToken: `xoxb-${agent}`,
+      channel: `#alerts-${agent}`,
+    });
+    expect(sends[0].text).toContain("Acme Co");
+    expect(sends[0].text).toContain(days(2).toISOString().slice(0, 10));
+    expect(await warnedAt(acc)).toEqual(NOW);
+
+    for (let i = 0; i < 3; i++) {
+      expect((await sweeper.tick()).warned).toBe(0);
+    }
+    expect(sends).toHaveLength(1);
+  });
+
+  it("posts once via each of the account's agents' own alert channel", async () => {
+    const acc = await makeAccount({ trialExpiresAt: days(2) });
+    const a1 = await makeAgent(acc, true, "one");
+    const a2 = await makeAgent(acc, true, "two");
+    await makeAgent(null); // unrelated agent, never posted to
+
+    const result = await makeSweeper().tick();
+    expect(result.warned).toBe(1);
+    expect(sends.map((s) => s.channel).sort()).toEqual(
+      [`#alerts-${a1}`, `#alerts-${a2}`].sort(),
+    );
+    await makeSweeper().tick();
+    expect(sends).toHaveLength(2);
+  });
+
+  it("not yet in the window -> no warning, no stamp", async () => {
+    const acc = await makeAccount({ trialExpiresAt: days(5) });
+    await makeAgent(acc);
+    expect((await makeSweeper().tick()).warned).toBe(0);
+    expect(sends).toHaveLength(0);
+    expect(await warnedAt(acc)).toBeNull();
+  });
+
+  it("no agent has Slack config -> skipped, not stamped, retried next tick", async () => {
+    const acc = await makeAccount({ trialExpiresAt: days(2) });
+    const agent = await makeAgent(acc, false);
+    const sweeper = makeSweeper();
+
+    expect(await sweeper.tick()).toMatchObject({ warned: 0, skipped: 1 });
+    expect(await warnedAt(acc)).toBeNull();
+
+    slackEnv.set(agent, {
+      SLACK_BOT_TOKEN: "xoxb-late",
+      SLACK_ALERT_CHANNEL: "#late",
+    });
+    expect((await sweeper.tick()).warned).toBe(1);
+    expect(sends).toHaveLength(1);
+  });
+
+  it("every send fails -> failed, not stamped", async () => {
+    const acc = await makeAccount({ trialExpiresAt: days(2) });
+    await makeAgent(acc);
+    sendOk = () => false;
+    expect(await makeSweeper().tick()).toMatchObject({ warned: 0, failed: 1 });
+    expect(await warnedAt(acc)).toBeNull();
+  });
+
+  it("account with no agents -> skipped, not stamped", async () => {
+    const acc = await makeAccount({ trialExpiresAt: days(2) });
+    expect(await makeSweeper().tick()).toMatchObject({ skipped: 1 });
+    expect(await warnedAt(acc)).toBeNull();
+  });
+
+  it("never warns suspended/expired accounts, already-warned accounts, or long-lapsed trials", async () => {
+    await makeAgent(
+      await makeAccount({ status: "suspended", trialExpiresAt: days(2) }),
+    );
+    await makeAgent(
+      await makeAccount({ trialExpiresAt: days(2), trialExpiryWarnedAt: NOW }),
+    );
+    const stale = await makeAccount({ trialExpiresAt: days(-30) });
+    await makeAgent(stale);
+
+    const result = await makeSweeper().tick();
+    expect(result).toMatchObject({ warned: 0, stale: 1 });
+    expect(sends).toHaveLength(0);
+  });
+
+  it("a candidate fetch failure returns all zeros without throwing", async () => {
+    const sweeper = makeSweeper({
+      accounts: {
+        listTrialWarningCandidates: async () => {
+          throw new Error("db down");
+        },
+        listAgents: accounts.listAgents.bind(accounts),
+        markTrialWarned: accounts.markTrialWarned.bind(accounts),
+      },
+    });
+    expect(await sweeper.tick()).toEqual({
+      warned: 0,
+      skipped: 0,
+      failed: 0,
+      stale: 0,
+    });
+  });
+});

package/src/account-trial-warning-sweeper.ts

@@ -0,0 +1,216 @@
+/**
+ * admin/src/account-trial-warning-sweeper.ts
+ *
+ * AccountTrialWarningSweeper (SSP-8.2) — the account-level counterpart of
+ * trial-expiry-warning-sweeper.ts (which keeps warning per-agent trials,
+ * unchanged). Every tick:
+ *
+ *   1. Lists active accounts with trialExpiresAt set and trialExpiryWarnedAt
+ *      null.
+ *   2. For each whose trialExpiresAt is inside the warning band
+ *      (isAccountTrialWarningDue — same window/grace semantics as the
+ *      per-agent sweeper, window from resolveTrialExpiryWarningDays), posts
+ *      one Slack warning via *each* of the account's agents' own
+ *      SLACK_BOT_TOKEN / SLACK_ALERT_CHANNEL (admin holds no Slack secret of
+ *      its own — same pattern as the per-agent sweeper).
+ *   3. If at least one post went out, stamps trialExpiryWarnedAt so the
+ *      account is never warned again (until a reactivation/extension resets
+ *      it, see account-lifecycle.ts). If no agent had usable Slack config,
+ *      or every send failed, nothing is stamped and the next tick retries.
+ *
+ * Non-re-entrant (`sweeping` guard), per-account try/catch, injected Clock
+ * and Slack sender — structure mirrors trial-expiry-warning-sweeper.ts.
+ */
+
+import { isAccountTrialWarningDue } from "./account-lifecycle.ts";
+import type { AccountService } from "./accounts.ts";
+import type { AgentEnvService } from "./agent-envs.ts";
+import { type Clock, SystemClock } from "./clock.ts";
+import {
+  DEFAULT_TRIAL_EXPIRY_WARNING_DAYS,
+  isPastWarningGrace,
+  type SendSlackWarning,
+  sendTrialExpiryWarning,
+} from "./trial-expiry-warning-sweeper.ts";
+
+export interface AccountTrialWarningSweeperDeps {
+  accounts: Pick<
+    AccountService,
+    "listTrialWarningCandidates" | "listAgents" | "markTrialWarned"
+  >;
+  agentEnvService: Pick<AgentEnvService, "getConfigBundle">;
+  /** Defaults to sendTrialExpiryWarning (real @slack/web-api client). */
+  sendSlackMessage?: SendSlackWarning;
+  clock?: Clock;
+  warningDays?: number;
+  graceDays?: number;
+  log?: (line: string) => void;
+}
+
+interface AccountTrialWarningSweepResult {
+  /** Accounts warned (≥1 post sent) and stamped. */
+  warned: number;
+  /** Due, but no agent of the account had usable Slack config. */
+  skipped: number;
+  /** Due, Slack config present, but every send failed. */
+  failed: number;
+  /** Never warned and trialExpiresAt beyond the grace window — not alerted. */
+  stale: number;
+}
+
+type Candidate = Awaited<
+  ReturnType<AccountService["listTrialWarningCandidates"]>
+>[number];
+
+/** Slack text for one account's warning, posted through one of its agents. */
+function buildAccountTrialWarningMessage(
+  accountName: string,
+  trialExpiresAt: Date,
+  now: Date,
+): string {
+  const dateStr = trialExpiresAt.toISOString().slice(0, 10);
+  const verb =
+    trialExpiresAt.getTime() <= now.getTime() ? "expired on" : "expires on";
+  return (
+    `:warning: The trial for account \`${accountName}\` ${verb} ${dateStr}. ` +
+    `After that, every agent in the account is paused: crons are disabled ` +
+    `and Slack access is blocked until the trial is renewed. Nothing is deleted.`
+  );
+}
+
+const zero = (): AccountTrialWarningSweepResult => ({
+  warned: 0,
+  skipped: 0,
+  failed: 0,
+  stale: 0,
+});
+
+export class AccountTrialWarningSweeper {
+  private readonly clock: Clock;
+  private readonly warningDays: number;
+  private readonly graceDays: number;
+  private readonly send: SendSlackWarning;
+  private readonly log: (line: string) => void;
+  private sweeping = false;
+
+  constructor(private readonly deps: AccountTrialWarningSweeperDeps) {
+    this.clock = deps.clock ?? SystemClock();
+    this.warningDays = deps.warningDays ?? DEFAULT_TRIAL_EXPIRY_WARNING_DAYS;
+    this.graceDays = deps.graceDays ?? this.warningDays;
+    this.send = deps.sendSlackMessage ?? sendTrialExpiryWarning;
+    this.log = deps.log ?? ((line) => console.log(line));
+  }
+
+  /** One sweep. Never throws; skips (all zeros) if a tick is in flight. */
+  async tick(): Promise<AccountTrialWarningSweepResult> {
+    if (this.sweeping) {
+      console.warn(
+        "[account-trial-warning-sweeper] previous tick still in flight — skipping",
+      );
+      return zero();
+    }
+    this.sweeping = true;
+    try {
+      return await this.sweep();
+    } finally {
+      this.sweeping = false;
+    }
+  }
+
+  private async sweep(): Promise<AccountTrialWarningSweepResult> {
+    const result = zero();
+    let candidates: Candidate[];
+    try {
+      candidates = await this.deps.accounts.listTrialWarningCandidates();
+    } catch (err) {
+      console.error(
+        "[account-trial-warning-sweeper] candidate fetch failed:",
+        err,
+      );
+      return result;
+    }
+
+    const now = this.clock.now();
+    for (const account of candidates) {
+      try {
+        await this.sweepAccount(account, now, result);
+      } catch (err) {
+        console.error(
+          `[account-trial-warning-sweeper] account ${account.id} failed:`,
+          err,
+        );
+      }
+    }
+
+    if (result.warned + result.skipped + result.failed + result.stale > 0) {
+      this.log(
+        `[account-trial-warning-sweeper] warned=${result.warned} skipped=${result.skipped} failed=${result.failed} stale=${result.stale}`,
+      );
+    }
+    return result;
+  }
+
+  private async sweepAccount(
+    account: Candidate,
+    now: Date,
+    result: AccountTrialWarningSweepResult,
+  ): Promise<void> {
+    const { trialExpiresAt } = account;
+    if (
+      !trialExpiresAt ||
+      !isAccountTrialWarningDue(
+        trialExpiresAt,
+        account.trialExpiryWarnedAt,
+        now,
+        this.warningDays,
+        this.graceDays,
+      )
+    ) {
+      if (
+        trialExpiresAt &&
+        !account.trialExpiryWarnedAt &&
+        isPastWarningGrace(trialExpiresAt, now, this.graceDays)
+      ) {
+        result.stale++;
+      }
+      return;
+    }
+
+    const text = buildAccountTrialWarningMessage(
+      account.name,
+      trialExpiresAt,
+      now,
+    );
+    let configured = 0;
+    let sent = 0;
+    for (const agent of await this.deps.accounts.listAgents(account.id)) {
+      const bundle = await this.deps.agentEnvService.getConfigBundle(agent.id);
+      const botToken = bundle?.env.SLACK_BOT_TOKEN;
+      const channel = bundle?.env.SLACK_ALERT_CHANNEL;
+      if (!botToken || !channel) continue;
+      configured++;
+      if (await this.send({ botToken, channel, text })) sent++;
+    }
+
+    if (configured === 0) {
+      this.log(
+        `[account-trial-warning-sweeper] skip ${account.id} (${account.name}): no agent with SLACK_BOT_TOKEN + SLACK_ALERT_CHANNEL — will retry next tick`,
+      );
+      result.skipped++;
+      return;
+    }
+    if (sent === 0) {
+      console.error(
+        `[account-trial-warning-sweeper] every warning post failed for account ${account.id} (${account.name}) — will retry next tick`,
+      );
+      result.failed++;
+      return;
+    }
+
+    await this.deps.accounts.markTrialWarned(account.id, now);
+    result.warned++;
+    this.log(
+      `[account-trial-warning-sweeper] warned ${account.id} (${account.name}) via ${sent} agent(s): trial expires ${trialExpiresAt.toISOString()}`,
+    );
+  }
+}