chore: more polishing on MCP logs UX (#2535)

Author: joeyorlando

docs/openapi.json

@@ -910,48 +910,6 @@ const mcpServerRoutes: FastifyPluginAsyncZod = async (fastify) => {
     },
   );
 
-  fastify.post(
-    "/api/mcp_server/:id/restart",
-    {
-      schema: {
-        operationId: RouteId.RestartMcpServer,
-        description: "Restart a single MCP server deployment",
-        tags: ["MCP Server"],
-        params: z.object({
-          id: UuidIdSchema,
-        }),
-        response: constructResponseSchema(
-          z.object({
-            success: z.boolean(),
-            message: z.string(),
-          }),
-        ),
-      },
-    },
-    async ({ params: { id } }, reply) => {
-      try {
-        await McpServerRuntimeManager.restartServer(id);
-        return reply.send({
-          success: true,
-          message: `MCP server ${id} restarted successfully`,
-        });
-      } catch (error) {
-        fastify.log.error(
-          `Failed to restart MCP server ${id}: ${error instanceof Error ? error.message : "Unknown error"}`,
-        );
-
-        if (error instanceof Error && error.message?.includes("not found")) {
-          throw new ApiError(404, error.message);
-        }
-
-        throw new ApiError(
-          500,
-          `Failed to restart MCP server: ${error instanceof Error ? error.message : "Unknown error"}`,
-        );
-      }
-    },
-  );
-
   /**
    * Reinstall an MCP server without losing tool assignments and policies.
    *
@@ -1148,140 +1106,48 @@ const mcpServerRoutes: FastifyPluginAsyncZod = async (fastify) => {
         });
       }
 
-      // Refetch the server with potentially updated secretId
+      // Set status to "pending" immediately so UI shows progress bar
+      await McpServerModel.update(id, {
+        localInstallationStatus: "pending",
+        localInstallationError: null,
+      });
+
+      // Refetch the server with updated status
       const updatedServer = await McpServerModel.findById(id);
       if (!updatedServer) {
         throw new ApiError(500, "Server not found after update");
       }
 
-      // Perform the reinstall
-      try {
-        await autoReinstallServer(updatedServer, catalogItem);
-        logger.info(
-          { serverId: id, serverName: mcpServer.name },
-          "MCP server reinstalled successfully",
-        );
-      } catch (error) {
-        logger.error(
-          { err: error, serverId: id },
-          "Failed to reinstall MCP server",
-        );
-        throw new ApiError(
-          500,
-          `Failed to reinstall MCP server: ${error instanceof Error ? error.message : "Unknown error"}`,
-        );
-      }
-
-      // Return the updated server
-      const finalServer = await McpServerModel.findById(id);
-      if (!finalServer) {
-        throw new ApiError(500, "Server not found after reinstall");
-      }
-      return reply.send(finalServer);
-    },
-  );
-
-  fastify.post(
-    "/api/mcp_catalog/:catalogId/restart-all-installations",
-    {
-      schema: {
-        operationId: RouteId.RestartAllMcpServerInstallations,
-        description:
-          "Restart all MCP server installations for a given catalog item",
-        tags: ["MCP Server"],
-        params: z.object({
-          catalogId: UuidIdSchema,
-        }),
-        response: constructResponseSchema(
-          z.object({
-            success: z.boolean(),
-            message: z.string(),
-            results: z.array(
-              z.object({
-                serverId: z.string(),
-                serverName: z.string(),
-                success: z.boolean(),
-                error: z.string().optional(),
-              }),
-            ),
-            summary: z.object({
-              total: z.number(),
-              succeeded: z.number(),
-              failed: z.number(),
-            }),
-          }),
-        ),
-      },
-    },
-    async ({ params: { catalogId } }, reply) => {
-      // Verify the catalog item exists
-      const catalogItem = await InternalMcpCatalogModel.findById(catalogId);
-      if (!catalogItem) {
-        throw new ApiError(404, `Catalog item ${catalogId} not found`);
-      }
-
-      // Find all MCP server installations for this catalog item
-      const servers = await McpServerModel.findByCatalogId(catalogId);
-
-      if (servers.length === 0) {
-        return reply.send({
-          success: true,
-          message: "No installations found for this catalog item",
-          results: [],
-          summary: { total: 0, succeeded: 0, failed: 0 },
-        });
-      }
-
-      // Restart each server sequentially
-      const results: Array<{
-        serverId: string;
-        serverName: string;
-        success: boolean;
-        error?: string;
-      }> = [];
-
-      for (const server of servers) {
+      // Perform the reinstall asynchronously (don't block the response)
+      // Use setImmediate to fully detach from the request lifecycle
+      // This allows the frontend to show the progress bar immediately
+      setImmediate(async () => {
         try {
-          await McpServerRuntimeManager.restartServer(server.id);
-          results.push({
-            serverId: server.id,
-            serverName: server.name,
-            success: true,
+          await autoReinstallServer(updatedServer, catalogItem);
+          // Set status to success when done
+          await McpServerModel.update(id, {
+            localInstallationStatus: "success",
           });
           logger.info(
-            `Restarted MCP server ${server.id} (${server.name}) as part of restart-all for catalog ${catalogId}`,
+            { serverId: id, serverName: mcpServer.name },
+            "MCP server reinstalled successfully",
           );
         } catch (error) {
-          const errorMessage =
-            error instanceof Error ? error.message : "Unknown error";
-          results.push({
-            serverId: server.id,
-            serverName: server.name,
-            success: false,
-            error: errorMessage,
+          // Set status to error if reinstall fails
+          await McpServerModel.update(id, {
+            localInstallationStatus: "error",
+            localInstallationError:
+              error instanceof Error ? error.message : "Unknown error",
           });
           logger.error(
-            `Failed to restart MCP server ${server.id} (${server.name}): ${errorMessage}`,
+            { err: error, serverId: id },
+            "Failed to reinstall MCP server",
           );
         }
-      }
-
-      const succeeded = results.filter((r) => r.success).length;
-      const failed = results.filter((r) => !r.success).length;
-
-      return reply.send({
-        success: failed === 0,
-        message:
-          failed === 0
-            ? `Successfully restarted all ${succeeded} installation(s)`
-            : `Restarted ${succeeded} of ${servers.length} installation(s), ${failed} failed`,
-        results,
-        summary: {
-          total: servers.length,
-          succeeded,
-          failed,
-        },
       });
+
+      // Return the server immediately with "pending" status
+      return reply.send(updatedServer);
     },
   );
 };

platform/backend/src/routes/mcp-server.ts

@@ -30,7 +30,6 @@ export interface TestFixtures {
   deleteMcpCatalogItem: typeof deleteMcpCatalogItem;
   installMcpServer: typeof installMcpServer;
   uninstallMcpServer: typeof uninstallMcpServer;
-  restartMcpServer: typeof restartMcpServer;
   createRole: typeof createRole;
   deleteRole: typeof deleteRole;
   waitForAgentTool: typeof waitForAgentTool;
@@ -309,17 +308,6 @@ const uninstallMcpServer = async (
     urlSuffix: `/api/mcp_server/${serverId}`,
   });
 
-/**
- * Restart an MCP server (local servers only)
- * (authnz is handled by the authenticated session)
- */
-const restartMcpServer = async (request: APIRequestContext, serverId: string) =>
-  makeApiRequest({
-    request,
-    method: "post",
-    urlSuffix: `/api/mcp_server/${serverId}/restart`,
-  });
-
 /**
  * Create a custom role
  * (authnz is handled by the authenticated session)
@@ -821,9 +809,6 @@ export const test = base.extend<TestFixtures>({
   uninstallMcpServer: async ({}, use) => {
     await use(uninstallMcpServer);
   },
-  restartMcpServer: async ({}, use) => {
-    await use(restartMcpServer);
-  },
   createRole: async ({}, use) => {
     await use(createRole);
   },

platform/e2e-tests/tests/api/fixtures.ts

@@ -231,37 +231,6 @@ test.describe("Orchestrator - MCP Server Installation and Execution", () => {
       );
       expect(testTool).toBeDefined();
     });
-
-    test("should restart local MCP server successfully", async ({
-      request,
-      makeApiRequest,
-      restartMcpServer,
-    }) => {
-      // Get tools count before restart
-      const toolsBefore = await getMcpServerTools(
-        request,
-        makeApiRequest,
-        serverId,
-      );
-      const toolsCountBefore = toolsBefore.length;
-
-      // Restart the MCP server
-      const restartResponse = await restartMcpServer(request, serverId);
-      expect(restartResponse.status()).toBe(200);
-      const restartResult = await restartResponse.json();
-      expect(restartResult.success).toBe(true);
-
-      // Wait for the server to be ready after restart
-      await waitForServerInstallation(request, serverId);
-
-      // Verify tools are still available after restart
-      const toolsAfter = await getMcpServerTools(
-        request,
-        makeApiRequest,
-        serverId,
-      );
-      expect(toolsAfter.length).toBe(toolsCountBefore);
-    });
   });
 
   test.describe("Local MCP Server - Docker Image", () => {