feat(webapp,cli): archive inactive dev branches at the limit

Mono-RevId: 81e6ee9f8902eea13a49f3e491005b7e22abf7f5

Author: carderne

.changeset/auto-archive-dev-branches.md

@@ -0,0 +1,6 @@
+---
+"trigger.dev": patch
+"@trigger.dev/core": patch
+---
+
+Automatically archive up to three inactive development branches when creating a branch at the plan limit. Connected and recently active branches remain protected, and the CLI reports which branches were archived.

apps/webapp/app/routes/api.v1.projects.$projectRef.branches.ts

@@ -163,7 +163,10 @@ export async function action({ request, params }: ActionFunctionArgs) {
     return json({ error: result.error }, { status: 400 });
   }
 
-  return json({ id: result.branch.id });
+  return json({
+    id: result.branch.id,
+    autoArchivedBranches: result.autoArchivedBranches,
+  });
 }
 
 export async function loader({ request, params }: LoaderFunctionArgs) {

apps/webapp/app/services/archiveBranch.server.ts

@@ -88,7 +88,7 @@ export class ArchiveBranchService {
       const shortcode = slug;
 
       const updatedBranch = await this.#prismaClient.runtimeEnvironment.update({
-        where: { id: environmentId },
+        where: { id: environmentId, archivedAt: null },
         data: { archivedAt: new Date(), slug, shortcode },
       });
 

apps/webapp/app/services/upsertBranch.server.ts

@@ -13,6 +13,8 @@ import {
   rootEnvironmentWhere,
   toBranchableEnvironmentType,
 } from "~/utils/branchableEnvironment";
+import { devPresence } from "~/presenters/v3/DevPresence.server";
+import { ArchiveBranchService } from "./archiveBranch.server";
 import { logger } from "./logger.server";
 import { getCurrentPlan, getLimit } from "./platform.v3.server";
 import { type z } from "zod";
@@ -24,6 +26,12 @@ import {
 } from "~/v3/services/billingLimit/getInitialEnvPauseStateForBillingLimit.server";
 
 type CreateBranchOptions = z.infer<typeof CreateBranchOptions>;
+type OrgFilter =
+  | { type: "userMembership"; userId: string }
+  | { type: "orgId"; organizationId: string };
+
+const DEV_BRANCH_STALE_AFTER_MS = 60 * 60 * 1000;
+const DEV_BRANCH_AUTO_ARCHIVE_LIMIT = 3;
 
 export class UpsertBranchService {
   #prismaClient: PrismaClient;
@@ -37,9 +45,7 @@ export class UpsertBranchService {
     // Currently authorization checks are spread across the controller/route layer and the service layer. Often we check in multiple places for org/project membership.
     // Ideally we would take care of both the authentication and authorization checks in the controllers and routes.
     // That would unify how we handle authorization and org/project membership checks. Also it would make the service layer queries simpler.
-    orgFilter:
-      | { type: "userMembership"; userId: string }
-      | { type: "orgId"; organizationId: string },
+    orgFilter: OrgFilter,
     { projectId, env, branchName, git }: CreateBranchOptions
   ) {
     const parentEnvType = toBranchableEnvironmentType(env);
@@ -120,14 +126,34 @@ export class UpsertBranchService {
         };
       }
 
-      const limits = await checkBranchLimit({
+      let limits = await checkBranchLimit({
         prisma: this.#prismaClient,
         organizationId: parentEnvironment.organization.id,
         projectId: parentEnvironment.project.id,
         type: parentEnvType,
         userId,
         newBranchName: sanitizedBranchName,
       });
+      const autoArchivedBranches = limits.isAtLimit
+        ? await autoArchiveStaleDevBranches({
+            prisma: this.#prismaClient,
+            orgFilter,
+            parentEnvironment,
+            userId,
+            limit: limits.limit,
+          })
+        : [];
+
+      if (autoArchivedBranches.length > 0) {
+        limits = await checkBranchLimit({
+          prisma: this.#prismaClient,
+          organizationId: parentEnvironment.organization.id,
+          projectId: parentEnvironment.project.id,
+          type: parentEnvType,
+          userId,
+          newBranchName: sanitizedBranchName,
+        });
+      }
 
       if (limits.isAtLimit) {
         // DEVELOPMENT has no upgrade path, so only PREVIEW mentions upgrading.
@@ -223,6 +249,7 @@ export class UpsertBranchService {
         branch,
         organization: parentEnvironment.organization,
         project: parentEnvironment.project,
+        autoArchivedBranches,
       };
     } catch (e) {
       logger.error("CreateBranchService error", { error: e });
@@ -234,6 +261,84 @@ export class UpsertBranchService {
   }
 }
 
+async function autoArchiveStaleDevBranches({
+  prisma,
+  orgFilter,
+  parentEnvironment,
+  userId,
+  limit,
+}: {
+  prisma: PrismaClient;
+  orgFilter: OrgFilter;
+  parentEnvironment: {
+    id: string;
+    type: string;
+    orgMemberId: string | null;
+    project: { id: string };
+  };
+  userId?: string;
+  limit: number;
+}) {
+  if (parentEnvironment.type !== "DEVELOPMENT" || !userId) return [];
+
+  try {
+    const branches = await prisma.runtimeEnvironment.findMany({
+      where: {
+        parentEnvironmentId: parentEnvironment.id,
+        archivedAt: null,
+      },
+      select: { id: true, branchName: true, createdAt: true },
+    });
+    const recentBranches = await devPresence.getRecentBranchIds(
+      userId,
+      parentEnvironment.project.id
+    );
+    const connectedBranches = await devPresence.isConnectedMany(
+      branches.map((branch) => branch.id)
+    );
+    const staleBefore = Date.now() - DEV_BRANCH_STALE_AFTER_MS;
+    const candidates = branches
+      .filter((branch) => {
+        if (connectedBranches.get(branch.id)) return false;
+        const lastActivity = recentBranches.get(branch.id)?.getTime() ?? branch.createdAt.getTime();
+        return lastActivity <= staleBefore;
+      })
+      .sort((a, b) => {
+        const aActivity = recentBranches.get(a.id)?.getTime() ?? a.createdAt.getTime();
+        const bActivity = recentBranches.get(b.id)?.getTime() ?? b.createdAt.getTime();
+        return aActivity - bActivity;
+      })
+      .slice(0, DEV_BRANCH_AUTO_ARCHIVE_LIMIT);
+
+    const used = await prisma.runtimeEnvironment.count({
+      where: {
+        projectId: parentEnvironment.project.id,
+        orgMemberId: parentEnvironment.orgMemberId,
+        type: "DEVELOPMENT",
+        archivedAt: null,
+      },
+    });
+    if (used < limit) return [];
+
+    const archiveService = new ArchiveBranchService(prisma);
+    const results = await Promise.all(
+      candidates.map((candidate) => archiveService.call(orgFilter, { environmentId: candidate.id }))
+    );
+
+    return results.flatMap((result) =>
+      result.success && result.branch.branchName
+        ? [{ id: result.branch.id, branchName: result.branch.branchName }]
+        : []
+    );
+  } catch (error) {
+    logger.warn("Failed to auto-archive stale development branches", {
+      projectId: parentEnvironment.project.id,
+      error,
+    });
+    return [];
+  }
+}
+
 export async function checkBranchLimit({
   prisma,
   organizationId,

apps/webapp/test/devBranchServices.test.ts

@@ -10,6 +10,17 @@ import {
   uniqueId,
 } from "./fixtures/environmentVariablesFixtures";
 
+const devPresence = vi.hoisted(() => ({
+  getRecentBranchIds: vi.fn(),
+  isConnectedMany: vi.fn(),
+}));
+
+vi.mock("~/presenters/v3/DevPresence.server", () => ({ devPresence }));
+vi.mock("~/services/platform.v3.server", () => ({
+  getCurrentPlan: vi.fn().mockResolvedValue(null),
+  getLimit: vi.fn().mockResolvedValue(5),
+}));
+
 vi.setConfig({ testTimeout: 60_000 });
 
 async function createDevRoot(
@@ -137,6 +148,48 @@ describe("UpsertBranchService — DEVELOPMENT parent", () => {
     expect(firstRetry.branch.id).toBe(firstResult.branch.id);
   });
 
+  postgresTest(
+    "archives up to three stale branches when creating at the limit",
+    async ({ prisma }) => {
+      const { organization, project, user, orgMember } =
+        await createTestOrgProjectWithMember(prisma);
+      const devRoot = await createDevRoot(prisma, project.id, organization.id, orgMember.id);
+      const service = new UpsertBranchService(prisma);
+      const orgFilter = { type: "userMembership" as const, userId: user.id };
+
+      for (const branchName of ["old-1", "old-2", "old-3", "old-4"]) {
+        expect(
+          (
+            await service.call(orgFilter, {
+              projectId: project.id,
+              env: "development",
+              branchName,
+            })
+          ).success
+        ).toBe(true);
+      }
+
+      await prisma.runtimeEnvironment.updateMany({
+        where: { parentEnvironmentId: devRoot.id },
+        data: { createdAt: new Date(Date.now() - 2 * 60 * 60 * 1000) },
+      });
+      devPresence.getRecentBranchIds.mockResolvedValue(new Map());
+      devPresence.isConnectedMany.mockImplementation(
+        async (ids: string[]) => new Map(ids.map((id) => [id, false]))
+      );
+
+      const result = await service.call(orgFilter, {
+        projectId: project.id,
+        env: "development",
+        branchName: "new-branch",
+      });
+
+      expect(result.success).toBe(true);
+      if (!result.success) return;
+      expect(result.autoArchivedBranches).toHaveLength(3);
+    }
+  );
+
   postgresTest(
     "rejects an invalid branch name without touching the database",
     async ({ prisma }) => {

packages/cli-v3/src/commands/dev.ts

@@ -312,6 +312,13 @@ async function startDev(options: StartDevOptions) {
         logger.error(`Failed to use branch "${branch}": ${upsertResult.error}`);
         process.exit(1);
       }
+
+      if (upsertResult.data.autoArchivedBranches?.length) {
+        const archivedNames = upsertResult.data.autoArchivedBranches
+          .map((archivedBranch) => `"${archivedBranch.branchName}"`)
+          .join(", ");
+        log.warn(`Archived inactive dev branches to make room: ${archivedNames}`);
+      }
     }
 
     // eslint-disable-next-line no-inner-declarations

packages/core/src/v3/schemas/api.ts

@@ -751,6 +751,14 @@ export type UpsertBranchRequestBody = z.infer<typeof UpsertBranchRequestBody>;
 
 export const UpsertBranchResponseBody = z.object({
   id: z.string(),
+  autoArchivedBranches: z
+    .array(
+      z.object({
+        id: z.string(),
+        branchName: z.string(),
+      })
+    )
+    .optional(),
 });
 
 export type UpsertBranchResponseBody = z.infer<typeof UpsertBranchResponseBody>;