@app-vitals/agent-admin 0.2.1 → 0.4.0

package/src/cron-run-transcripts.integration.test.ts

@@ -0,0 +1,220 @@
+/**
+ * admin/src/cron-run-transcripts.integration.test.ts
+ * Round-trip and retention sweep against a real Postgres (COS-43.1).
+ *
+ * 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 { AgentService } from "./agents.ts";
+import {
+  type AdminDeps,
+  createAdminApp,
+  parseAdminApiKeys,
+} from "./agents-api.ts";
+import {
+  CronRunTranscriptService,
+  TRANSCRIPT_RETENTION_PER_AGENT,
+} from "./cron-run-transcripts.ts";
+import { createAdminPrismaClient } from "./prisma-client.ts";
+import { parseTranscriptConfig } from "./transcript-config.ts";
+
+const TEST_DB = process.env.DATABASE_URL_ADMIN_TEST;
+const describeOrSkip = TEST_DB ? describe : describe.skip;
+
+const ADMIN = "admin-key";
+
+describeOrSkip("cron-run transcripts (integration)", () => {
+  let prisma: PrismaClient;
+  let agentId: string;
+  let otherAgentId: string;
+  let cronId: string;
+  let otherCronId: string;
+
+  beforeEach(async () => {
+    prisma = createAdminPrismaClient(TEST_DB as string);
+    await prisma.agentTranscriptRead.deleteMany();
+    await prisma.agentCronRunTranscript.deleteMany();
+    agentId = (await prisma.agent.create({ data: { name: "TxA" } })).id;
+    otherAgentId = (await prisma.agent.create({ data: { name: "TxB" } })).id;
+    cronId = (
+      await prisma.agentCronJob.create({
+        data: { agentId, name: "c", schedule: "* * * * *", prompt: "p" },
+      })
+    ).id;
+    otherCronId = (
+      await prisma.agentCronJob.create({
+        data: {
+          agentId: otherAgentId,
+          name: "c",
+          schedule: "* * * * *",
+          prompt: "p",
+        },
+      })
+    ).id;
+  });
+
+  afterEach(async () => {
+    await prisma.agentTranscriptRead.deleteMany();
+    await prisma.agentCronRunTranscript.deleteMany();
+    await prisma.agent.deleteMany({
+      where: { id: { in: [agentId, otherAgentId] } },
+    });
+    await prisma.$disconnect();
+  });
+
+  function makeApp() {
+    const deps = {
+      agentService: new AgentService(prisma),
+      agentTokenService: { validate: async () => null },
+      adminApiKeys: parseAdminApiKeys(`root:${ADMIN}:*`),
+      sessionSecret: "s".repeat(32),
+      prisma,
+      transcripts: {
+        config: parseTranscriptConfig({
+          SHIPWRIGHT_TRANSCRIPT_API_ENABLED: "enabled",
+        }),
+        store: new CronRunTranscriptService(prisma),
+      },
+    } as unknown as AdminDeps;
+    return createAdminApp(deps);
+  }
+
+  const newRun = (agent: string, cron: string, startedAt = new Date()) =>
+    prisma.agentCronRun.create({
+      data: { agentId: agent, cronId: cron, startedAt },
+    });
+
+  const put = (
+    app: ReturnType<typeof createAdminApp>,
+    runId: string,
+    body: string,
+    cron = cronId,
+    agent = agentId,
+  ) =>
+    app.request(`/agents/${agent}/crons/${cron}/runs/${runId}/transcript`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${ADMIN}`,
+      },
+      body: JSON.stringify({
+        sessionId: "s",
+        body,
+        truncated: false,
+        redactions: 1,
+      }),
+    });
+
+  it("round-trips PUT then GET and writes an audit row", async () => {
+    const app = makeApp();
+    const run = await newRun(agentId, cronId);
+    expect((await put(app, run.id, "hello\n")).status).toBe(200);
+    const res = await app.request(
+      `/agents/${agentId}/crons/${cronId}/runs/${run.id}/transcript`,
+      { headers: { Authorization: `Bearer ${ADMIN}` } },
+    );
+    expect(res.status).toBe(200);
+    const json = (await res.json()) as Record<string, unknown>;
+    expect(json).toMatchObject({
+      runId: run.id,
+      cronId,
+      sessionId: "s",
+      bytes: 6,
+      truncated: false,
+      redactions: 1,
+      body: "hello\n",
+    });
+    const reads = await prisma.agentTranscriptRead.findMany();
+    expect(reads).toHaveLength(1);
+    expect(reads[0]).toMatchObject({
+      runId: run.id,
+      agentId,
+      scopeKind: "admin",
+    });
+  });
+
+  it("upserts: a second PUT replaces the body, one row per run", async () => {
+    const app = makeApp();
+    const run = await newRun(agentId, cronId);
+    await put(app, run.id, "one");
+    await put(app, run.id, "two-two");
+    const rows = await prisma.agentCronRunTranscript.findMany();
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.body).toBe("two-two");
+    expect(rows[0]?.bytes).toBe(7);
+  });
+
+  it("404s a run owned by a different agent or cron", async () => {
+    const app = makeApp();
+    const run = await newRun(otherAgentId, otherCronId);
+    expect((await put(app, run.id, "x")).status).toBe(404);
+    const mine = await newRun(agentId, cronId);
+    expect((await put(app, mine.id, "x", otherCronId)).status).toBe(404);
+    expect(await prisma.agentCronRunTranscript.count()).toBe(0);
+  });
+
+  it(`keeps only the newest ${TRANSCRIPT_RETENTION_PER_AGENT} per agent`, async () => {
+    const service = new CronRunTranscriptService(prisma);
+    const total = TRANSCRIPT_RETENTION_PER_AGENT + 5;
+    const base = Date.now() - total * 1000;
+    const runs: Array<{ id: string }> = [];
+    for (let i = 0; i < total; i++) {
+      runs.push(await newRun(agentId, cronId, new Date(base + i)));
+    }
+    for (const [i, run] of runs.entries()) {
+      await prisma.agentCronRunTranscript.create({
+        data: {
+          runId: run.id,
+          agentId,
+          cronId,
+          bytes: 1,
+          truncated: false,
+          redactions: 0,
+          body: "x",
+          createdAt: new Date(base + i * 10),
+        },
+      });
+    }
+    const otherRun = await newRun(otherAgentId, otherCronId);
+    await prisma.agentCronRunTranscript.create({
+      data: {
+        runId: otherRun.id,
+        agentId: otherAgentId,
+        cronId: otherCronId,
+        bytes: 1,
+        truncated: false,
+        redactions: 0,
+        body: "x",
+        createdAt: new Date(base),
+      },
+    });
+
+    const fresh = await newRun(agentId, cronId);
+    await service.upsert({
+      runId: fresh.id,
+      agentId,
+      cronId,
+      sessionId: null,
+      bytes: 1,
+      truncated: false,
+      redactions: 0,
+      body: "new",
+    });
+
+    const mine = await prisma.agentCronRunTranscript.findMany({
+      where: { agentId },
+      orderBy: { createdAt: "desc" },
+    });
+    expect(mine).toHaveLength(TRANSCRIPT_RETENTION_PER_AGENT);
+    expect(mine[0]?.runId).toBe(fresh.id);
+    // The oldest were dropped; the other agent's row is untouched.
+    expect(mine.some((r) => r.runId === runs[0]?.id)).toBe(false);
+    expect(
+      await prisma.agentCronRunTranscript.count({
+        where: { agentId: otherAgentId },
+      }),
+    ).toBe(1);
+  });
+});

package/src/cron-run-transcripts.smoke.test.ts

@@ -0,0 +1,286 @@
+/**
+ * admin/src/cron-run-transcripts.smoke.test.ts
+ *
+ * PUT/GET /agents/{id}/crons/{cronId}/runs/{runId}/transcript (COS-43.1) over
+ * the real admin route table and auth middleware with an in-memory store.
+ * Uses app.request() — no real server, no real DB.
+ */
+
+import { describe, expect, it, spyOn } from "bun:test";
+import {
+  type AdminDeps,
+  createAdminApp,
+  parseAdminApiKeys,
+} from "./agents-api.ts";
+import {
+  MAX_TRANSCRIPT_BODY_BYTES,
+  type TranscriptReadRow,
+  type TranscriptRow,
+  type TranscriptStore,
+} from "./cron-run-transcripts.ts";
+import { NotFoundError } from "./errors.ts";
+import { parseTranscriptConfig } from "./transcript-config.ts";
+
+const AGENT = "agent-1";
+const CRON = "cron-1";
+const RUN = "run-1";
+const ADMIN = "admin-key";
+const READ = "platform-read-token";
+const OPS = "platform-ops-token";
+const AGENT_KEY = "agent-1-key";
+const OTHER_KEY = "agent-2-key";
+const SECRET_BODY = "TRANSCRIPT-BODY-MUST-NOT-BE-LOGGED";
+
+function memoryStore() {
+  const rows = new Map<string, TranscriptRow>();
+  const reads: TranscriptReadRow[] = [];
+  const order: string[] = [];
+  const store: TranscriptStore = {
+    async upsert(input) {
+      if (
+        input.agentId !== AGENT ||
+        input.cronId !== CRON ||
+        input.runId !== RUN
+      ) {
+        throw new NotFoundError(`cron run ${input.runId} not found`);
+      }
+      const row: TranscriptRow = { ...input, createdAt: new Date(0) };
+      rows.set(input.runId, row);
+      order.push("upsert");
+      return row;
+    },
+    async get(agentId, cronId, runId) {
+      const row = rows.get(runId);
+      return row && row.agentId === agentId && row.cronId === cronId
+        ? row
+        : null;
+    },
+    async recordRead(row) {
+      order.push("recordRead");
+      reads.push({ ...row, at: new Date(0) });
+    },
+  };
+  return { store, rows, reads, order };
+}
+
+function makeApp(enabled = true, mem = memoryStore()) {
+  const deps = {
+    agentService: { exists: async () => true },
+    agentTokenService: { validate: async () => null },
+    agentMemberService: { listByEmail: async () => [] },
+    adminApiKeys: parseAdminApiKeys(
+      `root:${ADMIN}:*,reader:${READ}:platform.read,operator:${OPS}:platform.ops,a1:${AGENT_KEY}:${AGENT},a2:${OTHER_KEY}:agent-2`,
+    ),
+    sessionSecret: "s".repeat(32),
+    transcripts: {
+      config: parseTranscriptConfig({
+        SHIPWRIGHT_TRANSCRIPT_API_ENABLED: enabled ? "enabled" : undefined,
+      }),
+      store: mem.store,
+    },
+  } as unknown as AdminDeps;
+  return { app: createAdminApp(deps), ...mem };
+}
+
+const path = (agent = AGENT, cron = CRON, run = RUN) =>
+  `/agents/${agent}/crons/${cron}/runs/${run}/transcript`;
+
+function put(
+  app: ReturnType<typeof createAdminApp>,
+  token: string | null,
+  body: Record<string, unknown> = {},
+  p = path(),
+) {
+  return app.request(p, {
+    method: "PUT",
+    body: JSON.stringify({
+      sessionId: "sess-1",
+      body: SECRET_BODY,
+      truncated: false,
+      redactions: 2,
+      ...body,
+    }),
+    headers: {
+      "Content-Type": "application/json",
+      ...(token ? { Authorization: `Bearer ${token}` } : {}),
+    },
+  });
+}
+
+function get(
+  app: ReturnType<typeof createAdminApp>,
+  token: string | null,
+  p = path(),
+) {
+  return app.request(p, {
+    headers: token ? { Authorization: `Bearer ${token}` } : {},
+  });
+}
+
+describe("transcript routes — flag", () => {
+  it("404s PUT and GET when the flag is off, for every caller", async () => {
+    const { app } = makeApp(false);
+    expect((await put(app, ADMIN)).status).toBe(404);
+    expect((await put(app, AGENT_KEY)).status).toBe(404);
+    expect((await get(app, ADMIN)).status).toBe(404);
+    expect((await get(app, READ)).status).toBe(404);
+  });
+
+  it("404s when no transcript deps are wired at all", async () => {
+    const deps = {
+      agentService: { exists: async () => true },
+      agentTokenService: { validate: async () => null },
+      adminApiKeys: parseAdminApiKeys(`root:${ADMIN}:*`),
+      sessionSecret: "s".repeat(32),
+    } as unknown as AdminDeps;
+    const app = createAdminApp(deps);
+    expect((await get(app, ADMIN)).status).toBe(404);
+  });
+});
+
+describe("PUT transcript — auth matrix", () => {
+  it("accepts the agent's own key and the admin key", async () => {
+    const { app, rows } = makeApp();
+    expect((await put(app, AGENT_KEY)).status).toBe(200);
+    expect((await put(app, ADMIN)).status).toBe(200);
+    expect(rows.get(RUN)?.redactions).toBe(2);
+  });
+
+  it("rejects another agent's key, platform keys and anonymous callers", async () => {
+    const { app } = makeApp();
+    expect((await put(app, OTHER_KEY)).status).toBe(403);
+    expect((await put(app, READ)).status).toBe(403);
+    expect((await put(app, OPS)).status).toBe(403);
+    expect((await put(app, null)).status).toBe(401);
+  });
+
+  it("404s when the run is not owned by the cron/agent", async () => {
+    const { app } = makeApp();
+    expect((await put(app, ADMIN, {}, path(AGENT, "other-cron"))).status).toBe(
+      404,
+    );
+  });
+
+  it("returns the stored size and flags", async () => {
+    const { app } = makeApp();
+    const res = await put(app, AGENT_KEY, { truncated: true });
+    expect(await res.json()).toEqual({
+      runId: RUN,
+      bytes: Buffer.byteLength(SECRET_BODY),
+      truncated: true,
+      redactions: 2,
+    });
+  });
+});
+
+describe("PUT transcript — size cap", () => {
+  it("accepts exactly 1 MiB and 413s one byte over", async () => {
+    const { app } = makeApp();
+    const ok = await put(app, AGENT_KEY, {
+      body: "a".repeat(MAX_TRANSCRIPT_BODY_BYTES),
+    });
+    expect(ok.status).toBe(200);
+    const big = await put(app, AGENT_KEY, {
+      body: "a".repeat(MAX_TRANSCRIPT_BODY_BYTES + 1),
+    });
+    expect(big.status).toBe(413);
+  });
+
+  it("counts bytes, not characters", async () => {
+    const { app } = makeApp();
+    const res = await put(app, AGENT_KEY, {
+      body: "é".repeat(MAX_TRANSCRIPT_BODY_BYTES / 2 + 1),
+    });
+    expect(res.status).toBe(413);
+  });
+
+  it("400s a malformed body", async () => {
+    const { app } = makeApp();
+    expect((await put(app, AGENT_KEY, { body: 5 })).status).toBe(400);
+  });
+});
+
+describe("GET transcript — auth matrix and audit", () => {
+  it("403s every agent key, even for its own run", async () => {
+    const mem = memoryStore();
+    const { app, reads } = makeApp(true, mem);
+    await put(app, ADMIN);
+    expect((await get(app, AGENT_KEY)).status).toBe(403);
+    expect((await get(app, OTHER_KEY)).status).toBe(403);
+    expect(reads).toHaveLength(0);
+  });
+
+  it("401s anonymous callers", async () => {
+    const { app } = makeApp();
+    expect((await get(app, null)).status).toBe(401);
+  });
+
+  it("serves admin, platform.read and platform.ops and audits each read first", async () => {
+    const mem = memoryStore();
+    const { app, reads, order } = makeApp(true, mem);
+    await put(app, AGENT_KEY);
+    order.length = 0;
+    for (const [token, kind, reader] of [
+      [ADMIN, "admin", "root"],
+      [READ, "platform-read", "reader"],
+      [OPS, "platform-ops", "operator"],
+    ] as const) {
+      const res = await get(app, token);
+      expect(res.status).toBe(200);
+      expect(await res.json()).toEqual({
+        runId: RUN,
+        cronId: CRON,
+        sessionId: "sess-1",
+        bytes: Buffer.byteLength(SECRET_BODY),
+        truncated: false,
+        redactions: 2,
+        createdAt: new Date(0).toISOString(),
+        body: SECRET_BODY,
+      });
+      expect(reads.at(-1)).toMatchObject({
+        runId: RUN,
+        agentId: AGENT,
+        scopeKind: kind,
+        reader,
+      });
+    }
+    expect(order).toEqual(["recordRead", "recordRead", "recordRead"]);
+    expect(reads).toHaveLength(3);
+  });
+
+  it("404s an absent transcript and writes no audit row", async () => {
+    const { app, reads } = makeApp();
+    expect((await get(app, ADMIN)).status).toBe(404);
+    expect(reads).toHaveLength(0);
+  });
+
+  it("does not respond when the audit write fails", async () => {
+    const mem = memoryStore();
+    const { app } = makeApp(true, mem);
+    await put(app, ADMIN);
+    mem.store.recordRead = async () => {
+      throw new Error("db down");
+    };
+    const errSpy = spyOn(console, "error").mockImplementation(() => {});
+    const res = await get(app, ADMIN);
+    errSpy.mockRestore();
+    expect(res.status).toBe(500);
+    expect(await res.text()).not.toContain(SECRET_BODY);
+  });
+});
+
+describe("transcript routes — logging", () => {
+  it("never logs the transcript body", async () => {
+    const lines: string[] = [];
+    const sinks = (["log", "warn", "error", "info"] as const).map((m) =>
+      spyOn(console, m).mockImplementation((...a: unknown[]) => {
+        lines.push(a.map(String).join(" "));
+      }),
+    );
+    const { app } = makeApp();
+    await put(app, AGENT_KEY);
+    await get(app, ADMIN);
+    for (const s of sinks) s.mockRestore();
+    expect(lines.join("\n")).not.toContain(SECRET_BODY);
+  });
+});