Improve the deploy experience

Author: ericallam

packages/cli-v3/package.json

@@ -132,6 +132,7 @@
     "socket.io-client": "4.7.5",
     "source-map-support": "0.5.21",
     "std-env": "^3.7.0",
+    "strip-ansi": "^7.1.0",
     "supports-color": "^10.0.0",
     "tiny-invariant": "^1.2.0",
     "tinyexec": "^0.3.1",

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

@@ -74,7 +74,7 @@ export const toolsMetadata = {
     name: "deploy",
     title: "Deploy",
     description:
-      "Deploy a project. Use this tool when you need to deploy a project. This will trigger a deployment for the project.",
+      "Deploy a project. Use this tool when you need to deploy a project. This will trigger a deployment for the project. This is a long running operation and including a progress token will allow you to display the progress to the user.",
   },
   list_deploys: {
     name: "list_deploys",

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

@@ -8,13 +8,14 @@ import { getPackageJson, tryResolveTriggerPackageVersion } from "../../commands/
 import { VERSION } from "../../version.js";
 import { resolveSync as esmResolve } from "mlly";
 import { fileURLToPath } from "node:url";
+import stripAnsi from "strip-ansi";
 
 export const deployTool = {
   name: toolsMetadata.deploy.name,
   title: toolsMetadata.deploy.title,
   description: toolsMetadata.deploy.description,
   inputSchema: DeployInput.shape,
-  handler: toolHandler(DeployInput.shape, async (input, { ctx }) => {
+  handler: toolHandler(DeployInput.shape, async (input, { ctx, createProgressTracker, _meta }) => {
     ctx.logger?.log("calling deploy", { input });
 
     if (ctx.options.devOnly) {
@@ -59,23 +60,43 @@ export const deployTool = {
       nodePath,
       cliPath,
       args,
+      meta: _meta,
     });
 
+    const progressTracker = createProgressTracker(100);
+    await progressTracker.updateProgress(
+      5,
+      `Starting deploy to ${input.environment}${input.branch ? ` on branch ${input.branch}` : ""}`
+    );
+
     const deployProcess = x(nodePath, [cliPath, ...args], {
       nodeOptions: {
         cwd: cwd.cwd,
         env: {
           TRIGGER_MCP_SERVER: "1",
+          CI: "true",
         },
       },
     });
 
     const logs = [];
 
     for await (const line of deployProcess) {
-      logs.push(line);
+      const lineWithoutAnsi = stripAnsi(line);
+
+      const buildingVersion = lineWithoutAnsi.match(/Building version (\d+\.\d+)/);
+
+      if (buildingVersion) {
+        await progressTracker.incrementProgress(1, `Building version ${buildingVersion[1]}`);
+      } else {
+        await progressTracker.incrementProgress(1);
+      }
+
+      logs.push(stripAnsi(line));
     }
 
+    await progressTracker.complete("Deploy complete");
+
     ctx.logger?.log("deploy deployProcess", {
       logs,
     });

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

@@ -1,4 +1,4 @@
-import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { CallToolResult, ServerNotification } from "@modelcontextprotocol/sdk/types.js";
 import z from "zod";
 import { ToolMeta } from "./types.js";
 import { loadConfig } from "../config.js";
@@ -37,9 +37,16 @@ function enumerateError(error: unknown) {
   return newError;
 }
 
+export type ToolHandlerMeta = ToolMeta & {
+  createProgressTracker: (total: number) => ProgressTracker;
+};
+
 export function toolHandler<TInputShape extends z.ZodRawShape>(
   shape: TInputShape,
-  handler: (input: z.output<z.ZodObject<TInputShape>>, meta: ToolMeta) => Promise<CallToolResult>
+  handler: (
+    input: z.output<z.ZodObject<TInputShape>>,
+    meta: ToolHandlerMeta
+  ) => Promise<CallToolResult>
 ) {
   return async (input: unknown, extra: ToolMeta) => {
     const parsedInput = z.object(shape).safeParse(input);
@@ -48,6 +55,81 @@ export function toolHandler<TInputShape extends z.ZodRawShape>(
       return respondWithError(parsedInput.error);
     }
 
-    return handler(parsedInput.data, extra);
+    function createProgressTracker(total: number) {
+      return new ProgressTracker(total, extra.sendNotification, extra._meta?.progressToken);
+    }
+
+    return handler(parsedInput.data, { ...extra, createProgressTracker });
   };
 }
+
+class ProgressTracker {
+  private progress: number = 0;
+  private progressToken: string | number | undefined;
+  private total: number;
+  private message: string;
+  private sendNotification: (notification: ServerNotification) => Promise<void>;
+
+  constructor(
+    total: number,
+    sendNotification: (notification: ServerNotification) => Promise<void>,
+    progressToken?: string | number
+  ) {
+    this.message = "";
+    this.progressToken = progressToken;
+    this.progress = 0;
+    this.total = total;
+    this.sendNotification = sendNotification;
+  }
+
+  async updateProgress(progress: number, message?: string) {
+    this.progress = progress;
+
+    if (message) {
+      this.message = message;
+    }
+
+    await this.#sendNotification(progress, this.message);
+  }
+
+  async incrementProgress(increment: number, message?: string) {
+    this.progress += increment;
+
+    // make sure the progress is never greater than the total
+    this.progress = Math.min(this.progress, this.total);
+
+    if (message) {
+      this.message = message;
+    }
+
+    await this.#sendNotification(this.progress, this.message);
+  }
+
+  async complete(message?: string) {
+    this.progress = this.total;
+    if (message) {
+      this.message = message;
+    }
+    await this.#sendNotification(this.progress, this.message);
+  }
+
+  getProgress() {
+    return this.progress;
+  }
+
+  async #sendNotification(progress: number, message: string) {
+    if (!this.progressToken) {
+      return;
+    }
+
+    await this.sendNotification({
+      method: "notifications/progress",
+      params: {
+        progress,
+        total: this.total,
+        message: this.message,
+        progressToken: this.progressToken,
+      },
+    });
+  }
+}