Add multi-repository setup support

Author: dutifulbob

apps/api/src/app.ts

@@ -1,7 +1,7 @@
 import cors from "@fastify/cors";
 import Fastify, { type FastifyInstance } from "fastify";
 import fastifyRawBody from "fastify-raw-body";
-import { loadVergeConfig } from "@verge/core";
+import { loadVergeConfigs } from "@verge/core";
 import { migrateDatabase, syncRepositoryConfiguration, type DatabaseConnection } from "@verge/db";
 
 import type { ApiContext } from "./context.js";
@@ -58,22 +58,22 @@ export const bootstrapApiApp = async (
   connection: DatabaseConnection,
   input?: {
     configPath?: string;
+    configPaths?: string[];
   },
 ): Promise<FastifyInstance> => {
-  const config = await loadVergeConfig(input);
+  const configs = await loadVergeConfigs(input);
+  const seenRepositorySlugs = new Set<string>();
 
   await migrateDatabase(connection.db);
-  await syncRepositoryConfiguration(connection.db, config.repository, config.steps);
+  for (const config of configs) {
+    if (seenRepositorySlugs.has(config.repository.slug)) {
+      throw new Error(`Duplicate repository slug: ${config.repository.slug}`);
+    }
+    seenRepositorySlugs.add(config.repository.slug);
+    await syncRepositoryConfiguration(connection.db, config.repository, config.steps);
+  }
 
   return createApiApp({
     connection,
-    repositorySlug: config.repository.slug,
-    repositoryDefinition: {
-      slug: config.repository.slug,
-      areas: config.repository.areas.map((area) => ({
-        key: area.key,
-        pathPrefixes: area.pathPrefixes,
-      })),
-    },
   });
 };

apps/api/src/context.ts

@@ -2,12 +2,4 @@ import type { DatabaseConnection } from "@verge/db";
 
 export type ApiContext = {
   connection: DatabaseConnection;
-  repositorySlug: string;
-  repositoryDefinition: {
-    slug: string;
-    areas: Array<{
-      key: string;
-      pathPrefixes: string[];
-    }>;
-  };
 };

apps/api/src/planning.ts

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 
 import { computeStepConfigFingerprint, planStepRuns } from "@verge/core";
+import type { RepositoryDefinition } from "@verge/contracts";
 import {
   cloneCompletedProcessesFromCheckpoint,
   cloneStepRunForReuse,
@@ -15,7 +16,6 @@ import {
   type DatabaseExecutor,
 } from "@verge/db";
 
-import type { ApiContext } from "./context.js";
 import { parseStringArray } from "./utils.js";
 
 const interruptPendingProcessesForStepRun = async (
@@ -59,7 +59,7 @@ export const createPlannedRun = async (
     slug: string;
     root_path: string;
   },
-  repositoryDefinition: ApiContext["repositoryDefinition"],
+  repositoryDefinition: Pick<RepositoryDefinition, "slug" | "areas">,
   input: {
     trigger: "manual" | "push" | "pull_request";
     commitSha: string;

apps/api/src/routes/public.ts

@@ -3,11 +3,13 @@ import type { FastifyInstance } from "fastify";
 import { createManualRunInputSchema, runListQuerySchema } from "@verge/contracts";
 import {
   getCommitDetail,
+  getRepositoryDefinitionBySlug,
   getPullRequestDetail,
   getRepositoryBySlug,
   getRepositoryHealth,
   getRunDetail,
   getStepRunDetail,
+  listRepositories,
   listRepositoryRuns,
   listStepSpecSummaries,
 } from "@verge/db";
@@ -18,19 +20,25 @@ import { createPlannedRun } from "../planning.js";
 export const registerPublicRoutes = (app: FastifyInstance, context: ApiContext): void => {
   app.get("/healthz", async () => ({ ok: true }));
 
-  app.get("/step-specs", async () =>
-    listStepSpecSummaries(context.connection.db, context.repositorySlug),
+  app.get("/repositories", async () => listRepositories(context.connection.db));
+
+  app.get("/repositories/:repo/step-specs", async (request) =>
+    listStepSpecSummaries(context.connection.db, (request.params as { repo: string }).repo),
   );
 
   app.post("/runs/manual", async (request, reply) => {
     const input = createManualRunInputSchema.parse(request.body);
     const repository = await getRepositoryBySlug(context.connection.db, input.repositorySlug);
+    const repositoryDefinition = await getRepositoryDefinitionBySlug(
+      context.connection.db,
+      input.repositorySlug,
+    );
 
-    if (!repository) {
+    if (!repository || !repositoryDefinition) {
       return reply.code(404).send({ message: "Repository not found" });
     }
 
-    return createPlannedRun(context.connection.db, repository, context.repositoryDefinition, {
+    return createPlannedRun(context.connection.db, repository, repositoryDefinition, {
       trigger: "manual",
       commitSha: input.commitSha,
       ...(input.changedFiles ? { changedFiles: input.changedFiles } : {}),

apps/api/src/routes/webhooks.ts

@@ -4,13 +4,22 @@ import {
   githubWebhookPullRequestPayloadSchema,
   githubWebhookPushPayloadSchema,
 } from "@verge/contracts";
-import { createEventIngestion, getRepositoryBySlug } from "@verge/db";
+import {
+  createEventIngestion,
+  getRepositoryBySlug,
+  getRepositoryDefinitionBySlug,
+} from "@verge/db";
 
 import type { ApiContext } from "../context.js";
 import { createPlannedRun } from "../planning.js";
 import { collectChangedFilesFromPushPayload, validateGitHubSignature } from "../utils.js";
 
 export const registerWebhookRoutes = (app: FastifyInstance, context: ApiContext): void => {
+  const deriveRepositorySlug = (fullName: string): string => {
+    const segments = fullName.split("/");
+    return segments[segments.length - 1] ?? fullName;
+  };
+
   app.post("/webhooks/github", { config: { rawBody: true } }, async (request, reply) => {
     const deliveryId = String(request.headers["x-github-delivery"] ?? "");
     const eventName = String(request.headers["x-github-event"] ?? "");
@@ -34,38 +43,75 @@ export const registerWebhookRoutes = (app: FastifyInstance, context: ApiContext)
       return reply.code(401).send({ message: "Invalid webhook signature" });
     }
 
-    const repository = await getRepositoryBySlug(context.connection.db, context.repositorySlug);
-    if (!repository) {
-      return reply.code(404).send({ message: "Repository not found" });
-    }
-
-    const result = await context.connection.db.transaction().execute(async (trx) => {
-      const { eventIngestion, inserted } = await createEventIngestion(trx, {
-        repositoryId: repository.id,
-        source: "github",
-        deliveryId,
-        eventName,
-        payload: request.body,
-      });
+    if (eventName === "push") {
+      const payload = githubWebhookPushPayloadSchema.parse(request.body);
+      const repositorySlug = deriveRepositorySlug(payload.repository.full_name);
+      const repository = await getRepositoryBySlug(context.connection.db, repositorySlug);
+      const repositoryDefinition = await getRepositoryDefinitionBySlug(
+        context.connection.db,
+        repositorySlug,
+      );
 
-      if (!inserted) {
-        return { duplicate: true } as const;
+      if (!repository || !repositoryDefinition) {
+        return reply.code(404).send({ message: "Repository not found" });
       }
 
-      if (eventName === "push") {
-        const payload = githubWebhookPushPayloadSchema.parse(request.body);
-        await createPlannedRun(trx, repository, context.repositoryDefinition, {
+      const result = await context.connection.db.transaction().execute(async (trx) => {
+        const { eventIngestion, inserted } = await createEventIngestion(trx, {
+          repositoryId: repository.id,
+          source: "github",
+          deliveryId,
+          eventName,
+          payload: request.body,
+        });
+
+        if (!inserted) {
+          return { duplicate: true } as const;
+        }
+
+        await createPlannedRun(trx, repository, repositoryDefinition, {
           trigger: "push",
           commitSha: payload.after,
           branch: payload.ref.replace("refs/heads/", ""),
           changedFiles: collectChangedFilesFromPushPayload(payload),
           eventIngestionId: eventIngestion.id,
         });
         return { duplicate: false, trigger: "push" } as const;
+      });
+
+      if (result.duplicate) {
+        return reply.code(202).send({ ok: true, duplicate: true });
       }
 
-      if (eventName === "pull_request") {
-        const payload = githubWebhookPullRequestPayloadSchema.parse(request.body);
+      return reply.code(202).send({ ok: true, ...result });
+    }
+
+    if (eventName === "pull_request") {
+      const payload = githubWebhookPullRequestPayloadSchema.parse(request.body);
+      const repositorySlug = deriveRepositorySlug(payload.repository.full_name);
+      const repository = await getRepositoryBySlug(context.connection.db, repositorySlug);
+      const repositoryDefinition = await getRepositoryDefinitionBySlug(
+        context.connection.db,
+        repositorySlug,
+      );
+
+      if (!repository || !repositoryDefinition) {
+        return reply.code(404).send({ message: "Repository not found" });
+      }
+
+      const result = await context.connection.db.transaction().execute(async (trx) => {
+        const { eventIngestion, inserted } = await createEventIngestion(trx, {
+          repositoryId: repository.id,
+          source: "github",
+          deliveryId,
+          eventName,
+          payload: request.body,
+        });
+
+        if (!inserted) {
+          return { duplicate: true } as const;
+        }
+
         if (!["opened", "reopened", "synchronize"].includes(payload.action)) {
           return {
             duplicate: false,
@@ -74,7 +120,7 @@ export const registerWebhookRoutes = (app: FastifyInstance, context: ApiContext)
           } as const;
         }
 
-        await createPlannedRun(trx, repository, context.repositoryDefinition, {
+        await createPlannedRun(trx, repository, repositoryDefinition, {
           trigger: "pull_request",
           commitSha: payload.pull_request.head.sha,
           branch: payload.pull_request.head.ref,
@@ -83,15 +129,15 @@ export const registerWebhookRoutes = (app: FastifyInstance, context: ApiContext)
           eventIngestionId: eventIngestion.id,
         });
         return { duplicate: false, trigger: "pull_request" } as const;
-      }
+      });
 
-      return { duplicate: false, ignored: true, eventName } as const;
-    });
+      if (result.duplicate) {
+        return reply.code(202).send({ ok: true, duplicate: true });
+      }
 
-    if (result.duplicate) {
-      return reply.code(202).send({ ok: true, duplicate: true });
+      return reply.code(202).send({ ok: true, ...result });
     }
 
-    return reply.code(202).send({ ok: true, ...result });
+    return reply.code(202).send({ ok: true, ignored: true, eventName });
   });
 };