@app-vitals/agent-admin 1.5.0 → 1.7.0

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

@@ -6485,3 +6485,117 @@ describe("admin API — PATCH /agents/:id specialty (SAL-1.2)", () => {
     ]);
   });
 });
+
+// ─── PUT /agents/:id/baked-marketplaces (PMK-1.4) ─────────────────────────────
+
+describe("admin API — baked marketplaces report", () => {
+  const BAKED_URL = `/agents/${AGENT_ID}/baked-marketplaces`;
+  let cookie: string;
+
+  beforeAll(async () => {
+    cookie = await makeSessionCookie();
+  });
+
+  /** Deps whose agentService stores/serves the baked list in memory. */
+  function makeBakedDeps(tokenAgentId: string) {
+    let baked: string[] = [];
+    const base = makeDepsWithTokenValidation(async () => ({
+      agentId: tokenAgentId,
+    }));
+    const deps: AdminDeps = {
+      ...base,
+      agentService: {
+        ...base.agentService,
+        getDetail: async (id: string) => {
+          const d = await base.agentService.getDetail(id);
+          return d ? { ...d, bakedMarketplaces: baked } : null;
+        },
+        setBakedMarketplaces: async (_id: string, names: string[]) => {
+          baked = names;
+          return names;
+        },
+      },
+    };
+    return { deps, stored: () => baked };
+  }
+
+  const bearerPut = (app: ReturnType<typeof createAdminApp>, body: unknown) =>
+    app.request(BAKED_URL, {
+      method: "PUT",
+      body: JSON.stringify(body),
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${VALID_BEARER_TOKEN}`,
+      },
+    });
+  const bearerGet = (app: ReturnType<typeof createAdminApp>) =>
+    app.request(`/agents/${AGENT_ID}`, {
+      headers: { Cookie: `admin_session=${cookie}` },
+    });
+
+  it("stores the names for the agent's own key and GET shows them", async () => {
+    const app = createAdminApp(makeBakedDeps(AGENT_ID).deps);
+    const res = await bearerPut(app, { names: ["vitals-os", "shipwright"] });
+    expect(res.status).toBe(200);
+    expect((await res.json()).bakedMarketplaces).toEqual([
+      "vitals-os",
+      "shipwright",
+    ]);
+    expect((await (await bearerGet(app)).json()).bakedMarketplaces).toEqual([
+      "vitals-os",
+      "shipwright",
+    ]);
+  });
+
+  it("overwrites rather than appends", async () => {
+    const app = createAdminApp(makeBakedDeps(AGENT_ID).deps);
+    await bearerPut(app, { names: ["vitals-os", "shipwright"] });
+    await bearerPut(app, { names: ["vitals-os"] });
+    expect((await (await bearerGet(app)).json()).bakedMarketplaces).toEqual([
+      "vitals-os",
+    ]);
+  });
+
+  it("another agent's key is rejected (403) and stores nothing", async () => {
+    const { deps, stored } = makeBakedDeps("other-agent");
+    const res = await bearerPut(createAdminApp(deps), { names: ["x"] });
+    expect(res.status).toBe(403);
+    expect(stored()).toEqual([]);
+  });
+
+  it("an admin session is rejected (403): only the agent's own key reports", async () => {
+    const { deps, stored } = makeBakedDeps(AGENT_ID);
+    const res = await createAdminApp(deps).request(BAKED_URL, {
+      method: "PUT",
+      body: JSON.stringify({ names: ["x"] }),
+      headers: {
+        "Content-Type": "application/json",
+        Cookie: `admin_session=${cookie}`,
+      },
+    });
+    expect(res.status).toBe(403);
+    expect(stored()).toEqual([]);
+  });
+
+  it("rejects unknown body fields (400)", async () => {
+    const { deps } = makeBakedDeps(AGENT_ID);
+    const res = await bearerPut(createAdminApp(deps), {
+      names: [],
+      extra: 1,
+    });
+    expect(res.status).toBe(400);
+  });
+
+  it("PATCH /agents/:id cannot set the baked list", async () => {
+    const { deps, stored } = makeBakedDeps(AGENT_ID);
+    await createAdminApp(deps).request(`/agents/${AGENT_ID}`, {
+      method: "PATCH",
+      body: JSON.stringify({ bakedMarketplaces: ["evil"] }),
+      headers: {
+        "Content-Type": "application/json",
+        Cookie: `admin_session=${cookie}`,
+      },
+    });
+    expect(stored()).toEqual([]);
+  });
+});

package/src/agents-api.ts

@@ -123,6 +123,7 @@ import {
   AgentSummarySchema,
   AgentTokenSchema,
   AgentToolSchema,
+  BakedMarketplacesResultSchema,
   ChatCredentialsWrapperSchema,
   ChatTokenStatsSchema,
   CreateAgentBodySchema,
@@ -154,6 +155,7 @@ import {
   PatchAgentPluginBodySchema,
   PatchAgentToolBodySchema,
   PluginNameQuerySchema,
+  PutBakedMarketplacesBodySchema,
   PutGitHubInstallationsBodySchema,
   TokenIdParamSchema,
   ToolIdParamSchema,
@@ -182,7 +184,10 @@ export interface AdminDeps {
     // through the narrower Pick above.
     | "updateFields"
     | "runTransaction"
-  >;
+  > &
+    // PMK-1.4: optional so existing AdminDeps consumers stay valid; the
+    // baked-marketplaces report route fails with a 500 when it is not wired.
+    Partial<Pick<AgentService, "setBakedMarketplaces">>;
   agentEnvService: Pick<
     AgentEnvService,
     "upsert" | "patch" | "getByAgentId" | "deleteKey"
@@ -453,6 +458,15 @@ const GetAgentResultSchema = z
      */
     trialExpiresAt: z.string().datetime().nullable().optional(),
     trialExpiryWarnedAt: z.string().datetime().nullable().optional(),
+    /**
+     * PMK-1.4: names of the marketplaces baked into the agent's image, as last
+     * reported by the runtime at boot. Read-only: only the runtime-authenticated
+     * PUT /agents/:id/baked-marketplaces route writes it.
+     */
+    bakedMarketplaces: z
+      .array(z.string())
+      .optional()
+      .openapi({ example: ["vitals-os", "shipwright"] }),
     /** APM-1.3: the six real agent-policy fields (APM-1.1 DB columns). */
     autoPostReviews: z.boolean().openapi({ example: true }),
     allowSelfReview: z.boolean().openapi({ example: false }),
@@ -1341,6 +1355,37 @@ const putGitHubInstallationsRoute = createRoute({
   },
 });
 
+const putBakedMarketplacesRoute = createRoute({
+  method: "put",
+  path: "/agents/{id}/baked-marketplaces",
+  summary: "Report the marketplaces baked into the agent's image",
+  description:
+    "Runtime-only report, authenticated with the agent's own key. Overwrites the stored list of baked marketplace names (the image's current state); it is exposed read-only as `bakedMarketplaces` on GET /agents/{id}. Other callers, including another agent's key, get 403.",
+  request: {
+    params: AgentIdParamSchema,
+    body: {
+      content: {
+        "application/json": { schema: PutBakedMarketplacesBodySchema },
+      },
+    },
+  },
+  responses: {
+    200: {
+      description: "Baked marketplaces stored",
+      content: {
+        "application/json": { schema: BakedMarketplacesResultSchema },
+      },
+    },
+    400: { description: "Bad request", ...jsonError },
+    401: { description: "Unauthorized", ...jsonError },
+    403: {
+      description: "Forbidden — only the agent's own key may report",
+      ...jsonError,
+    },
+    404: { description: "Agent not found", ...jsonError },
+  },
+});
+
 const getGitHubInstallationsRoute = createRoute({
   method: "get",
   path: "/agents/{id}/github-installations",
@@ -2747,6 +2792,28 @@ export function createAdminApp(deps: AdminDeps): OpenAPIHono<AdminAuthEnv> {
     );
   });
 
+  // PUT /agents/:id/baked-marketplaces — runtime report (PMK-1.4), overwrite.
+  // Restricted to the agent's own key: admins, members and other agents' keys
+  // never write this value.
+  app.openapi(putBakedMarketplacesRoute, async (c) => {
+    const { id: agentId } = c.req.valid("param");
+    const scope = c.get("scope") as AdminScope | undefined;
+    if (scope?.kind !== "agent" || scope.agentId !== agentId) {
+      throw new ForbiddenError(
+        "Only the agent's own key may report baked marketplaces",
+      );
+    }
+    if (!agentService.setBakedMarketplaces) {
+      throw new Error("agentService.setBakedMarketplaces is not wired");
+    }
+    const { names } = c.req.valid("json");
+    const stored = await agentService.setBakedMarketplaces(agentId, [
+      ...new Set(names),
+    ]);
+    if (!stored) throw new NotFoundError(`agent ${agentId} not found`);
+    return c.json({ bakedMarketplaces: stored }, 200);
+  });
+
   // GET /agents/:id/github-installations — latest snapshot, 404 if none yet
   app.openapi(getGitHubInstallationsRoute, async (c) => {
     const { id: agentId } = c.req.valid("param");
@@ -2990,6 +3057,7 @@ function serializeAgent(
     missingRequiredEnv?: string[];
     trialExpiresAt?: Date | null;
     trialExpiryWarnedAt?: Date | null;
+    bakedMarketplaces?: string[];
     autoPostReviews?: boolean;
     allowSelfReview?: boolean;
     minConfidence?: number;
@@ -3024,6 +3092,7 @@ function serializeAgent(
     trialExpiryWarnedAt: agent.trialExpiryWarnedAt
       ? agent.trialExpiryWarnedAt.toISOString()
       : null,
+    bakedMarketplaces: agent.bakedMarketplaces ?? [],
     autoPostReviews: agent.autoPostReviews ?? true,
     allowSelfReview: agent.allowSelfReview ?? false,
     minConfidence: agent.minConfidence ?? 75,

package/src/agents.baked-marketplaces.integration.test.ts

@@ -0,0 +1,123 @@
+/**
+ * PMK-1.4: integration tests (real Postgres) for the baked-marketplaces store:
+ * AgentService.setBakedMarketplaces, overwrite semantics, GET detail exposure,
+ * and the absence of any other write path.
+ *
+ * Requires DATABASE_URL_ADMIN_TEST; skips otherwise.
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { PrismaClient } from "../prisma/client/client.ts";
+import { AgentService } from "./agents.ts";
+import { PatchAgentBodySchema } from "./openapi-schemas.ts";
+import { createAdminPrismaClient } from "./prisma-client.ts";
+
+const TEST_DB = process.env.DATABASE_URL_ADMIN_TEST;
+const describeOrSkip = TEST_DB ? describe : describe.skip;
+
+describeOrSkip("baked marketplaces store (integration)", () => {
+  let prisma: PrismaClient;
+  let service: AgentService;
+
+  beforeEach(async () => {
+    prisma = createAdminPrismaClient(TEST_DB as string);
+    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 AgentService(prisma);
+  });
+
+  afterEach(async () => {
+    await prisma.$disconnect();
+  });
+
+  it("defaults to an empty list", async () => {
+    const { id } = await prisma.agent.create({ data: { name: "a" } });
+    expect((await service.getDetail(id))?.bakedMarketplaces).toEqual([]);
+  });
+
+  it("stores the reported names and getDetail exposes them", async () => {
+    const { id } = await prisma.agent.create({ data: { name: "a" } });
+    const stored = await service.setBakedMarketplaces(id, [
+      "vitals-os",
+      "shipwright",
+    ]);
+    expect(stored).toEqual(["vitals-os", "shipwright"]);
+    expect((await service.getDetail(id))?.bakedMarketplaces).toEqual([
+      "vitals-os",
+      "shipwright",
+    ]);
+  });
+
+  it("overwrites on every report instead of appending", async () => {
+    const { id } = await prisma.agent.create({ data: { name: "a" } });
+    await service.setBakedMarketplaces(id, ["vitals-os", "shipwright"]);
+    await service.setBakedMarketplaces(id, ["vitals-os"]);
+    expect((await service.getDetail(id))?.bakedMarketplaces).toEqual([
+      "vitals-os",
+    ]);
+    await service.setBakedMarketplaces(id, []);
+    expect((await service.getDetail(id))?.bakedMarketplaces).toEqual([]);
+  });
+
+  it("only touches the reporting agent's row", async () => {
+    const a = await prisma.agent.create({ data: { name: "a" } });
+    const b = await prisma.agent.create({ data: { name: "b" } });
+    await service.setBakedMarketplaces(a.id, ["x"]);
+    expect((await service.getDetail(b.id))?.bakedMarketplaces).toEqual([]);
+  });
+
+  it("returns null for an unknown agent", async () => {
+    expect(await service.setBakedMarketplaces("nope", ["x"])).toBeNull();
+  });
+
+  it("updateSelfHosted (the PATCH writer) never writes the baked list", async () => {
+    const { id } = await prisma.agent.create({ data: { name: "a" } });
+    await service.setBakedMarketplaces(id, ["vitals-os"]);
+    await service.updateSelfHosted(id, {
+      selfHosted: true,
+      // biome-ignore lint/suspicious/noExplicitAny: proving an off-contract key is ignored
+      ...({ bakedMarketplaces: ["evil"] } as any),
+    });
+    expect((await service.getDetail(id))?.bakedMarketplaces).toEqual([
+      "vitals-os",
+    ]);
+  });
+
+  it("PatchAgentBodySchema does not carry the field through", () => {
+    const parsed = PatchAgentBodySchema.safeParse({
+      bakedMarketplaces: ["evil"],
+    });
+    if (parsed.success) {
+      expect("bakedMarketplaces" in parsed.data).toBe(false);
+    }
+  });
+
+  it("no admin source other than the report path writes bakedMarketplaces", () => {
+    const dir = import.meta.dir;
+    const writers = readdirSync(dir)
+      .filter((f) => f.endsWith(".ts") && !/\.test\.ts$/.test(f))
+      .filter((f) =>
+        /bakedMarketplaces/.test(readFileSync(join(dir, f), "utf8")),
+      )
+      .sort();
+    // agents.ts: writer + read select; agents-api.ts: report route + read
+    // serialization; openapi-schemas.ts: response/read schemas only.
+    expect(writers).toEqual([
+      "agents-api.ts",
+      "agents.ts",
+      "openapi-schemas.ts",
+    ]);
+    const api = readFileSync(join(dir, "agents-api.ts"), "utf8");
+    expect(api.match(/setBakedMarketplaces\(/g)?.length).toBe(1);
+  });
+});

package/src/agents.ts

@@ -125,6 +125,12 @@ export interface AgentDetail extends Partial<AgentAnthropicIdentity> {
    */
   trialExpiresAt?: Date | null;
   trialExpiryWarnedAt?: Date | null;
+  /**
+   * PMK-1.4: marketplace names baked into the agent's image, as last reported
+   * by the runtime. Read-only here; written only by setBakedMarketplaces().
+   * Optional so existing AgentDetail test doubles stay valid.
+   */
+  bakedMarketplaces?: string[];
   /**
    * APM-1.3: the six real agent-policy fields (APM-1.1 DB columns,
    * Prisma-column defaults noted per field below). Optional here (like
@@ -281,6 +287,7 @@ const DETAIL_SELECT = {
   updatedAt: true,
   trialExpiresAt: true,
   trialExpiryWarnedAt: true,
+  bakedMarketplaces: true,
   autoPostReviews: true,
   allowSelfReview: true,
   minConfidence: true,
@@ -454,6 +461,23 @@ export class AgentService {
     return { ...row, missingRequiredEnv };
   }
 
+  /**
+   * PMK-1.4: overwrite the agent's reported baked-marketplace names. Called
+   * only by the runtime-authenticated PUT /agents/:id/baked-marketplaces
+   * route; no PATCH field or UI control reaches it. Returns the stored list,
+   * or null when the agent does not exist.
+   */
+  async setBakedMarketplaces(
+    id: string,
+    names: string[],
+  ): Promise<string[] | null> {
+    const res = await this.prisma.agent.updateMany({
+      where: { id },
+      data: { bakedMarketplaces: names },
+    });
+    return res.count === 0 ? null : names;
+  }
+
   /**
    * Returns whether an agent with the given id exists.
    */

package/src/openapi-schemas.ts

@@ -1078,6 +1078,26 @@ export const AgentGitHubInstallationsSnapshotSchema = z
 
 // ─── Path param schemas ───────────────────────────────────────────────────────
 
+/**
+ * PUT /agents/:id/baked-marketplaces body (PMK-1.4). Runtime-only report:
+ * `names` overwrites the stored list.
+ */
+export const PutBakedMarketplacesBodySchema = z
+  .object({
+    names: z
+      .array(z.string().min(1).max(255))
+      .max(100)
+      .openapi({ example: ["vitals-os", "shipwright"] }),
+  })
+  .strict()
+  .openapi("PutBakedMarketplacesBody");
+
+export const BakedMarketplacesResultSchema = z
+  .object({
+    bakedMarketplaces: z.array(z.string()).openapi({ example: ["vitals-os"] }),
+  })
+  .openapi("BakedMarketplacesResult");
+
 export const AgentIdParamSchema = z.object({
   id: z.string().openapi({ example: "clx1234567890" }),
 });