feat: MCP server 2.0

.cursor/mcp.json

@@ -1,7 +1,3 @@
 {
-  "mcpServers": {
-    "trigger.dev": {
-      "url": "http://localhost:3333/sse"
-    }
-  }
-}
+  "mcpServers": {}
+}

.gitignore

@@ -63,4 +63,5 @@ apps/**/public/build
 /packages/core/src/package.json
 /packages/trigger-sdk/src/package.json
 /packages/python/src/package.json
-.claude
+.claude
+.mcp.log

apps/webapp/app/routes/account.authorization-code.$authorizationCode/route.tsx

@@ -1,24 +1,25 @@
 import { CheckCircleIcon } from "@heroicons/react/24/solid";
 import { LoaderFunctionArgs } from "@remix-run/server-runtime";
-import { title } from "process";
 import { typedjson, useTypedLoaderData } from "remix-typedjson";
 import { z } from "zod";
-import { ErrorIcon } from "~/assets/icons/ErrorIcon";
 import { AppContainer, MainCenteredContainer } from "~/components/layout/AppLayout";
-import { LinkButton } from "~/components/primitives/Buttons";
 import { Callout } from "~/components/primitives/Callout";
 import { Header1 } from "~/components/primitives/Headers";
 import { Icon } from "~/components/primitives/Icon";
 import { Paragraph } from "~/components/primitives/Paragraph";
 import { logger } from "~/services/logger.server";
 import { createPersonalAccessTokenFromAuthorizationCode } from "~/services/personalAccessToken.server";
 import { requireUserId } from "~/services/session.server";
-import { rootPath } from "~/utils/pathBuilder";
 
 const ParamsSchema = z.object({
   authorizationCode: z.string(),
 });
 
+const SearchParamsSchema = z.object({
+  source: z.string().optional(),
+  clientName: z.string().optional(),
+});
+
 export const loader = async ({ request, params }: LoaderFunctionArgs) => {
   const userId = await requireUserId(request);
 
@@ -32,13 +33,23 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
     });
   }
 
+  const url = new URL(request.url);
+  const searchObject = Object.fromEntries(url.searchParams.entries());
+
+  const searchParams = SearchParamsSchema.safeParse(searchObject);
+
+  const source = (searchParams.success ? searchParams.data.source : undefined) ?? "cli";
+  const clientName = (searchParams.success ? searchParams.data.clientName : undefined) ?? "unknown";
+
   try {
     const personalAccessToken = await createPersonalAccessTokenFromAuthorizationCode(
       parsedParams.data.authorizationCode,
       userId
     );
     return typedjson({
       success: true as const,
+      source,
+      clientName,
     });
   } catch (error) {
     if (error instanceof Response) {
@@ -49,6 +60,8 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
       return typedjson({
         success: false as const,
         error: error.message,
+        source,
+        clientName,
       });
     }
 
@@ -73,7 +86,7 @@ export default function Page() {
                 <Icon icon={CheckCircleIcon} className="h-6 w-6 text-emerald-500" /> Successfully
                 authenticated
               </Header1>
-              <Paragraph>Return to your terminal to continue.</Paragraph>
+              <Paragraph>{getInstructionsForSource(result.source, result.clientName)}</Paragraph>
             </div>
           ) : (
             <div>
@@ -91,3 +104,21 @@ export default function Page() {
     </AppContainer>
   );
 }
+
+const prettyClientNames: Record<string, string> = {
+  "claude-code": "Claude Code",
+  "cursor-vscode": "Cursor",
+  "Visual Studio Code": "VSCode",
+  "windsurf-client": "Windsurf",
+  "claude-ai": "Claude Desktop",
+};
+
+function getInstructionsForSource(source: string, clientName: string) {
+  if (source === "mcp") {
+    if (clientName) {
+      return `Return to your ${prettyClientNames[clientName] ?? clientName} to continue.`;
+    }
+  }
+
+  return `Return to your terminal to continue.`;
+}

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,119 @@ 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";
+import { parseDate } from "@trigger.dev/core/v3/isomorphic";
+
+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 = parseDate(value);
+
+  if (!date) {
+    throw new ServiceValidationError(`Invalid search query parameter: ${paramName}=${value}`, 400);
+  }
+  return date;
+}

apps/webapp/app/routes/api.v1.orgs.$orgParam.projects.ts

@@ -0,0 +1,138 @@
+import type { ActionFunctionArgs, LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { json } from "@remix-run/server-runtime";
+import {
+  CreateProjectRequestBody,
+  GetProjectResponseBody,
+  GetProjectsResponseBody,
+} from "@trigger.dev/core/v3";
+import { z } from "zod";
+import { prisma } from "~/db.server";
+import { createProject } from "~/models/project.server";
+import { logger } from "~/services/logger.server";
+import { authenticateApiRequestWithPersonalAccessToken } from "~/services/personalAccessToken.server";
+import { isCuid } from "cuid";
+
+const ParamsSchema = z.object({
+  orgParam: z.string(),
+});
+
+export async function loader({ request, params }: LoaderFunctionArgs) {
+  logger.info("get projects", { url: request.url });
+
+  const authenticationResult = await authenticateApiRequestWithPersonalAccessToken(request);
+
+  if (!authenticationResult) {
+    return json({ error: "Invalid or Missing Access Token" }, { status: 401 });
+  }
+
+  const { orgParam } = ParamsSchema.parse(params);
+
+  const projects = await prisma.project.findMany({
+    where: {
+      organization: {
+        ...orgParamWhereClause(orgParam),
+        deletedAt: null,
+        members: {
+          some: {
+            userId: authenticationResult.userId,
+          },
+        },
+      },
+      version: "V3",
+      deletedAt: null,
+    },
+    include: {
+      organization: true,
+    },
+  });
+
+  if (!projects) {
+    return json({ error: "Projects not found" }, { status: 404 });
+  }
+
+  const result: GetProjectsResponseBody = projects.map((project) => ({
+    id: project.id,
+    externalRef: project.externalRef,
+    name: project.name,
+    slug: project.slug,
+    createdAt: project.createdAt,
+    organization: {
+      id: project.organization.id,
+      title: project.organization.title,
+      slug: project.organization.slug,
+      createdAt: project.organization.createdAt,
+    },
+  }));
+
+  return json(result);
+}
+
+export async function action({ request, params }: ActionFunctionArgs) {
+  const authenticationResult = await authenticateApiRequestWithPersonalAccessToken(request);
+
+  if (!authenticationResult) {
+    return json({ error: "Invalid or Missing Access Token" }, { status: 401 });
+  }
+
+  const { orgParam } = ParamsSchema.parse(params);
+
+  const organization = await prisma.organization.findFirst({
+    where: {
+      ...orgParamWhereClause(orgParam),
+      deletedAt: null,
+      members: {
+        some: {
+          userId: authenticationResult.userId,
+        },
+      },
+    },
+  });
+
+  if (!organization) {
+    return json({ error: "Organization not found" }, { status: 404 });
+  }
+
+  const body = await request.json();
+  const parsedBody = CreateProjectRequestBody.safeParse(body);
+
+  if (!parsedBody.success) {
+    return json({ error: "Invalid request body" }, { status: 400 });
+  }
+
+  const project = await createProject({
+    organizationSlug: organization.slug,
+    name: parsedBody.data.name,
+    userId: authenticationResult.userId,
+    version: "v3",
+  });
+
+  const result: GetProjectResponseBody = {
+    id: project.id,
+    externalRef: project.externalRef,
+    name: project.name,
+    slug: project.slug,
+    createdAt: project.createdAt,
+    organization: {
+      id: project.organization.id,
+      title: project.organization.title,
+      slug: project.organization.slug,
+      createdAt: project.organization.createdAt,
+    },
+  };
+
+  return json(result);
+}
+
+function orgParamWhereClause(orgParam: string) {
+  // If the orgParam is an ID, or if it's a slug
+  // IDs are cuid
+  if (isCuid(orgParam)) {
+    return {
+      id: orgParam,
+    };
+  }
+
+  return {
+    slug: orgParam,
+  };
+}