Add list deploys tool

ericallam · ericallam · commit cfdcd9d15537 · 2025-08-12T15:42:54.000+01:00
diff --git a/apps/webapp/app/routes/api.v1.deployments.ts b/apps/webapp/app/routes/api.v1.deployments.ts
@@ -1,10 +1,13 @@
 import { ActionFunctionArgs, json } from "@remix-run/server-runtime";
 import {
+  ApiDeploymentListSearchParams,
   InitializeDeploymentRequestBody,
   InitializeDeploymentResponseBody,
 } from "@trigger.dev/core/v3";
+import { $replica } from "~/db.server";
 import { authenticateApiRequest } from "~/services/apiAuth.server";
 import { logger } from "~/services/logger.server";
+import { createLoaderApiRoute } from "~/services/routeBuilders/apiBuilder.server";
 import { ServiceValidationError } from "~/v3/services/baseService.server";
 import { InitializeDeploymentService } from "~/v3/services/initializeDeployment.server";
 
@@ -60,3 +63,117 @@ export async function action({ request, params }: ActionFunctionArgs) {
     }
   }
 }
+
+export const loader = createLoaderApiRoute(
+  {
+    searchParams: ApiDeploymentListSearchParams,
+    allowJWT: true,
+    corsStrategy: "none",
+    authorization: {
+      action: "read",
+      resource: () => ({ deployments: "list" }),
+      superScopes: ["read:deployments", "read:all", "admin"],
+    },
+    findResource: async () => 1, // This is a dummy function, we don't need to find a resource
+  },
+  async ({ searchParams, authentication }) => {
+    const limit = Math.max(Math.min(searchParams["page[size]"] ?? 20, 100), 5);
+
+    const afterDeployment = searchParams["page[after]"]
+      ? await $replica.workerDeployment.findFirst({
+          where: {
+            friendlyId: searchParams["page[after]"],
+            environmentId: authentication.environment.id,
+          },
+        })
+      : undefined;
+
+    const deployments = await $replica.workerDeployment.findMany({
+      where: {
+        environmentId: authentication.environment.id,
+        ...(afterDeployment ? { id: { lt: afterDeployment.id } } : {}),
+        ...getCreatedAtFilter(searchParams),
+        ...(searchParams.status ? { status: searchParams.status } : {}),
+      },
+      orderBy: {
+        id: "desc",
+      },
+      take: limit + 1,
+    });
+
+    const hasMore = deployments.length > limit;
+    const nextCursor = hasMore ? deployments[limit - 1].friendlyId : undefined;
+    const data = hasMore ? deployments.slice(0, limit) : deployments;
+
+    return json({
+      data: data.map((deployment) => ({
+        id: deployment.friendlyId,
+        createdAt: deployment.createdAt,
+        shortCode: deployment.shortCode,
+        version: deployment.version.toString(),
+        runtime: deployment.runtime,
+        runtimeVersion: deployment.runtimeVersion,
+        status: deployment.status,
+        deployedAt: deployment.deployedAt,
+        git: deployment.git,
+        error: deployment.errorData ?? undefined,
+      })),
+      pagination: {
+        next: nextCursor,
+      },
+    });
+  }
+);
+
+import parseDuration from "parse-duration";
+
+function getCreatedAtFilter(searchParams: ApiDeploymentListSearchParams) {
+  if (searchParams.period) {
+    const duration = parseDuration(searchParams.period, "ms");
+
+    if (!duration) {
+      throw new ServiceValidationError(
+        `Invalid search query parameter: period=${searchParams.period}`,
+        400
+      );
+    }
+
+    return {
+      createdAt: {
+        gte: new Date(Date.now() - duration),
+        lte: new Date(),
+      },
+    };
+  }
+
+  if (searchParams.from && searchParams.to) {
+    const fromDate = safeDateFromString(searchParams.from, "from");
+    const toDate = safeDateFromString(searchParams.to, "to");
+
+    return {
+      createdAt: {
+        gte: fromDate,
+        lte: toDate,
+      },
+    };
+  }
+
+  if (searchParams.from) {
+    const fromDate = safeDateFromString(searchParams.from, "from");
+    return {
+      createdAt: {
+        gte: fromDate,
+      },
+    };
+  }
+
+  return {};
+}
+
+function safeDateFromString(value: string, paramName: string) {
+  const date = new Date(value);
+  if (isNaN(date.getTime())) {
+    throw new ServiceValidationError(`Invalid search query parameter: ${paramName}=${value}`, 400);
+  }
+  return date;
+}
diff --git a/apps/webapp/app/services/authorization.server.ts b/apps/webapp/app/services/authorization.server.ts
@@ -1,6 +1,6 @@
 export type AuthorizationAction = "read" | "write" | string; // Add more actions as needed
 
-const ResourceTypes = ["tasks", "tags", "runs", "batch", "waitpoints"] as const;
+const ResourceTypes = ["tasks", "tags", "runs", "batch", "waitpoints", "deployments"] as const;
 
 export type AuthorizationResources = {
   [key in (typeof ResourceTypes)[number]]?: string | string[];
diff --git a/packages/cli-v3/src/commands/mcp.ts b/packages/cli-v3/src/commands/mcp.ts
@@ -16,6 +16,7 @@ import {
   registerGetRunDetailsTool,
   registerGetTasksTool,
   registerInitializeProjectTool,
+  registerListDeploymentsTool,
   registerListOrgsTool,
   registerListProjectsTool,
   registerListRunsTool,
@@ -112,6 +113,7 @@ export async function mcpCommand(options: McpCommandOptions) {
   registerListOrgsTool(context);
   registerCreateProjectTool(context);
   registerDeployTool(context);
+  registerListDeploymentsTool(context);
 
   await server.connect(transport);
 }
diff --git a/packages/cli-v3/src/mcp/tools.ts b/packages/cli-v3/src/mcp/tools.ts
@@ -1,4 +1,5 @@
 import {
+  ApiDeploymentListParams,
   GetOrgsResponseBody,
   GetProjectsResponseBody,
   MachinePresetName,
@@ -994,6 +995,100 @@ export function registerDeployTool(context: McpContext) {
   );
 }
 
+export function registerListDeploymentsTool(context: McpContext) {
+  context.server.registerTool(
+    "list_deployments",
+    {
+      description: "List deployments for a project",
+      inputSchema: {
+        projectRef: ProjectRefSchema,
+        configPath: z
+          .string()
+          .describe(
+            "The path to the trigger.config.ts file. Only used when the trigger.config.ts file is not at the root dir (like in a monorepo setup). If not provided, we will try to find the config file in the current working directory"
+          )
+          .optional(),
+        environment: z
+          .enum(["staging", "prod", "preview"])
+          .describe("The environment to list deployments for")
+          .default("prod"),
+        branch: z
+          .string()
+          .describe("The branch to trigger the task in, only used for preview environments")
+          .optional(),
+        ...ApiDeploymentListParams,
+      },
+    },
+    async ({
+      projectRef,
+      configPath,
+      environment,
+      branch,
+      cursor,
+      limit,
+      status,
+      from,
+      to,
+      period,
+    }) => {
+      context.logger?.log("calling list_deployments", {
+        projectRef,
+        configPath,
+        environment,
+        branch,
+        cursor,
+        limit,
+        status,
+        from,
+        to,
+        period,
+      });
+
+      const projectRefResult = await resolveExistingProjectRef(context, projectRef, configPath);
+
+      if (projectRefResult.status === "error") {
+        return respondWithError(projectRefResult.error);
+      }
+
+      const $projectRef = projectRefResult.projectRef;
+
+      context.logger?.log("list_deployments projectRefResult", { projectRefResult });
+
+      const auth = await mcpAuth({
+        server: context.server,
+        defaultApiUrl: context.options.apiUrl,
+        profile: context.options.profile,
+        context,
+      });
+
+      if (!auth.ok) {
+        return respondWithError(auth.error);
+      }
+
+      const apiClient = await createApiClientWithPublicJWT(auth, $projectRef, environment, [
+        "read:deployments",
+      ]);
+
+      if (!apiClient) {
+        return respondWithError("Failed to create API client with public JWT");
+      }
+
+      const result = await apiClient.listDeployments({
+        cursor: cursor,
+        limit,
+        status,
+        from,
+        to,
+        period,
+      });
+
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+      };
+    }
+  );
+}
+
 async function resolveCLIExec(context: McpContext, cwd: string): Promise<[string, string]> {
   // Lets first try to get the version of the CLI package
   const installedCLI = await tryResolveTriggerCLIPath(context, cwd);
diff --git a/packages/core/src/v3/apiClient/index.ts b/packages/core/src/v3/apiClient/index.ts
@@ -3,6 +3,9 @@ import { VERSION } from "../../version.js";
 import { generateJWT } from "../jwt.js";
 import {
   AddTagsRequestBody,
+  ApiDeploymentListOptions,
+  ApiDeploymentListResponseItem,
+  ApiDeploymentListSearchParams,
   BatchTaskRunExecutionResult,
   BatchTriggerTaskV3RequestBody,
   BatchTriggerTaskV3Response,
@@ -972,6 +975,41 @@ export class ApiClient {
     );
   }
 
+  listDeployments(options?: ApiDeploymentListOptions, requestOptions?: ZodFetchOptions) {
+    const searchParams = new URLSearchParams();
+
+    if (options?.status) {
+      searchParams.append("status", options.status);
+    }
+
+    if (options?.period) {
+      searchParams.append("period", options.period);
+    }
+
+    if (options?.from) {
+      searchParams.append("from", options.from);
+    }
+
+    if (options?.to) {
+      searchParams.append("to", options.to);
+    }
+
+    return zodfetchCursorPage(
+      ApiDeploymentListResponseItem,
+      `${this.baseUrl}/api/v1/deployments`,
+      {
+        query: searchParams,
+        after: options?.cursor,
+        limit: options?.limit,
+      },
+      {
+        method: "GET",
+        headers: this.#getHeaders(false),
+      },
+      mergeRequestOptions(this.defaultRequestOptions, requestOptions)
+    );
+  }
+
   async fetchStream<T>(
     runId: string,
     streamKey: string,
diff --git a/packages/core/src/v3/schemas/api.ts b/packages/core/src/v3/schemas/api.ts
@@ -1139,3 +1139,64 @@ export function timeoutError(timeout: Date) {
     message: `Waitpoint timed out at ${timeout.toISOString()}`,
   };
 }
+
+const ApiDeploymentCommonShape = {
+  from: z.string().describe("The date to start the search from, in ISO 8601 format").optional(),
+  to: z.string().describe("The date to end the search, in ISO 8601 format").optional(),
+  period: z.string().describe("The period to search within (e.g. 1d, 7d, 3h, etc.)").optional(),
+  status: z
+    .enum(["PENDING", "BUILDING", "DEPLOYING", "DEPLOYED", "FAILED", "CANCELED", "TIMED_OUT"])
+    .describe("Filter deployments that are in this status")
+    .optional(),
+};
+
+const ApiDeploymentListPaginationCursor = z
+  .string()
+  .describe("The deployment ID to start the search from, to get the next page")
+  .optional();
+
+const ApiDeploymentListPaginationLimit = z.coerce
+  .number()
+  .describe("The number of deployments to return, defaults to 20 (max 100)")
+  .optional();
+
+export const ApiDeploymentListParams = {
+  ...ApiDeploymentCommonShape,
+  cursor: ApiDeploymentListPaginationCursor,
+  limit: ApiDeploymentListPaginationLimit,
+};
+
+export const ApiDeploymentListOptions = z.object(ApiDeploymentListParams);
+
+export type ApiDeploymentListOptions = z.infer<typeof ApiDeploymentListOptions>;
+
+export const ApiDeploymentListSearchParams = z.object({
+  ...ApiDeploymentCommonShape,
+  "page[after]": ApiDeploymentListPaginationCursor,
+  "page[size]": ApiDeploymentListPaginationLimit,
+});
+
+export type ApiDeploymentListSearchParams = z.infer<typeof ApiDeploymentListSearchParams>;
+
+export const ApiDeploymentListResponseItem = z.object({
+  id: z.string(),
+  createdAt: z.coerce.date(),
+  shortCode: z.string(),
+  version: z.string(),
+  runtime: z.string(),
+  runtimeVersion: z.string(),
+  status: z.enum([
+    "PENDING",
+    "BUILDING",
+    "DEPLOYING",
+    "DEPLOYED",
+    "FAILED",
+    "CANCELED",
+    "TIMED_OUT",
+  ]),
+  deployedAt: z.coerce.date().optional(),
+  git: z.record(z.any()).optional(),
+  error: DeploymentErrorData.optional(),
+});
+
+export type ApiDeploymentListResponseItem = z.infer<typeof ApiDeploymentListResponseItem>;
