@app-vitals/agent-admin 0.0.1 → 0.1.1

package/src/agent-envs.integration.test.ts

@@ -0,0 +1,323 @@
+/**
+ * agent/src/agent-envs.integration.test.ts
+ * Integration tests for AgentEnvService against a real PostgreSQL DB.
+ *
+ * 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 { AgentEnvService } from "./agent-envs.ts";
+import { AnthropicCredentialsBlockedError } from "./anthropic-credential-guard.ts";
+import { UnprocessableEntityError } from "./errors.ts";
+import { createAdminPrismaClient } from "./prisma-client.ts";
+import { identityCrypto } from "./token-crypto.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);
+}
+
+async function createAgent(
+  prisma: PrismaClient,
+  name = "Test Agent",
+): Promise<string> {
+  const agent = await prisma.agent.create({ data: { name } });
+  return agent.id;
+}
+
+describeOrSkip("AgentEnvService (integration)", () => {
+  let prisma: PrismaClient;
+  let service: AgentEnvService;
+
+  beforeEach(async () => {
+    prisma = makePrisma();
+    // Clean all tables in FK dependency order
+    await prisma.agentToken.deleteMany();
+    await prisma.agentCronJob.deleteMany();
+    await prisma.agentTool.deleteMany();
+    await prisma.agentEnv.deleteMany();
+    await prisma.agent.deleteMany();
+    service = new AgentEnvService(prisma, identityCrypto);
+  });
+
+  afterEach(async () => {
+    await prisma.$disconnect();
+  });
+
+  it("upsert() writes values and getByAgentId() returns them", async () => {
+    const agentId = await createAgent(prisma);
+    await service.upsert(agentId, { FOO: "bar", BAZ: "qux" });
+    const result = await service.getByAgentId(agentId);
+    expect(result).not.toBeNull();
+    expect(result?.env).toEqual({ FOO: "bar", BAZ: "qux" });
+    expect(result?.secretKeys).toEqual([]);
+  });
+
+  it("upsert() replaces all existing vars (delete + insert)", async () => {
+    const agentId = await createAgent(prisma);
+    await service.upsert(agentId, { FOO: "bar", OLD: "value" });
+    await service.upsert(agentId, { FOO: "new", FRESH: "yes" });
+    const result = await service.getByAgentId(agentId);
+    expect(result).not.toBeNull();
+    expect(result?.env).toEqual({ FOO: "new", FRESH: "yes" });
+    expect(result?.env).not.toHaveProperty("OLD");
+  });
+
+  it("upsert() encrypts values (round-trip with real crypto)", async () => {
+    // Use a real crypto instead of identity to verify encrypt→decrypt round-trip
+    const { makeTokenCrypto } = await import("./token-crypto.ts");
+    const realKey =
+      "0000000000000000000000000000000000000000000000000000000000000001";
+    const origKey = process.env.SHIPWRIGHT_ENCRYPTION_KEY;
+    process.env.SHIPWRIGHT_ENCRYPTION_KEY = realKey;
+    const realCrypto = makeTokenCrypto();
+
+    try {
+      const encService = new AgentEnvService(prisma, realCrypto);
+      const agentId = await createAgent(prisma);
+      await encService.upsert(agentId, { SECRET: "my-api-key" });
+
+      // Raw DB value should be encrypted (not plain text)
+      const raw = await prisma.agentEnv.findFirst({
+        where: { agentId, key: "SECRET" },
+      });
+      expect(raw?.value).not.toBe("my-api-key");
+      expect(raw?.value).toContain(":"); // iv:ciphertext:authTag format
+
+      // But getByAgentId should return decrypted (not secret-flagged, so not masked)
+      const result = await encService.getByAgentId(agentId);
+      expect(result?.env.SECRET).toBe("my-api-key");
+    } finally {
+      if (origKey === undefined) {
+        delete process.env.SHIPWRIGHT_ENCRYPTION_KEY;
+      } else {
+        process.env.SHIPWRIGHT_ENCRYPTION_KEY = origKey;
+      }
+    }
+  });
+
+  it("upsert() throws UnprocessableEntityError for unknown agent", async () => {
+    await expect(
+      service.upsert("nonexistent-id", { FOO: "bar" }),
+    ).rejects.toBeInstanceOf(UnprocessableEntityError);
+  });
+
+  it("patch() upserts specific keys without touching others", async () => {
+    const agentId = await createAgent(prisma);
+    await service.upsert(agentId, { A: "1", B: "2" });
+    await service.patch(agentId, { B: "updated", C: "new" });
+    const result = await service.getByAgentId(agentId);
+    expect(result).not.toBeNull();
+    expect(result?.env).toEqual({ A: "1", B: "updated", C: "new" });
+  });
+
+  it("patch() throws UnprocessableEntityError for unknown agent", async () => {
+    await expect(
+      service.patch("nonexistent-id", { FOO: "bar" }),
+    ).rejects.toBeInstanceOf(UnprocessableEntityError);
+  });
+
+  it("getByAgentId() returns null when no env vars set", async () => {
+    const agentId = await createAgent(prisma);
+    const result = await service.getByAgentId(agentId);
+    expect(result).toBeNull();
+  });
+
+  it("getConfigBundle() returns env and agentId and allowedTools", async () => {
+    const agentId = await createAgent(prisma);
+    await service.upsert(agentId, { SLACK_BOT_TOKEN: "xoxb-test" });
+
+    const bundle = await service.getConfigBundle(agentId);
+    expect(bundle).not.toBeNull();
+    expect(bundle?.env.SLACK_BOT_TOKEN).toBe("xoxb-test");
+    expect(bundle?.agentId).toBe(agentId);
+    expect(Array.isArray(bundle?.allowedTools)).toBe(true);
+  });
+
+  it("getConfigBundle() returns null when no env vars", async () => {
+    const agentId = await createAgent(prisma);
+    const bundle = await service.getConfigBundle(agentId);
+    expect(bundle).toBeNull();
+  });
+
+  it("getConfigBundle() includes enabled tools in allowedTools", async () => {
+    const agentId = await createAgent(prisma);
+    await service.upsert(agentId, { FOO: "bar" });
+    await prisma.agentTool.create({
+      data: { agentId, pattern: "Read", enabled: true },
+    });
+    await prisma.agentTool.create({
+      data: { agentId, pattern: "Bash", enabled: false },
+    });
+
+    const bundle = await service.getConfigBundle(agentId);
+    expect(bundle?.allowedTools).toContain("Read");
+    expect(bundle?.allowedTools).not.toContain("Bash");
+  });
+
+  it("deleteKey() removes a specific env var", async () => {
+    const agentId = await createAgent(prisma);
+    await service.upsert(agentId, { A: "1", B: "2" });
+    await service.deleteKey(agentId, "A");
+    const result = await service.getByAgentId(agentId);
+    expect(result).not.toBeNull();
+    expect(result?.env).toEqual({ B: "2" });
+  });
+
+  it("deleteKey() no-ops for a key that doesn't exist", async () => {
+    const agentId = await createAgent(prisma);
+    await service.upsert(agentId, { B: "2" });
+    await expect(
+      service.deleteKey(agentId, "MISSING"),
+    ).resolves.toBeUndefined();
+  });
+
+  it("listAll() returns entries for all agents", async () => {
+    const id1 = await createAgent(prisma, "Agent 1");
+    const id2 = await createAgent(prisma, "Agent 2");
+    await service.upsert(id1, { KEY: "val1" });
+    await service.upsert(id2, { KEY: "val2" });
+
+    const all = await service.listAll();
+    expect(all).toHaveLength(2);
+    const entry1 = all.find((e) => e.agentId === id1);
+    const entry2 = all.find((e) => e.agentId === id2);
+    expect(entry1?.env.KEY).toBe("val1");
+    expect(entry2?.env.KEY).toBe("val2");
+  });
+
+  // ─── Secret flag tests ────────────────────────────────────────────────────
+
+  it("upsert() with secret=true masks value in getByAgentId() response", async () => {
+    const agentId = await createAgent(prisma);
+    await service.upsert(
+      agentId,
+      { MY_SECRET: "supersecret", PLAIN: "visible" },
+      new Set(["MY_SECRET"]),
+    );
+    const result = await service.getByAgentId(agentId);
+    expect(result).not.toBeNull();
+    expect(result?.env.MY_SECRET).toBe("***");
+    expect(result?.env.PLAIN).toBe("visible");
+    expect(result?.secretKeys).toContain("MY_SECRET");
+    expect(result?.secretKeys).not.toContain("PLAIN");
+  });
+
+  it("upsert() with secret=false returns real value in getByAgentId() response", async () => {
+    const agentId = await createAgent(prisma);
+    await service.upsert(agentId, { MY_KEY: "realvalue" });
+    const result = await service.getByAgentId(agentId);
+    expect(result).not.toBeNull();
+    expect(result?.env.MY_KEY).toBe("realvalue");
+    expect(result?.secretKeys).toEqual([]);
+  });
+
+  it("getConfigBundle() always decrypts regardless of secret flag", async () => {
+    const agentId = await createAgent(prisma);
+    await service.upsert(
+      agentId,
+      { MY_SECRET: "supersecret", PLAIN: "visible" },
+      new Set(["MY_SECRET"]),
+    );
+    const bundle = await service.getConfigBundle(agentId);
+    expect(bundle).not.toBeNull();
+    // Config bundle always returns real values — no masking
+    expect(bundle?.env.MY_SECRET).toBe("supersecret");
+    expect(bundle?.env.PLAIN).toBe("visible");
+  });
+
+  it("patch() with secretKeys updates secret flag", async () => {
+    const agentId = await createAgent(prisma);
+    await service.upsert(agentId, { A: "1", B: "2" });
+    // Patch B as secret
+    await service.patch(agentId, { B: "newsecret" }, new Set(["B"]));
+    const result = await service.getByAgentId(agentId);
+    expect(result).not.toBeNull();
+    expect(result?.env.A).toBe("1");
+    expect(result?.env.B).toBe("***");
+    expect(result?.secretKeys).toContain("B");
+    expect(result?.secretKeys).not.toContain("A");
+  });
+});
+
+describeOrSkip(
+  "AgentEnvService Anthropic federation guard (integration, WIF-2.1)",
+  () => {
+    let prisma: PrismaClient;
+    let federated: AgentEnvService;
+
+    const BLOCKED = [
+      "CLAUDE_CODE_OAUTH_TOKEN",
+      "ANTHROPIC_API_KEY",
+      "ANTHROPIC_AUTH_TOKEN",
+    ];
+
+    async function createAgentWith(selfHosted: boolean): Promise<string> {
+      const agent = await prisma.agent.create({
+        data: { name: "Guard Agent", selfHosted },
+      });
+      return agent.id;
+    }
+
+    beforeEach(async () => {
+      prisma = makePrisma();
+      await prisma.agentToken.deleteMany();
+      await prisma.agentCronJob.deleteMany();
+      await prisma.agentTool.deleteMany();
+      await prisma.agentEnv.deleteMany();
+      await prisma.agent.deleteMany();
+      federated = new AgentEnvService(prisma, identityCrypto, undefined, true);
+    });
+
+    afterEach(async () => {
+      await prisma.$disconnect();
+    });
+
+    for (const key of BLOCKED) {
+      it(`upsert() rejects ${key} (even empty) for a non-self-hosted agent and writes nothing`, async () => {
+        const agentId = await createAgentWith(false);
+        await federated.upsert(agentId, { KEEP: "me" });
+        await expect(
+          federated.upsert(agentId, { FOO: "bar", [key]: "" }),
+        ).rejects.toBeInstanceOf(AnthropicCredentialsBlockedError);
+        // Rejected before the delete+insert transaction: old bundle intact.
+        expect((await federated.getByAgentId(agentId))?.env).toEqual({
+          KEEP: "me",
+        });
+      });
+
+      it(`patch() rejects ${key} for a non-self-hosted agent`, async () => {
+        const agentId = await createAgentWith(false);
+        await expect(
+          federated.patch(agentId, { [key]: "secret" }),
+        ).rejects.toMatchObject({
+          code: "anthropic_credentials_blocked_federation",
+          statusCode: 400,
+        });
+        expect(await federated.getByAgentId(agentId)).toBeNull();
+      });
+    }
+
+    it("allows the keys for a self-hosted agent under federation", async () => {
+      const agentId = await createAgentWith(true);
+      await federated.patch(agentId, { ANTHROPIC_API_KEY: "sk-ant" });
+      expect((await federated.getByAgentId(agentId))?.env).toEqual({
+        ANTHROPIC_API_KEY: "sk-ant",
+      });
+    });
+
+    it("allows the keys when federation is disabled (default)", async () => {
+      const plain = new AgentEnvService(prisma, identityCrypto);
+      const agentId = await createAgentWith(false);
+      await plain.upsert(agentId, { CLAUDE_CODE_OAUTH_TOKEN: "tok" });
+      expect((await plain.getByAgentId(agentId))?.env).toEqual({
+        CLAUDE_CODE_OAUTH_TOKEN: "tok",
+      });
+    });
+  },
+);

package/src/agent-envs.ts

@@ -0,0 +1,244 @@
+/**
+ * agent/src/agent-envs.ts
+ * AgentEnvService — generic env var store for deployed agents.
+ *
+ * Keys are env var names (e.g. SLACK_BOT_TOKEN). Values are encrypted at rest
+ * using SHIPWRIGHT_ENCRYPTION_KEY (AES-256-GCM).
+ */
+
+import type { PrismaClient } from "../prisma/client/client.ts";
+import {
+  AnthropicCredentialsBlockedError,
+  anthropicCredentialKeysIn,
+} from "./anthropic-credential-guard.ts";
+import { type Clock, SystemClock } from "./clock.ts";
+import { ApiError, UnprocessableEntityError } from "./errors.ts";
+import type { TokenCrypto } from "./token-crypto.ts";
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+export interface AgentEnvBundle {
+  /** All stored env vars (decrypted). */
+  env: Record<string, string>;
+  agentId: string;
+  /** Enabled tool patterns for this agent. */
+  allowedTools: string[];
+}
+
+export interface AgentEnvEntry {
+  agentId: string;
+  env: Record<string, string>;
+}
+
+/**
+ * Return type for getByAgentId().
+ * Secret values are masked as "***" in env; their keys are listed in secretKeys.
+ */
+interface AgentEnvResult {
+  env: Record<string, string>;
+  secretKeys: string[];
+}
+
+// ─── Service ──────────────────────────────────────────────────────────────────
+
+export class AgentEnvService {
+  constructor(
+    private prisma: PrismaClient,
+    private crypto: TokenCrypto,
+    private clock: Clock = SystemClock(),
+    /** WIF-2.1: block Anthropic credential keys for non-self-hosted agents. */
+    private anthropicFederationEnabled = false,
+  ) {}
+
+  /**
+   * Reject Anthropic credential keys for a federated (non-self-hosted) agent.
+   * Every write path (API, admin UI, createAgent, Slack/GitHub provisioning)
+   * goes through upsert/patch, so this is the single enforcement point.
+   */
+  private assertNoBlockedCredentials(
+    agent: { selfHosted: boolean },
+    env: Record<string, string>,
+  ): void {
+    if (!this.anthropicFederationEnabled || agent.selfHosted) return;
+    const blocked = anthropicCredentialKeysIn(Object.keys(env));
+    if (blocked.length > 0) throw new AnthropicCredentialsBlockedError(blocked);
+  }
+
+  /**
+   * Replace all env vars for the given agent (delete existing + insert new).
+   * Validates that agentId references an existing Agent.
+   *
+   * @param secretKeys - optional set of key names to mark as secret
+   */
+  async upsert(
+    agentId: string,
+    env: Record<string, string>,
+    secretKeys?: Set<string>,
+  ): Promise<void> {
+    const agent = await this.prisma.agent.findUnique({
+      where: { id: agentId },
+    });
+    if (!agent) {
+      throw new UnprocessableEntityError("agent not found");
+    }
+    this.assertNoBlockedCredentials(agent, env);
+
+    const now = this.clock.now();
+    const rows = Object.entries(env).map(([key, value]) => ({
+      agentId,
+      key,
+      value: this.crypto.encrypt(value),
+      secret: secretKeys?.has(key) ?? false,
+      updatedAt: now,
+    }));
+
+    await this.prisma.$transaction([
+      this.prisma.agentEnv.deleteMany({ where: { agentId } }),
+      ...rows.map((row) =>
+        this.prisma.agentEnv.create({
+          data: {
+            agentId: row.agentId,
+            key: row.key,
+            value: row.value,
+            secret: row.secret,
+            updatedAt: row.updatedAt,
+          },
+        }),
+      ),
+    ]);
+  }
+
+  /**
+   * Upsert specific keys for the given agent without touching other keys.
+   * Validates that agentId references an existing Agent.
+   *
+   * @param secretKeys - optional set of key names to mark as secret
+   */
+  async patch(
+    agentId: string,
+    env: Record<string, string>,
+    secretKeys?: Set<string>,
+  ): Promise<void> {
+    const agent = await this.prisma.agent.findUnique({
+      where: { id: agentId },
+    });
+    if (!agent) {
+      throw new UnprocessableEntityError("agent not found");
+    }
+    this.assertNoBlockedCredentials(agent, env);
+
+    const now = this.clock.now();
+    await this.prisma.$transaction(
+      Object.entries(env).map(([key, value]) =>
+        this.prisma.agentEnv.upsert({
+          where: { agentId_key: { agentId, key } },
+          create: {
+            agentId,
+            key,
+            value: this.crypto.encrypt(value),
+            secret: secretKeys?.has(key) ?? false,
+            updatedAt: now,
+          },
+          update: {
+            value: this.crypto.encrypt(value),
+            secret: secretKeys?.has(key) ?? false,
+            updatedAt: now,
+          },
+        }),
+      ),
+    );
+  }
+
+  /**
+   * Get all env vars for an agent.
+   * Secret values are masked as "***"; their keys are listed in secretKeys.
+   * Returns null if the agent has no env vars set.
+   */
+  async getByAgentId(agentId: string): Promise<AgentEnvResult | null> {
+    const rows = await this.prisma.agentEnv.findMany({ where: { agentId } });
+    if (rows.length === 0) return null;
+
+    const env: Record<string, string> = {};
+    const secretKeys: string[] = [];
+
+    for (const row of rows) {
+      if (row.secret) {
+        env[row.key] = "***";
+        secretKeys.push(row.key);
+      } else {
+        env[row.key] = this.crypto.decrypt(row.value);
+      }
+    }
+
+    return { env, secretKeys };
+  }
+
+  /**
+   * Returns the full env bundle for an agent — stored env vars (decrypted) plus
+   * allowed tools. Always decrypts regardless of the secret flag.
+   *
+   * Returns null if the agent has no env vars set.
+   * Throws 500 if decryption fails.
+   */
+  async getConfigBundle(agentId: string): Promise<AgentEnvBundle | null> {
+    const rows = await this.prisma.agentEnv.findMany({ where: { agentId } });
+    if (rows.length === 0) return null;
+
+    let env: Record<string, string>;
+    try {
+      // Always decrypt — secret flag only affects the admin API response
+      env = this.decryptRows(rows);
+    } catch (err) {
+      console.error("[shipwright agent] failed to decrypt agent env vars", err);
+      throw new ApiError(500, "failed to decrypt agent env vars");
+    }
+
+    const tools = await this.prisma.agentTool.findMany({
+      where: { agentId, enabled: true },
+    });
+
+    return {
+      env,
+      agentId,
+      allowedTools: tools.map((t: { pattern: string }) => t.pattern),
+    };
+  }
+
+  /**
+   * Delete a single env var key for the given agent.
+   * No-ops if the key does not exist.
+   */
+  async deleteKey(agentId: string, key: string): Promise<void> {
+    await this.prisma.agentEnv.deleteMany({ where: { agentId, key } });
+  }
+
+  /**
+   * List all agents with their decrypted env vars.
+   */
+  async listAll(): Promise<AgentEnvEntry[]> {
+    const rows = await this.prisma.agentEnv.findMany();
+
+    // Group by agentId
+    const byAgent = new Map<string, typeof rows>();
+    for (const row of rows) {
+      const existing = byAgent.get(row.agentId) ?? [];
+      existing.push(row);
+      byAgent.set(row.agentId, existing);
+    }
+
+    return Array.from(byAgent.entries()).map(([agentId, agentRows]) => ({
+      agentId,
+      env: this.decryptRows(agentRows),
+    }));
+  }
+
+  private decryptRows(
+    rows: Array<{ key: string; value: string }>,
+  ): Record<string, string> {
+    const env: Record<string, string> = {};
+    for (const row of rows) {
+      env[row.key] = this.crypto.decrypt(row.value);
+    }
+    return env;
+  }
+}

package/src/agent-github-installations.integration.test.ts

@@ -0,0 +1,115 @@
+/**
+ * admin/src/agent-github-installations.integration.test.ts
+ * Integration tests for AgentGitHubInstallationsService — push/get.
+ *
+ * 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 { AgentGitHubInstallationsService } from "./agent-github-installations.ts";
+import { createAdminPrismaClient } from "./prisma-client.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);
+}
+
+async function createAgent(
+  prisma: PrismaClient,
+  name = "Test Agent",
+): Promise<string> {
+  const agent = await prisma.agent.create({ data: { name } });
+  return agent.id;
+}
+
+describeOrSkip("AgentGitHubInstallationsService (integration)", () => {
+  let prisma: PrismaClient;
+  let service: AgentGitHubInstallationsService;
+
+  beforeEach(async () => {
+    prisma = makePrisma();
+    await prisma.agentGitHubInstallationsSnapshot.deleteMany();
+    await prisma.agentWorkQueueSnapshot.deleteMany();
+    await prisma.agentChatTokenUsageDailyByModel.deleteMany();
+    await prisma.agentCronRun.deleteMany();
+    await prisma.agentToken.deleteMany();
+    await prisma.agentCronJob.deleteMany();
+    await prisma.agentTool.deleteMany();
+    await prisma.agentEnv.deleteMany();
+    await prisma.agentMember.deleteMany();
+    await prisma.agent.deleteMany();
+    service = new AgentGitHubInstallationsService(prisma);
+  });
+
+  afterEach(async () => {
+    await prisma.$disconnect();
+  });
+
+  it("push() creates a snapshot and get() reads it back", async () => {
+    const agentId = await createAgent(prisma);
+    const reportedAt = new Date("2026-01-15T12:00:00.000Z");
+    const installations = [
+      { owner: "app-vitals", installationId: 1, state: "active" },
+    ];
+
+    const written = await service.push(agentId, { reportedAt, installations });
+    expect(written.agentId).toBe(agentId);
+    expect(written.installations).toEqual(installations);
+
+    const read = await service.get(agentId);
+    expect(read?.id).toBe(written.id);
+    expect(read?.reportedAt).toEqual(reportedAt);
+  });
+
+  it("get() returns null when nothing has been pushed", async () => {
+    const agentId = await createAgent(prisma);
+    expect(await service.get(agentId)).toBeNull();
+  });
+
+  it("a second push replaces the first, removing a dropped installation", async () => {
+    const agentId = await createAgent(prisma);
+    const first = await service.push(agentId, {
+      reportedAt: new Date("2026-01-15T12:00:00.000Z"),
+      installations: [
+        { owner: "a", installationId: 1, state: "active" },
+        { owner: "b", installationId: 2, state: "active" },
+      ],
+    });
+    const second = await service.push(agentId, {
+      reportedAt: new Date("2026-01-16T12:00:00.000Z"),
+      installations: [{ owner: "a", installationId: 1, state: "active" }],
+    });
+
+    expect(second.id).toBe(first.id);
+    const read = await service.get(agentId);
+    expect(read?.installations).toEqual([
+      { owner: "a", installationId: 1, state: "active" },
+    ]);
+    expect(
+      await prisma.agentGitHubInstallationsSnapshot.count({
+        where: { agentId },
+      }),
+    ).toBe(1);
+  });
+
+  it("the snapshot row is deleted when the agent is deleted", async () => {
+    const agentId = await createAgent(prisma);
+    await service.push(agentId, {
+      reportedAt: new Date(),
+      installations: [],
+    });
+
+    await prisma.agent.delete({ where: { id: agentId } });
+
+    expect(
+      await prisma.agentGitHubInstallationsSnapshot.count({
+        where: { agentId },
+      }),
+    ).toBe(0);
+  });
+});