Add cancel_run tool

Author: ericallam

apps/webapp/app/routes/api.v2.runs.$runParam.cancel.ts

@@ -1,53 +1,47 @@
-import type { ActionFunctionArgs } from "@remix-run/server-runtime";
 import { json } from "@remix-run/server-runtime";
 import { z } from "zod";
-import { prisma } from "~/db.server";
-import { authenticateApiRequest } from "~/services/apiAuth.server";
+import { $replica } from "~/db.server";
+import { createActionApiRoute } from "~/services/routeBuilders/apiBuilder.server";
 import { CancelTaskRunService } from "~/v3/services/cancelTaskRun.server";
 
 const ParamsSchema = z.object({
   runParam: z.string(),
 });
 
-export async function action({ request, params }: ActionFunctionArgs) {
-  // Ensure this is a POST request
-  if (request.method.toUpperCase() !== "POST") {
-    return { status: 405, body: "Method Not Allowed" };
-  }
-
-  // Authenticate the request
-  const authenticationResult = await authenticateApiRequest(request);
-
-  if (!authenticationResult) {
-    return json({ error: "Invalid or Missing API Key" }, { status: 401 });
-  }
-
-  const parsed = ParamsSchema.safeParse(params);
-
-  if (!parsed.success) {
-    return json({ error: "Invalid or Missing run id" }, { status: 400 });
-  }
-
-  const { runParam } = parsed.data;
-
-  const taskRun = await prisma.taskRun.findUnique({
-    where: {
-      friendlyId: runParam,
-      runtimeEnvironmentId: authenticationResult.environment.id,
+const { action } = createActionApiRoute(
+  {
+    params: ParamsSchema,
+    allowJWT: true,
+    corsStrategy: "none",
+    authorization: {
+      action: "write",
+      resource: (params) => ({ runs: params.runParam }),
+      superScopes: ["write:runs", "admin"],
     },
-  });
+    findResource: async (params, auth) => {
+      return $replica.taskRun.findFirst({
+        where: {
+          friendlyId: params.runParam,
+          runtimeEnvironmentId: auth.environment.id,
+        },
+      });
+    },
+  },
+  async ({ resource }) => {
+    if (!resource) {
+      return json({ error: "Run not found" }, { status: 404 });
+    }
 
-  if (!taskRun) {
-    return json({ error: "Run not found" }, { status: 404 });
-  }
+    const service = new CancelTaskRunService();
 
-  const service = new CancelTaskRunService();
+    try {
+      await service.call(resource);
+    } catch (error) {
+      return json({ error: "Internal Server Error" }, { status: 500 });
+    }
 
-  try {
-    await service.call(taskRun);
-  } catch (error) {
-    return json({ error: "Internal Server Error" }, { status: 500 });
+    return json({ id: resource.friendlyId }, { status: 200 });
   }
+);
 
-  return json({ id: runParam }, { status: 200 });
-}
+export { action };

apps/webapp/app/services/routeBuilders/apiBuilder.server.ts

@@ -430,14 +430,26 @@ type ApiKeyActionRouteBuilderOptions<
   TParamsSchema extends AnyZodSchema | undefined = undefined,
   TSearchParamsSchema extends AnyZodSchema | undefined = undefined,
   THeadersSchema extends AnyZodSchema | undefined = undefined,
-  TBodySchema extends AnyZodSchema | undefined = undefined
+  TBodySchema extends AnyZodSchema | undefined = undefined,
+  TResource = never
 > = {
   params?: TParamsSchema;
   searchParams?: TSearchParamsSchema;
   headers?: THeadersSchema;
   allowJWT?: boolean;
   corsStrategy?: "all" | "none";
   method?: "POST" | "PUT" | "DELETE" | "PATCH";
+  findResource?: (
+    params: TParamsSchema extends z.ZodFirstPartySchemaTypes | z.ZodDiscriminatedUnion<any, any>
+      ? z.infer<TParamsSchema>
+      : undefined,
+    authentication: ApiAuthenticationResultSuccess,
+    searchParams: TSearchParamsSchema extends
+      | z.ZodFirstPartySchemaTypes
+      | z.ZodDiscriminatedUnion<any, any>
+      ? z.infer<TSearchParamsSchema>
+      : undefined
+  ) => Promise<TResource | undefined>;
   authorization?: {
     action: AuthorizationAction;
     resource: (
@@ -466,7 +478,8 @@ type ApiKeyActionHandlerFunction<
   TParamsSchema extends AnyZodSchema | undefined,
   TSearchParamsSchema extends AnyZodSchema | undefined,
   THeadersSchema extends AnyZodSchema | undefined = undefined,
-  TBodySchema extends AnyZodSchema | undefined = undefined
+  TBodySchema extends AnyZodSchema | undefined = undefined,
+  TResource = never
 > = (args: {
   params: TParamsSchema extends z.ZodFirstPartySchemaTypes | z.ZodDiscriminatedUnion<any, any>
     ? z.infer<TParamsSchema>
@@ -484,25 +497,29 @@ type ApiKeyActionHandlerFunction<
     : undefined;
   authentication: ApiAuthenticationResultSuccess;
   request: Request;
+  resource?: TResource;
 }) => Promise<Response>;
 
 export function createActionApiRoute<
   TParamsSchema extends AnyZodSchema | undefined = undefined,
   TSearchParamsSchema extends AnyZodSchema | undefined = undefined,
   THeadersSchema extends AnyZodSchema | undefined = undefined,
-  TBodySchema extends AnyZodSchema | undefined = undefined
+  TBodySchema extends AnyZodSchema | undefined = undefined,
+  TResource = never
 >(
   options: ApiKeyActionRouteBuilderOptions<
     TParamsSchema,
     TSearchParamsSchema,
     THeadersSchema,
-    TBodySchema
+    TBodySchema,
+    TResource
   >,
   handler: ApiKeyActionHandlerFunction<
     TParamsSchema,
     TSearchParamsSchema,
     THeadersSchema,
-    TBodySchema
+    TBodySchema,
+    TResource
   >
 ) {
   const {
@@ -682,13 +699,18 @@ export function createActionApiRoute<
         }
       }
 
+      const resource = options.findResource
+        ? await options.findResource(parsedParams, authenticationResult, parsedSearchParams)
+        : undefined;
+
       const result = await handler({
         params: parsedParams,
         searchParams: parsedSearchParams,
         headers: parsedHeaders,
         body: parsedBody,
         authentication: authenticationResult,
         request,
+        resource,
       });
       return await wrapResponse(request, result, corsStrategy !== "none");
     } catch (error) {

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

@@ -10,6 +10,7 @@ import { CLOUD_API_URL } from "../consts.js";
 import { McpContext } from "../mcp/context.js";
 import { FileLogger } from "../mcp/logger.js";
 import {
+  registerCancelRunTool,
   registerCreateProjectTool,
   registerDeployTool,
   registerGetRunDetailsTool,
@@ -105,6 +106,7 @@ export async function mcpCommand(options: McpCommandOptions) {
   registerGetTasksTool(context);
   registerTriggerTaskTool(context);
   registerGetRunDetailsTool(context);
+  registerCancelRunTool(context);
   registerListRunsTool(context);
   registerListProjectsTool(context);
   registerListOrgsTool(context);

packages/cli-v3/src/mcp/tools.ts

@@ -19,6 +19,7 @@ import { performSearch } from "./mintlifyClient.js";
 import { ProjectRefSchema } from "./schemas.js";
 import { respondWithError } from "./utils.js";
 import { resolveSync as esmResolve } from "mlly";
+import { tryCatch } from "@trigger.dev/core/utils";
 
 export function registerListProjectsTool(context: McpContext) {
   context.server.registerTool(
@@ -618,6 +619,92 @@ export function registerGetRunDetailsTool(context: McpContext) {
   );
 }
 
+export function registerCancelRunTool(context: McpContext) {
+  context.server.registerTool(
+    "cancel_run",
+    {
+      description: "Cancel a run",
+      inputSchema: {
+        runId: z.string().describe("The ID of the run to cancel, starts with run_"),
+        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(["dev", "staging", "prod", "preview"])
+          .describe("The environment to trigger the task in")
+          .default("dev"),
+        branch: z
+          .string()
+          .describe("The branch to trigger the task in, only used for preview environments")
+          .optional(),
+      },
+    },
+    async ({ projectRef, configPath, environment, branch, runId }) => {
+      context.logger?.log("calling cancel_run", {
+        projectRef,
+        configPath,
+        environment,
+        branch,
+        runId,
+      });
+
+      if (context.options.devOnly && environment !== "dev") {
+        return respondWithError(
+          `This MCP server is only available for the dev environment. You tried to access the ${environment} environment. Remove the --dev-only flag to access other environments.`
+        );
+      }
+
+      const projectRefResult = await resolveExistingProjectRef(context, projectRef, configPath);
+
+      if (projectRefResult.status === "error") {
+        return respondWithError(projectRefResult.error);
+      }
+
+      const $projectRef = projectRefResult.projectRef;
+
+      context.logger?.log("cancel_run 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, [
+        `write:runs:${runId}`,
+        `read:runs:${runId}`,
+      ]);
+
+      if (!apiClient) {
+        return respondWithError("Failed to create API client with public JWT");
+      }
+
+      const [cancelError] = await tryCatch(apiClient.cancelRun(runId));
+
+      if (cancelError) {
+        return respondWithError(cancelError.message);
+      }
+
+      const retrieveResult = await apiClient.retrieveRun(runId);
+
+      const runUrl = `${auth.dashboardUrl}/projects/v3/${$projectRef}/runs/${runId}`;
+
+      return {
+        content: [{ type: "text", text: JSON.stringify({ ...retrieveResult, runUrl }, null, 2) }],
+      };
+    }
+  );
+}
+
 export function registerListRunsTool(context: McpContext) {
   context.server.registerTool(
     "list_runs",