@app-vitals/agent-admin 0.0.1 → 0.1.1

package/src/accounts-api.integration.test.ts

@@ -0,0 +1,196 @@
+/**
+ * admin/src/accounts-api.integration.test.ts
+ * POST /accounts against real Postgres (SSP-5.1): the admin-created account
+ * seeds the owner AccountMember, so that owner's first login resolves to it
+ * (no new account), and PATCH can raise maxAgents.
+ *
+ * Requires DATABASE_URL_ADMIN_TEST to be set; skips otherwise.
+ *
+ * Note: SSP-4.1 agent-creation quota gating is not present on this branch, so
+ * the "owner can then create up to 3 agents" half of the PATCH criterion is
+ * covered with SSP-4.1; here we assert the raised quota and the agent count
+ * the quota is compared against.
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import type { PrismaClient } from "../prisma/client/client.ts";
+import { AccountLifecycle } from "./account-lifecycle.ts";
+import { AccountMemberService } from "./account-members.ts";
+import { AccountService } from "./accounts.ts";
+import { createAccountsApp } from "./accounts-api.ts";
+import { AgentCronJobService } from "./agent-cron-jobs.ts";
+import { createAdminPrismaClient } from "./prisma-client.ts";
+
+const TEST_DB = process.env.DATABASE_URL_ADMIN_TEST;
+const describeOrSkip = TEST_DB ? describe : describe.skip;
+
+describeOrSkip("/accounts API (integration)", () => {
+  let prisma: PrismaClient;
+  let accounts: AccountService;
+  let app: ReturnType<typeof createAccountsApp>;
+  const headers = {
+    Authorization: "Bearer k",
+    "Content-Type": "application/json",
+  };
+
+  beforeEach(async () => {
+    prisma = createAdminPrismaClient(TEST_DB as string);
+    await prisma.agentCronJob.deleteMany();
+    await prisma.accountInvite.deleteMany();
+    await prisma.accountMember.deleteMany();
+    await prisma.agent.deleteMany();
+    await prisma.account.deleteMany();
+    accounts = new AccountService(prisma);
+    app = createAccountsApp({
+      selfServe: {
+        enabled: true,
+        defaultMaxAgents: 0,
+        contactEmail: "c@x.com",
+      },
+      sessionSecret: "s".repeat(32),
+      adminApiKeys: new Map([["k", { name: "t", scope: "*" }]]),
+      agentTokenService: { validate: async () => null } as never,
+      accountService: accounts,
+      accountLifecycle: new AccountLifecycle({
+        accounts,
+        cronJobs: new AgentCronJobService(prisma),
+        log: () => {},
+      }),
+    });
+  });
+
+  afterEach(async () => {
+    await prisma.$disconnect();
+  });
+
+  it("POST /accounts seeds the owner so their first login joins it", async () => {
+    const res = await app.request("/accounts", {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        name: "Acme",
+        ownerEmail: "Owner@Acme.com",
+        maxAgents: 2,
+      }),
+    });
+    expect(res.status).toBe(201);
+    const created = (await res.json()) as { id: string; memberCount: number };
+    expect(created.memberCount).toBe(1);
+
+    // First-login lookup (same one the login join uses) lands in this account.
+    const joined = await accounts.getByMemberEmail("owner@acme.com");
+    expect(joined?.id).toBe(created.id);
+    const member = await new AccountMemberService(prisma).getByEmail(
+      "owner@acme.com",
+    );
+    expect(member?.role).toBe("owner");
+    expect(await prisma.account.count()).toBe(1);
+  });
+
+  it("duplicate owner email -> 409 and no extra account", async () => {
+    const body = JSON.stringify({
+      name: "A",
+      ownerEmail: "d@x.com",
+      maxAgents: 1,
+    });
+    expect(
+      (await app.request("/accounts", { method: "POST", headers, body }))
+        .status,
+    ).toBe(201);
+    expect(
+      (await app.request("/accounts", { method: "POST", headers, body }))
+        .status,
+    ).toBe(409);
+    expect(await prisma.account.count()).toBe(1);
+  });
+
+  it("PATCH raises maxAgents 0 -> 3 and GET reflects counts", async () => {
+    const a = await accounts.create("A", "a@x.com");
+    expect(a.maxAgents).toBe(0);
+    await prisma.agent.create({ data: { name: "one", accountId: a.id } });
+    const res = await app.request(`/accounts/${a.id}`, {
+      method: "PATCH",
+      headers,
+      body: JSON.stringify({ maxAgents: 3, plan: "pro", status: "active" }),
+    });
+    expect(res.status).toBe(200);
+    const got = await app.request(`/accounts/${a.id}`, { headers });
+    expect(await got.json()).toMatchObject({
+      maxAgents: 3,
+      plan: "pro",
+      agentCount: 1,
+      memberCount: 1,
+    });
+    const list = (await (
+      await app.request("/accounts", { headers })
+    ).json()) as {
+      accounts: unknown[];
+    };
+    expect(list.accounts).toHaveLength(1);
+  });
+
+  // ─── SSP-8.2: status transitions drive the cron lockdown ──────────────────
+
+  async function agentWithCrons(accountId: string) {
+    const agent = await prisma.agent.create({
+      data: { name: "bot", accountId },
+    });
+    const mk = (enabled: boolean) =>
+      prisma.agentCronJob.create({
+        data: {
+          agentId: agent.id,
+          schedule: "0 * * * *",
+          prompt: "p",
+          channel: "C1",
+          silent: false,
+          enabled,
+        },
+      });
+    return { on: await mk(true), userOff: await mk(false) };
+  }
+
+  const patch = (id: string, body: unknown) =>
+    app.request(`/accounts/${id}`, {
+      method: "PATCH",
+      headers,
+      body: JSON.stringify(body),
+    });
+
+  const cron = (id: string) =>
+    prisma.agentCronJob.findUniqueOrThrow({ where: { id } });
+
+  it("PATCH status=suspended locks down crons; status=active restores only those", async () => {
+    const a = await accounts.create("A", "a@x.com");
+    const { on, userOff } = await agentWithCrons(a.id);
+
+    expect((await patch(a.id, { status: "suspended" })).status).toBe(200);
+    const locked = await cron(on.id);
+    expect(locked.enabled).toBe(false);
+    expect(locked.lockdownDisabledAt).not.toBeNull();
+    expect((await cron(userOff.id)).lockdownDisabledAt).toBeNull();
+
+    const res = await patch(a.id, { status: "active" });
+    expect(res.status).toBe(200);
+    expect(await res.json()).toMatchObject({ status: "active" });
+    expect((await cron(on.id)).enabled).toBe(true);
+    expect((await cron(userOff.id)).enabled).toBe(false);
+  });
+
+  it("PATCH status=active with a lapsed trial -> 422 and nothing restored", async () => {
+    const a = await accounts.create("A", "a@x.com", {
+      status: "trial_expired",
+      trialExpiresAt: new Date("2020-01-01T00:00:00.000Z"),
+    });
+    const res = await patch(a.id, { status: "active" });
+    expect(res.status).toBe(422);
+    expect(
+      (await prisma.account.findUniqueOrThrow({ where: { id: a.id } })).status,
+    ).toBe("trial_expired");
+
+    const ok = await patch(a.id, {
+      status: "active",
+      trialExpiresAt: "2099-01-01T00:00:00.000Z",
+    });
+    expect(ok.status).toBe(200);
+  });
+});

package/src/accounts-api.smoke.test.ts

@@ -0,0 +1,292 @@
+/**
+ * admin/src/accounts-api.smoke.test.ts
+ * Smoke tests for the admin-only /accounts API (SSP-5.1). In-process
+ * app.request(), in-memory AccountService double.
+ */
+
+import { describe, expect, it } from "bun:test";
+import { sign } from "hono/jwt";
+import type { AccountWithCounts } from "./accounts.ts";
+import { createAccountsApp } from "./accounts-api.ts";
+import { parseAdminApiKeys } from "./api-auth.ts";
+import { UnprocessableEntityError } from "./errors.ts";
+
+const SESSION_SECRET = "accounts-smoke-secret-32-bytes!!!";
+const ADMIN_KEY = "admin-key";
+const SCOPED_KEY = "scoped-key";
+const AGENT_TOKEN = "agent-token";
+
+const NOW = new Date("2026-01-01T00:00:00.000Z");
+
+function acct(over: Partial<AccountWithCounts> = {}): AccountWithCounts {
+  return {
+    id: "acc1",
+    name: "Acme",
+    status: "active",
+    maxAgents: 0,
+    plan: null,
+    trialExpiresAt: null,
+    trialExpiryWarnedAt: null,
+    createdAt: NOW,
+    updatedAt: NOW,
+    agentCount: 2,
+    memberCount: 1,
+    ...over,
+  };
+}
+
+function cookie(isAdmin: boolean): Promise<string> {
+  return sign(
+    {
+      isAdmin,
+      userId: "u1",
+      email: "someone@example.com",
+      exp: Math.floor(Date.now() / 1000) + 3600,
+    },
+    SESSION_SECRET,
+    "HS256",
+  );
+}
+
+function build(enabled = true) {
+  const calls: Array<{ fn: string; args: unknown[] }> = [];
+  const store = new Map<string, AccountWithCounts>([
+    ["acc1", acct()],
+    ["expired1", acct({ id: "expired1", status: "trial_expired" })],
+  ]);
+  const app = createAccountsApp({
+    selfServe: { enabled, defaultMaxAgents: 0, contactEmail: "c@x.com" },
+    sessionSecret: SESSION_SECRET,
+    adminApiKeys: parseAdminApiKeys(
+      `admin:${ADMIN_KEY}:*,scoped:${SCOPED_KEY}:agent-1`,
+    ),
+    agentTokenService: {
+      validate: async (t: string) =>
+        t === AGENT_TOKEN ? { agentId: "agent-1" } : null,
+    } as never,
+    accountService: {
+      listWithCounts: async () => [...store.values()],
+      getWithCounts: async (id: string) => store.get(id) ?? null,
+      create: async (...args: unknown[]) => {
+        calls.push({ fn: "create", args });
+        const [name, ownerEmail] = args as [string, string];
+        if (ownerEmail === "taken@x.com") {
+          throw Object.assign(new Error("unique"), { code: "P2002" });
+        }
+        const a = acct({ id: "new1", name, agentCount: 0, memberCount: 1 });
+        store.set(a.id, a);
+        return a;
+      },
+    },
+    accountLifecycle: {
+      update: async (...args: unknown[]) => {
+        calls.push({ fn: "update", args });
+        const [id, data] = args as [string, Partial<AccountWithCounts>];
+        const cur = store.get(id);
+        if (!cur) throw Object.assign(new Error("nf"), { code: "P2025" });
+        if (data.status === "active" && cur.status === "trial_expired") {
+          throw new UnprocessableEntityError("trial still lapsed");
+        }
+        const next = { ...cur, ...data };
+        store.set(id, next);
+        return next;
+      },
+    },
+  });
+  return { app, calls };
+}
+
+const adminHeaders = { Authorization: `Bearer ${ADMIN_KEY}` };
+const json = { "Content-Type": "application/json" };
+
+const ROUTES: Array<[string, string, unknown?]> = [
+  ["GET", "/accounts", undefined],
+  ["GET", "/accounts/acc1", undefined],
+  ["POST", "/accounts", { name: "N", ownerEmail: "o@x.com", maxAgents: 1 }],
+  ["PATCH", "/accounts/acc1", { maxAgents: 3 }],
+];
+
+function req(
+  app: ReturnType<typeof build>["app"],
+  method: string,
+  path: string,
+  headers: Record<string, string>,
+  body?: unknown,
+) {
+  return app.request(path, {
+    method,
+    headers: body === undefined ? headers : { ...headers, ...json },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+}
+
+describe("flag off", () => {
+  it.each(ROUTES)("%s %s -> 404", async (method, path, body) => {
+    const { app } = build(false);
+    const res = await req(app, method, path, adminHeaders, body);
+    expect(res.status).toBe(404);
+  });
+});
+
+describe("auth classes", () => {
+  it.each(ROUTES)("%s %s: no credentials -> 401", async (m, p, b) => {
+    const { app } = build();
+    expect((await req(app, m, p, {}, b)).status).toBe(401);
+  });
+
+  it.each(ROUTES)("%s %s: non-admin cookie -> 403", async (m, p, b) => {
+    const { app } = build();
+    const res = await req(
+      app,
+      m,
+      p,
+      { Cookie: `admin_session=${await cookie(false)}` },
+      b,
+    );
+    expect(res.status).toBe(403);
+  });
+
+  it.each(ROUTES)("%s %s: scoped key -> 403", async (m, p, b) => {
+    const { app } = build();
+    const res = await req(
+      app,
+      m,
+      p,
+      { Authorization: `Bearer ${SCOPED_KEY}` },
+      b,
+    );
+    expect(res.status).toBe(403);
+  });
+
+  it.each(ROUTES)("%s %s: per-agent token -> 403", async (m, p, b) => {
+    const { app } = build();
+    const res = await req(
+      app,
+      m,
+      p,
+      { Authorization: `Bearer ${AGENT_TOKEN}` },
+      b,
+    );
+    expect(res.status).toBe(403);
+  });
+
+  it.each(ROUTES)("%s %s: admin cookie -> 2xx", async (m, p, b) => {
+    const { app } = build();
+    const res = await req(
+      app,
+      m,
+      p,
+      { Cookie: `admin_session=${await cookie(true)}` },
+      b,
+    );
+    expect(res.status).toBeLessThan(300);
+  });
+
+  it.each(ROUTES)("%s %s: scope * key -> 2xx", async (m, p, b) => {
+    const { app } = build();
+    expect((await req(app, m, p, adminHeaders, b)).status).toBeLessThan(300);
+  });
+});
+
+describe("behaviour", () => {
+  it("GET /accounts returns counts and ISO dates", async () => {
+    const { app } = build();
+    const res = await req(app, "GET", "/accounts", adminHeaders);
+    const body = (await res.json()) as {
+      accounts: Array<Record<string, unknown>>;
+    };
+    expect(body.accounts[0]).toMatchObject({
+      id: "acc1",
+      agentCount: 2,
+      memberCount: 1,
+      createdAt: NOW.toISOString(),
+    });
+  });
+
+  it("GET /accounts/:id 404s for unknown", async () => {
+    const { app } = build();
+    expect((await req(app, "GET", "/accounts/nope", adminHeaders)).status).toBe(
+      404,
+    );
+  });
+
+  it("POST /accounts passes through fields and returns 201", async () => {
+    const { app, calls } = build();
+    const res = await req(app, "POST", "/accounts", adminHeaders, {
+      name: "N",
+      ownerEmail: "o@x.com",
+      maxAgents: 5,
+      plan: "pro",
+      trialExpiresAt: "2030-01-01T00:00:00.000Z",
+    });
+    expect(res.status).toBe(201);
+    expect(calls[0]?.args[1]).toBe("o@x.com");
+    expect(calls[0]?.args[2]).toMatchObject({
+      maxAgents: 5,
+      plan: "pro",
+      trialExpiresAt: new Date("2030-01-01T00:00:00.000Z"),
+    });
+  });
+
+  it("POST /accounts with an already-used owner email -> 409", async () => {
+    const { app } = build();
+    const res = await req(app, "POST", "/accounts", adminHeaders, {
+      name: "N",
+      ownerEmail: "taken@x.com",
+      maxAgents: 1,
+    });
+    expect(res.status).toBe(409);
+  });
+
+  it("POST /accounts validation failure -> 400", async () => {
+    const { app } = build();
+    const res = await req(app, "POST", "/accounts", adminHeaders, {
+      name: "",
+      ownerEmail: "bad",
+      maxAgents: -1,
+    });
+    expect(res.status).toBe(400);
+  });
+
+  it("PATCH raises maxAgents and converts trialExpiresAt", async () => {
+    const { app, calls } = build();
+    const res = await req(app, "PATCH", "/accounts/acc1", adminHeaders, {
+      maxAgents: 3,
+      trialExpiresAt: null,
+    });
+    expect(res.status).toBe(200);
+    expect(((await res.json()) as { maxAgents: number }).maxAgents).toBe(3);
+    expect(calls[0]?.args[1]).toEqual({ maxAgents: 3, trialExpiresAt: null });
+  });
+
+  it("PATCH unknown account -> 404", async () => {
+    const { app } = build();
+    expect(
+      (
+        await req(app, "PATCH", "/accounts/nope", adminHeaders, {
+          maxAgents: 1,
+        })
+      ).status,
+    ).toBe(404);
+  });
+
+  it("PATCH routes status changes through the account lifecycle (SSP-8.2)", async () => {
+    const { app, calls } = build();
+    const res = await req(app, "PATCH", "/accounts/acc1", adminHeaders, {
+      status: "suspended",
+    });
+    expect(res.status).toBe(200);
+    expect(calls).toEqual([
+      { fn: "update", args: ["acc1", { status: "suspended" }] },
+    ]);
+  });
+
+  it("PATCH reactivation rejected by the lifecycle -> 422", async () => {
+    const { app } = build();
+    const res = await req(app, "PATCH", "/accounts/expired1", adminHeaders, {
+      status: "active",
+    });
+    expect(res.status).toBe(422);
+    expect(await res.json()).toEqual({ error: "trial still lapsed" });
+  });
+});