fix: support mcp

Author: avi-alpert

src/cli/operations/dev/web-ui/__tests__/mcp-proxy.test.ts

@@ -4,7 +4,7 @@ import type { IncomingMessage, ServerResponse } from 'http';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 function mockReq(_body: string): IncomingMessage {
-  return {} as IncomingMessage;
+  return { url: '/api/mcp', headers: { host: 'localhost:8081' } } as unknown as IncomingMessage;
 }
 
 function mockRes(): ServerResponse & { _status: number; _headers: Record<string, string>; _body: string } {

src/cli/operations/dev/web-ui/handlers/mcp-proxy.ts

@@ -1,4 +1,7 @@
-import type { RouteContext } from './route-context.js';
+import { ConfigIO } from '../../../../../lib';
+import { mcpCallTool, mcpInitSession, mcpListTools } from '../../../../aws/agentcore';
+import { resolveInvokeTarget } from '../../../../commands/invoke/resolve';
+import { type RouteContext, parseRequestUrl } from './route-context.js';
 import type { IncomingMessage, ServerResponse } from 'http';
 
 export async function handleMcpProxy(
@@ -7,6 +10,11 @@ export async function handleMcpProxy(
   res: ServerResponse,
   origin?: string
 ): Promise<void> {
+  const { param } = parseRequestUrl(req);
+  if (param('target') === 'deployed') {
+    return handleDeployedMcpProxy(ctx, req, res, origin);
+  }
+
   ctx.setCorsHeaders(res, origin);
 
   const raw = await ctx.readBody(req);
@@ -80,3 +88,135 @@ export async function handleMcpProxy(
   res.writeHead(200, { 'Content-Type': 'application/json' });
   res.end(JSON.stringify({ success: true, result, sessionId: responseSessionId }));
 }
+
+async function handleDeployedMcpProxy(
+  ctx: RouteContext,
+  req: IncomingMessage,
+  res: ServerResponse,
+  origin?: string
+): Promise<void> {
+  const { configRoot } = ctx.options;
+  if (!configRoot) {
+    ctx.setCorsHeaders(res, origin);
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ success: false, error: 'No agentcore project found' }));
+    return;
+  }
+
+  const raw = await ctx.readBody(req);
+  let parsed: {
+    agentName?: string;
+    targetName?: string;
+    body?: Record<string, unknown>;
+    sessionId?: string;
+  };
+  try {
+    parsed = JSON.parse(raw) as typeof parsed;
+  } catch {
+    ctx.setCorsHeaders(res, origin);
+    res.writeHead(400, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ success: false, error: 'Invalid JSON' }));
+    return;
+  }
+
+  const { agentName, targetName, body, sessionId } = parsed;
+
+  if (!body) {
+    ctx.setCorsHeaders(res, origin);
+    res.writeHead(400, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ success: false, error: 'body is required' }));
+    return;
+  }
+
+  const configIO = new ConfigIO({ baseDir: configRoot });
+  let project;
+  let deployedState;
+  let awsTargets;
+  try {
+    project = await configIO.readProjectSpec();
+    deployedState = await configIO.readDeployedState();
+    awsTargets = await configIO.readAWSDeploymentTargets();
+  } catch (err) {
+    ctx.setCorsHeaders(res, origin);
+    res.writeHead(500, { 'Content-Type': 'application/json' });
+    res.end(
+      JSON.stringify({
+        success: false,
+        error: `Failed to load config: ${err instanceof Error ? err.message : String(err)}`,
+      })
+    );
+    return;
+  }
+
+  const resolved = await resolveInvokeTarget({
+    project,
+    deployedState,
+    awsTargets,
+    agentName,
+    targetName,
+    sessionId,
+    configIO,
+  });
+
+  if (!resolved.success) {
+    ctx.setCorsHeaders(res, origin);
+    res.writeHead(400, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ success: false, error: resolved.error.message }));
+    return;
+  }
+
+  const mcpOpts = {
+    region: resolved.region,
+    runtimeArn: resolved.runtimeArn,
+    bearerToken: resolved.bearerToken,
+    mcpSessionId: sessionId,
+  };
+
+  const method = (body as { method?: string }).method;
+
+  try {
+    if (method === 'initialize') {
+      const mcpSessionId = await mcpInitSession(mcpOpts);
+      ctx.setCorsHeaders(res, origin);
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ success: true, result: { jsonrpc: '2.0', result: {} }, sessionId: mcpSessionId }));
+    } else if (method === 'tools/list') {
+      const result = await mcpListTools(mcpOpts);
+      ctx.setCorsHeaders(res, origin);
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ success: true, result: { jsonrpc: '2.0', result } }));
+    } else if (method === 'tools/call') {
+      const params = (body as { params?: { name?: string; arguments?: Record<string, unknown> } }).params;
+      if (!params?.name) {
+        ctx.setCorsHeaders(res, origin);
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: false, error: 'tools/call requires params.name' }));
+        return;
+      }
+      const response = await mcpCallTool(mcpOpts, params.name, params.arguments ?? {});
+      ctx.setCorsHeaders(res, origin);
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(
+        JSON.stringify({
+          success: true,
+          result: { jsonrpc: '2.0', result: { content: [{ type: 'text', text: response }] } },
+        })
+      );
+    } else {
+      ctx.setCorsHeaders(res, origin);
+      res.writeHead(400, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ success: false, error: `Unsupported MCP method: ${method}` }));
+    }
+  } catch (err) {
+    ctx.setCorsHeaders(res, origin);
+    if (!res.headersSent) {
+      res.writeHead(502, { 'Content-Type': 'application/json' });
+    }
+    res.end(
+      JSON.stringify({
+        success: false,
+        error: `MCP invoke failed: ${err instanceof Error ? err.message : String(err)}`,
+      })
+    );
+  }
+}

src/cli/operations/dev/web-ui/web-server.ts

@@ -342,7 +342,7 @@ export class WebUIServer {
       await handleStart(ctx, req, res, origin);
     } else if (req.method === 'POST' && (req.url === '/invocations' || req.url?.startsWith('/invocations?'))) {
       await handleInvocations(ctx, req, res, origin);
-    } else if (req.method === 'POST' && req.url === '/api/mcp') {
+    } else if (req.method === 'POST' && (req.url === '/api/mcp' || req.url?.startsWith('/api/mcp?'))) {
       await handleMcpProxy(ctx, req, res, origin);
     } else if (req.method === 'GET' && req.url?.startsWith('/api/a2a/agent-card')) {
       await handleA2AAgentCard(ctx, req, res, origin);