@app-vitals/agent-admin 1.3.0 → 1.5.0

package/prisma/client/models.ts

@@ -14,6 +14,7 @@ export type * from './models/SessionFollow.ts'
 export type * from './models/SessionAlertState.ts'
 export type * from './models/Agent.ts'
 export type * from './models/AgentEnv.ts'
+export type * from './models/GitHubEnterpriseApp.ts'
 export type * from './models/AgentCronJob.ts'
 export type * from './models/AgentTool.ts'
 export type * from './models/AgentToken.ts'
@@ -34,4 +35,5 @@ export type * from './models/AgentGitHubInstallationsSnapshot.ts'
 export type * from './models/PushSubscription.ts'
 export type * from './models/ChatThreadWatch.ts'
 export type * from './models/UserNotificationPrefs.ts'
+export type * from './models/AgentMarketplace.ts'
 export type * from './commonInputTypes.ts'

package/prisma/migrations/20261101000000_add_agent_marketplace/migration.sql

@@ -0,0 +1,19 @@
+-- PMK-1.1: AgentMarketplace table for per-agent plugin marketplaces (additive only).
+-- CreateTable
+CREATE TABLE "AgentMarketplace" (
+    "id" TEXT NOT NULL,
+    "agentId" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "source" TEXT NOT NULL,
+    "ref" TEXT,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "AgentMarketplace_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "AgentMarketplace_agentId_name_key" ON "AgentMarketplace"("agentId", "name");
+
+-- AddForeignKey
+ALTER TABLE "AgentMarketplace" ADD CONSTRAINT "AgentMarketplace_agentId_fkey" FOREIGN KEY ("agentId") REFERENCES "Agent"("id") ON DELETE CASCADE ON UPDATE CASCADE;

package/prisma/migrations/20261109000000_add_github_enterprise_app/migration.sql

@@ -0,0 +1,16 @@
+-- GHE-1.1: optional admin-level GitHub Apps (installer / lookup). Additive only: new table.
+-- CreateTable
+CREATE TABLE "GitHubEnterpriseApp" (
+    "role" TEXT NOT NULL,
+    "appId" TEXT NOT NULL,
+    "slug" TEXT NOT NULL,
+    "enterpriseSlug" TEXT,
+    "privateKeyEncrypted" TEXT NOT NULL,
+    "lastValidationStatus" TEXT,
+    "lastValidatedAt" TIMESTAMP(3),
+    "lastValidationError" TEXT,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "GitHubEnterpriseApp_pkey" PRIMARY KEY ("role")
+);

package/prisma/schema/schema.prisma

@@ -1,5 +1,6 @@
 // Shipwright — Admin Service Schema
 // Owns: Agent, AgentEnv, AgentCronJob, AgentTool, AgentToken, AgentPlugin,
+// AgentMarketplace,
 // plus the coding-owned models in coding.prisma (AgentWorkQueueSnapshot,
 // AgentPhaseMethodology, SessionFollow, SessionAlertState).
 // Agent is a first-class model (standalone, not embedded in a User model).
@@ -88,6 +89,7 @@ model Agent {
   tools            AgentTool[]
   tokens           AgentToken[]
   plugins          AgentPlugin[]
+  marketplaces     AgentMarketplace[]
   members          AgentMember[]
   chatTokenUsage   AgentChatTokenUsageDailyByModel[]
   workQueueSnapshot AgentWorkQueueSnapshot?
@@ -114,6 +116,24 @@ model AgentEnv {
   @@unique([agentId, key])
 }
 
+// ─── GitHub Enterprise Apps ───────────────────────────────────────────────────
+// Optional admin-level GitHub Apps, one per role ('installer' | 'lookup'), at most
+// two rows per deployment; no rows means the feature is off. Deliberately NOT in
+// AgentEnv so the private key can never reach the agent config bundle.
+
+model GitHubEnterpriseApp {
+  role                  String    @id // 'installer' | 'lookup'
+  appId                 String
+  slug                  String
+  enterpriseSlug        String?   // installer only
+  privateKeyEncrypted   String    // AES-256-GCM (iv:ciphertext:authTag); never returned by any read path
+  lastValidationStatus  String?
+  lastValidatedAt       DateTime?
+  lastValidationError   String?
+  createdAt             DateTime  @default(now())
+  updatedAt             DateTime  @updatedAt
+}
+
 // ─── Agent Cron Jobs ──────────────────────────────────────────────────────────
 // Scheduled prompts per agent.
 // Delivery target is either a Slack channel ID or a Slack user ID (DM).
@@ -569,3 +589,20 @@ model UserNotificationPrefs {
   updatedAt          DateTime  @updatedAt
 }
 
+
+// ─── AgentMarketplace ─────────────────────────────────────────────────────────
+// Plugin marketplaces registered per agent. `name` is the marketplace name that
+// AgentPlugin specs reference after the `@` (e.g. "plugin@<name>").
+
+model AgentMarketplace {
+  id        String   @id @default(cuid())
+  agentId   String
+  agent     Agent    @relation(fields: [agentId], references: [id], onDelete: Cascade)
+  name      String
+  source    String
+  ref       String?
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@unique([agentId, name])
+}

package/src/admin-boot.ts

@@ -23,7 +23,7 @@
  * They use non-overlapping sub-paths so Hono resolves them correctly:
  *   runtime  → GET  /agents/:id/config, GET /agents/:id/crons
  *   admin    → GET /agents/:id/crons/summary (enriched with run stats)
- *              POST/PATCH/DELETE /agents/:id/envs, /crons, /tools, /tokens, /plugins
+ *              POST/PATCH/DELETE /agents/:id/envs, /crons, /tools, /tokens, /plugins, /marketplaces
  *
  * This file must not import any coding module — main.ts is the only file
  * that wires a concrete extension in.
@@ -80,6 +80,7 @@ import { AgentCronRunStatsService } from "./agent-cron-run-stats.ts";
 import { AgentCronRunService } from "./agent-cron-runs.ts";
 import { AgentEnvService } from "./agent-envs.ts";
 import { AgentGitHubInstallationsService } from "./agent-github-installations.ts";
+import { AgentMarketplaceService } from "./agent-marketplaces.ts";
 import { AgentMemberService } from "./agent-members.ts";
 import { AgentPluginService } from "./agent-plugins.ts";
 import { AgentTokenService } from "./agent-tokens.ts";
@@ -197,6 +198,7 @@ export async function startAdmin(
   const agentToolService = new AgentToolService(prisma);
   const agentTokenService = new AgentTokenService(prisma);
   const agentPluginService = new AgentPluginService(prisma);
+  const agentMarketplaceService = new AgentMarketplaceService(prisma);
   const agentMemberService = new AgentMemberService(prisma);
   // Account-aware caller scope (SSP-2.1). Account membership contributes
   // agents only when the self-serve flag is on; off → AgentMember-only.
@@ -433,6 +435,7 @@ export async function startAdmin(
     agentCronJobService,
     agentService,
     agentPluginService,
+    agentMarketplaceService,
     ...(resolvedExtensions.agentPhaseMethodologyService
       ? {
           agentPhaseMethodologyService:
@@ -461,6 +464,7 @@ export async function startAdmin(
     agentToolService,
     agentTokenService,
     agentPluginService,
+    agentMarketplaceService,
     agentMemberService,
     callerScopeResolver,
     specialtyRegistry,

package/src/agent-marketplaces-api.integration.test.ts

@@ -0,0 +1,263 @@
+/**
+ * admin/src/agent-marketplaces-api.integration.test.ts
+ * Integration tests for AgentMarketplaceService, the /agents/{id}/marketplaces
+ * routes and the `marketplaces` field of GET /agents/{id}/config, 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 { AgentMarketplaceService } from "./agent-marketplaces.ts";
+import { AgentTokenService } from "./agent-tokens.ts";
+import { AgentService } from "./agents.ts";
+import {
+  type AdminDeps,
+  createAdminApp,
+  parseAdminApiKeys,
+} from "./agents-api.ts";
+import { createAgentRuntimeApp } from "./api.ts";
+import { NotFoundError, UnprocessableEntityError } from "./errors.ts";
+import { createAdminPrismaClient } from "./prisma-client.ts";
+
+const TEST_DB = process.env.DATABASE_URL_ADMIN_TEST;
+const describeOrSkip = TEST_DB ? describe : describe.skip;
+
+const SESSION_SECRET = "test-admin-session-secret-32-bytes!";
+const ADMIN_KEY = "admin-key-token";
+
+describeOrSkip("AgentMarketplaceService + routes (integration)", () => {
+  let prisma: PrismaClient;
+  let service: AgentMarketplaceService;
+  let tokens: AgentTokenService;
+  let adminApp: ReturnType<typeof createAdminApp>;
+  let runtimeApp: ReturnType<typeof createAgentRuntimeApp>;
+  let agentA: string;
+  let agentB: string;
+  let tokenA: string;
+  let tokenB: string;
+
+  const adminKeys = parseAdminApiKeys(`root:${ADMIN_KEY}:*`);
+  const json = (token: string, body?: unknown, method = "POST") => ({
+    method,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+    },
+    ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+  });
+  const get = (token: string) => ({
+    headers: { Authorization: `Bearer ${token}` },
+  });
+
+  beforeEach(async () => {
+    prisma = createAdminPrismaClient(TEST_DB as string);
+    await prisma.agentMarketplace.deleteMany();
+    await prisma.agentPlugin.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();
+
+    agentA = (await prisma.agent.create({ data: { name: "A" } })).id;
+    agentB = (await prisma.agent.create({ data: { name: "B" } })).id;
+    service = new AgentMarketplaceService(prisma);
+    tokens = new AgentTokenService(prisma);
+    tokenA = (await tokens.create(agentA)).rawToken;
+    tokenB = (await tokens.create(agentB)).rawToken;
+
+    adminApp = createAdminApp({
+      agentTokenService: tokens,
+      agentMemberService: { exists: async () => false },
+      agentMarketplaceService: service,
+      prisma,
+      sessionSecret: SESSION_SECRET,
+      adminApiKeys: adminKeys,
+    } as unknown as AdminDeps);
+
+    runtimeApp = createAgentRuntimeApp({
+      agentEnvService: { getConfigBundle: async () => null },
+      agentCronJobService: { list: async () => [] },
+      agentService: new AgentService(prisma),
+      agentPluginService: { listEnabled: async () => [] },
+      agentMarketplaceService: service,
+      sessionSecret: SESSION_SECRET,
+      adminApiKeys: adminKeys,
+      agentTokenService: tokens,
+    } as never);
+  });
+
+  afterEach(async () => {
+    await prisma.$disconnect();
+  });
+
+  describe("service", () => {
+    it("upserts, lists in creation order, and re-points an existing name", async () => {
+      const first = await service.upsert(agentA, {
+        name: "shipwright",
+        source: "app-vitals/shipwright",
+      });
+      expect(first.ref).toBeNull();
+      await service.upsert(agentA, {
+        name: "other",
+        source: "https://github.com/o/r.git",
+        ref: "v1",
+      });
+      const again = await service.upsert(agentA, {
+        name: "shipwright",
+        source: "app-vitals/shipwright-fork",
+        ref: "main",
+      });
+      expect(again.id).toBe(first.id);
+
+      const rows = await service.list(agentA);
+      expect(rows.map((r) => r.name)).toEqual(["shipwright", "other"]);
+      expect(rows[0]?.source).toBe("app-vitals/shipwright-fork");
+      expect(rows[0]?.ref).toBe("main");
+      expect(await service.list(agentB)).toEqual([]);
+    });
+
+    it("same name on two agents are independent rows", async () => {
+      await service.upsert(agentA, { name: "m", source: "o/a" });
+      await service.upsert(agentB, { name: "m", source: "o/b" });
+      expect((await service.list(agentA))[0]?.source).toBe("o/a");
+      expect((await service.list(agentB))[0]?.source).toBe("o/b");
+    });
+
+    it("rejects an invalid source without writing", async () => {
+      await expect(
+        service.upsert(agentA, { name: "m", source: "http://x.com/o/r" }),
+      ).rejects.toBeInstanceOf(UnprocessableEntityError);
+      expect(await service.list(agentA)).toEqual([]);
+    });
+
+    it("remove deletes an owned row and 404s on another agent's row", async () => {
+      const row = await service.upsert(agentA, { name: "m", source: "o/r" });
+      await expect(service.remove(agentB, row.id)).rejects.toBeInstanceOf(
+        NotFoundError,
+      );
+      expect(await service.list(agentA)).toHaveLength(1);
+      await service.remove(agentA, row.id);
+      expect(await service.list(agentA)).toEqual([]);
+      await expect(service.remove(agentA, row.id)).rejects.toBeInstanceOf(
+        NotFoundError,
+      );
+    });
+  });
+
+  describe("routes", () => {
+    it("POST upserts (201), GET lists, DELETE removes (204)", async () => {
+      const created = await adminApp.request(
+        `/agents/${agentA}/marketplaces`,
+        json(tokenA, {
+          name: "shipwright",
+          source: "app-vitals/shipwright",
+          ref: "main",
+        }),
+      );
+      expect(created.status).toBe(201);
+      const { marketplace } = await created.json();
+      expect(marketplace).toMatchObject({
+        agentId: agentA,
+        name: "shipwright",
+        source: "app-vitals/shipwright",
+        ref: "main",
+      });
+
+      const listed = await adminApp.request(
+        `/agents/${agentA}/marketplaces`,
+        get(ADMIN_KEY),
+      );
+      expect(listed.status).toBe(200);
+      expect((await listed.json()).marketplaces).toHaveLength(1);
+
+      const del = await adminApp.request(
+        `/agents/${agentA}/marketplaces/${marketplace.id}`,
+        json(tokenA, undefined, "DELETE"),
+      );
+      expect(del.status).toBe(204);
+      expect(await service.list(agentA)).toEqual([]);
+    });
+
+    it("platform admin key can write and read any agent", async () => {
+      const res = await adminApp.request(
+        `/agents/${agentB}/marketplaces`,
+        json(ADMIN_KEY, { name: "m", source: "o/r" }),
+      );
+      expect(res.status).toBe(201);
+    });
+
+    it("invalid source returns 422 and writes nothing", async () => {
+      for (const source of [
+        "http://x.com/o/r",
+        "not-a-source",
+        "git@github.com:o/r.git",
+        "",
+      ]) {
+        const res = await adminApp.request(
+          `/agents/${agentA}/marketplaces`,
+          json(tokenA, { name: "m", source }),
+        );
+        expect(res.status).toBe(422);
+      }
+      expect(await service.list(agentA)).toEqual([]);
+    });
+
+    it("deleting another agent's row returns 404 and leaves it", async () => {
+      const row = await service.upsert(agentB, { name: "m", source: "o/r" });
+      const res = await adminApp.request(
+        `/agents/${agentA}/marketplaces/${row.id}`,
+        json(tokenA, undefined, "DELETE"),
+      );
+      expect(res.status).toBe(404);
+      expect(await service.list(agentB)).toHaveLength(1);
+    });
+
+    it("another agent's key is 403 on every method; no credential is 401", async () => {
+      const row = await service.upsert(agentA, { name: "m", source: "o/r" });
+      const post = await adminApp.request(
+        `/agents/${agentA}/marketplaces`,
+        json(tokenB, { name: "x", source: "o/r" }),
+      );
+      const list = await adminApp.request(
+        `/agents/${agentA}/marketplaces`,
+        get(tokenB),
+      );
+      const del = await adminApp.request(
+        `/agents/${agentA}/marketplaces/${row.id}`,
+        json(tokenB, undefined, "DELETE"),
+      );
+      expect([post.status, list.status, del.status]).toEqual([403, 403, 403]);
+      expect(
+        (await adminApp.request(`/agents/${agentA}/marketplaces`)).status,
+      ).toBe(401);
+      expect(await service.list(agentA)).toHaveLength(1);
+    });
+  });
+
+  describe("GET /agents/:id/config", () => {
+    it("includes marketplaces: [] when none", async () => {
+      const res = await runtimeApp.request(`/${agentA}/config`, get(tokenA));
+      expect(res.status).toBe(200);
+      expect((await res.json()).marketplaces).toEqual([]);
+    });
+
+    it("includes name/source/ref for the agent's own rows only", async () => {
+      await service.upsert(agentA, { name: "one", source: "o/r", ref: "v1" });
+      await service.upsert(agentA, {
+        name: "two",
+        source: "https://h.example/o/r",
+      });
+      await service.upsert(agentB, { name: "theirs", source: "o/x" });
+      const res = await runtimeApp.request(`/${agentA}/config`, get(tokenA));
+      expect(res.status).toBe(200);
+      expect((await res.json()).marketplaces).toEqual([
+        { name: "one", source: "o/r", ref: "v1" },
+        { name: "two", source: "https://h.example/o/r", ref: null },
+      ]);
+    });
+  });
+});

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

@@ -0,0 +1,82 @@
+/**
+ * admin/src/agent-marketplaces.integration.test.ts
+ * Integration tests for the AgentMarketplace model 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 { createAdminPrismaClient } from "./prisma-client.ts";
+
+const TEST_DB = process.env.DATABASE_URL_ADMIN_TEST;
+
+const describeOrSkip = TEST_DB ? describe : describe.skip;
+
+describeOrSkip("AgentMarketplace (integration)", () => {
+  let prisma: PrismaClient;
+
+  beforeEach(async () => {
+    prisma = createAdminPrismaClient(TEST_DB as string);
+    await prisma.agentMarketplace.deleteMany();
+    await prisma.agentPlugin.deleteMany();
+    await prisma.agentToken.deleteMany();
+    await prisma.agentCronJob.deleteMany();
+    await prisma.agentTool.deleteMany();
+    await prisma.agentEnv.deleteMany();
+    await prisma.agent.deleteMany();
+  });
+
+  afterEach(async () => {
+    await prisma.$disconnect();
+  });
+
+  async function createAgent(): Promise<string> {
+    return (await prisma.agent.create({ data: { name: "Test Agent" } })).id;
+  }
+
+  it("inserts a row and reads it back", async () => {
+    const agentId = await createAgent();
+    const created = await prisma.agentMarketplace.create({
+      data: {
+        agentId,
+        name: "shipwright",
+        source: "github:app-vitals/shipwright",
+      },
+    });
+    const found = await prisma.agentMarketplace.findUnique({
+      where: { id: created.id },
+    });
+    expect(found?.agentId).toBe(agentId);
+    expect(found?.name).toBe("shipwright");
+    expect(found?.source).toBe("github:app-vitals/shipwright");
+    expect(found?.ref).toBeNull();
+    expect(found?.createdAt).toBeInstanceOf(Date);
+    expect(found?.updatedAt).toBeInstanceOf(Date);
+  });
+
+  it("rejects a duplicate (agentId, name)", async () => {
+    const agentId = await createAgent();
+    await prisma.agentMarketplace.create({
+      data: { agentId, name: "dup", source: "a" },
+    });
+    await expect(
+      (async () =>
+        prisma.agentMarketplace.create({
+          data: { agentId, name: "dup", source: "b", ref: "main" },
+        }))(),
+    ).rejects.toThrow();
+  });
+
+  it("cascades when the agent is deleted", async () => {
+    const agentId = await createAgent();
+    await prisma.agentMarketplace.create({
+      data: { agentId, name: "m1", source: "a" },
+    });
+    await prisma.agentMarketplace.create({
+      data: { agentId, name: "m2", source: "b", ref: "v1" },
+    });
+    await prisma.agent.delete({ where: { id: agentId } });
+    expect(await prisma.agentMarketplace.count({ where: { agentId } })).toBe(0);
+  });
+});

package/src/agent-marketplaces.ts

@@ -0,0 +1,120 @@
+/**
+ * admin/src/agent-marketplaces.ts
+ * AgentMarketplaceService — CRUD for remote Claude Code plugin marketplaces
+ * per agent.
+ *
+ * A marketplace is identified by `name` (the name plugins reference after the
+ * "@" in "<plugin>@<marketplace>") and points at a `source`: a GitHub
+ * "owner/repo" or an https git URL, optionally pinned to a `ref`. The unique
+ * constraint on [agentId, name] makes two versions of one marketplace
+ * impossible; upsert() re-points an existing name.
+ *
+ * Input is validated here (422) rather than in the Zod request schema, which
+ * would answer 400: `source` and `ref` end up as arguments to `git`/`claude`
+ * in the runtime, so anything that could be read as an option, a local path,
+ * or a credential-bearing URL is refused.
+ */
+
+import type {
+  AgentMarketplace,
+  PrismaClient,
+} from "../prisma/client/client.ts";
+import { NotFoundError, UnprocessableEntityError } from "./errors.ts";
+
+export type { AgentMarketplace };
+
+const GITHUB_SHORTHAND =
+  /^[A-Za-z0-9_][A-Za-z0-9_.-]*\/[A-Za-z0-9_][A-Za-z0-9_.-]*$/;
+const NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const REF = /^[A-Za-z0-9_][A-Za-z0-9_./-]*$/;
+const HOST = /^[A-Za-z0-9][A-Za-z0-9.-]*$/;
+
+/** Throws UnprocessableEntityError unless `source` is `owner/repo` or an https git URL. */
+export function validateMarketplaceSource(source: string): void {
+  if (GITHUB_SHORTHAND.test(source)) return;
+  if (source.startsWith("https://") && !/\s/.test(source)) {
+    try {
+      const url = new URL(source);
+      if (
+        url.protocol === "https:" &&
+        HOST.test(url.hostname) &&
+        url.username === "" &&
+        url.password === "" &&
+        url.pathname.length > 1
+      ) {
+        return;
+      }
+    } catch {
+      // fall through to the 422 below
+    }
+  }
+  throw new UnprocessableEntityError(
+    "source must be a GitHub 'owner/repo' or an https git URL without credentials",
+  );
+}
+
+/** Throws UnprocessableEntityError unless `name` is a plain marketplace name. */
+export function validateMarketplaceName(name: string): void {
+  if (!NAME.test(name)) {
+    throw new UnprocessableEntityError(
+      "name must start with a letter or digit and contain only letters, digits, '.', '_' and '-'",
+    );
+  }
+}
+
+/** Throws UnprocessableEntityError for a ref that is not a plain branch, tag or sha. */
+export function validateMarketplaceRef(ref: string | null | undefined): void {
+  if (ref === undefined || ref === null) return;
+  if (!REF.test(ref) || ref.includes("..")) {
+    throw new UnprocessableEntityError(
+      "ref must be a plain branch, tag or sha",
+    );
+  }
+}
+
+export class AgentMarketplaceService {
+  constructor(private prisma: PrismaClient) {}
+
+  /** List all marketplaces for a given agent, ordered by createdAt. */
+  async list(agentId: string): Promise<AgentMarketplace[]> {
+    return this.prisma.agentMarketplace.findMany({
+      where: { agentId },
+      orderBy: { createdAt: "asc" },
+    });
+  }
+
+  /**
+   * Add a marketplace for the agent, or re-point the existing one with the
+   * same name at a new source/ref. Throws UnprocessableEntityError on invalid
+   * input.
+   */
+  async upsert(
+    agentId: string,
+    input: { name: string; source: string; ref?: string | null },
+  ): Promise<AgentMarketplace> {
+    const { name, source } = input;
+    const ref = input.ref ?? null;
+    validateMarketplaceName(name);
+    validateMarketplaceSource(source);
+    validateMarketplaceRef(ref);
+    return this.prisma.agentMarketplace.upsert({
+      where: { agentId_name: { agentId, name } },
+      create: { agentId, name, source, ref },
+      update: { source, ref },
+    });
+  }
+
+  /**
+   * Remove a marketplace by ID. Verifies agentId ownership before deleting.
+   * Throws NotFoundError if the id doesn't exist or belongs to another agent.
+   */
+  async remove(agentId: string, marketplaceId: string): Promise<void> {
+    const existing = await this.prisma.agentMarketplace.findUnique({
+      where: { id: marketplaceId },
+    });
+    if (!existing || existing.agentId !== agentId) {
+      throw new NotFoundError(`marketplace ${marketplaceId} not found`);
+    }
+    await this.prisma.agentMarketplace.delete({ where: { id: marketplaceId } });
+  }
+}