MCP Server TypeScript全栈：双传输到远程部署

┌─────────────┐     MCP Protocol     ┌─────────────┐
│  MCP Client │ ◄──────────────────► │  MCP Server │
│ (Claude Code│    JSON-RPC 2.0      │  (你的工具)   │
│  VS Code    │                      │             │
│  任意客户端) │                      │             │
└─────────────┘                      └─────────────┘

graph TB
    MCP[MCP Server 能力] --> T[Tools 工具]
    MCP --> R[Resources 资源]
    MCP --> P[Prompts 提示模板]

    T --> T1["执行动作：调用API、操作文件<br/>读写数据库、发HTTP请求"]
    R --> R1["提供数据：文件内容、数据库记录<br/>API响应、配置信息"]
    P --> P1["预设模板：代码审查模板<br/>分析框架、报告格式"]

    style T fill:#e74c3c,color:#fff
    style R fill:#3498db,color:#fff
    style P fill:#2ecc71,color:#fff

timeline
    title MCP 协议版本演进
    2024-11 : 协议首次发布
              : JSON-RPC batching
              : SSE 传输
    2025-03 : 2025-03-26 版本
              : Streamable HTTP 传输
              : OAuth 2.1 认证框架
    2025-06 : 2025-06-18 版本
              : Elicitation（人工确认）
              : 结构化 Tool 输出
              : Tool Annotations
              : 移除 JSON-RPC batching

mkdir mcp-devtool-server && cd mcp-devtool-server
npm init -y
npm install @modelcontextprotocol/sdk zod
npm install -D typescript @types/node tsx

// tsconfig.json
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "Node16",
    "moduleResolution": "Node16",
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "declaration": true
  },
  "include": ["src/**/*"]
}

// src/index.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const server = new McpServer({
  name: "devtool-server",
  version: "1.0.0",
});

// 注册一个 Tool
server.tool(
  "get_timestamp",
  "获取当前时间戳和格式化的日期时间",
  {},  // 无参数
  async () => ({
    content: [
      {
        type: "text",
        text: JSON.stringify({
          unix: Math.floor(Date.now() / 1000),
          iso: new Date().toISOString(),
          local: new Date().toLocaleString("zh-CN", { timeZone: "Asia/Shanghai" }),
        }, null, 2),
      },
    ],
  })
);

// 启动 Stdio 传输
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("MCP DevTool Server running on stdio");
}

main().catch(console.error);

{
  "type": "module",
  "scripts": {
    "dev": "tsx src/index.ts",
    "build": "tsc",
    "start": "node dist/index.js"
  }
}

{
  "mcpServers": {
    "devtool": {
      "command": "npx",
      "args": ["tsx", "src/index.ts"],
      "type": "stdio"
    }
  }
}

请调用 get_timestamp 工具获取当前时间

// src/tools/code-metrics.ts
import { z } from "zod";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

export function registerCodeMetricsTools(server: McpServer) {
  // Tool 1：代码复杂度分析
  server.tool(
    "analyze_complexity",
    "分析 TypeScript 代码的圈复杂度（Cyclomatic Complexity）",
    {
      code: z.string().describe("要分析的 TypeScript 代码"),
      threshold: z.number().optional().default(10).describe("复杂度告警阈值"),
    },
    async ({ code, threshold }) => {
      // 简化的圈复杂度计算
      const patterns = [
        /\bif\b/g, /\belse\b/g, /\bfor\b/g, /\bwhile\b/g,
        /\bcase\b/g, /\bcatch\b/g, /\&\&/g, /\|\|/g, /\?\?/g,
      ];

      let complexity = 1; // 基础复杂度
      for (const pattern of patterns) {
        const matches = code.match(pattern);
        if (matches) complexity += matches.length;
      }

      const lines = code.split("\n").length;
      const functions = (code.match(/\bfunction\b|\b=>\b|\w+\s*\(/g) || []).length;

      return {
        content: [
          {
            type: "text",
            text: JSON.stringify({
              complexity,
              lines,
              functions,
              rating: complexity <= (threshold ?? 10) ? "✅ GOOD" : "⚠️ HIGH",
              threshold,
              suggestion: complexity > (threshold ?? 10)
                ? `复杂度 ${complexity} 超过阈值 ${threshold}，建议拆分函数`
                : "代码复杂度在合理范围内",
            }, null, 2),
          },
        ],
      };
    }
  );

  // Tool 2：JSON 格式化与验证
  server.tool(
    "format_json",
    "格式化和验证 JSON 字符串，支持自定义缩进",
    {
      input: z.string().describe("要格式化的 JSON 字符串"),
      indent: z.number().optional().default(2).describe("缩进空格数"),
      sort_keys: z.boolean().optional().default(false).describe("是否排序键名"),
    },
    async ({ input, indent, sort_keys }) => {
      try {
        let parsed = JSON.parse(input);
        if (sort_keys) {
          parsed = sortObjectKeys(parsed);
        }
        return {
          content: [
            {
              type: "text",
              text: JSON.stringify(parsed, null, indent),
            },
          ],
        };
      } catch (e) {
        return {
          content: [
            {
              type: "text",
              text: `JSON 解析错误: ${(e as Error).message}`,
            },
          ],
          isError: true,
        };
      }
    }
  );
}

function sortObjectKeys(obj: unknown): unknown {
  if (Array.isArray(obj)) return obj.map(sortObjectKeys);
  if (obj && typeof obj === "object") {
    return Object.keys(obj as Record<string, unknown>)
      .sort()
      .reduce((acc: Record<string, unknown>, key) => {
        acc[key] = sortObjectKeys((obj as Record<string, unknown>)[key]);
        return acc;
      }, {});
  }
  return obj;
}

// src/resources/project-context.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import * as fs from "fs";
import * as path from "path";

export function registerProjectResources(server: McpServer) {
  // 静态 Resource：项目配置
  server.resource(
    "project-config",
    "config://project",
    async (uri) => ({
      contents: [
        {
          uri: uri.href,
          mimeType: "application/json",
          text: JSON.stringify({
            name: "mcp-devtool-server",
            version: "1.0.0",
            description: "Development toolchain MCP server",
            supportedTools: ["analyze_complexity", "format_json", "generate_scaffold"],
            supportedResources: ["project-config", "changelog"],
          }, null, 2),
        },
      ],
    })
  );

  // 动态 Resource 模板：读取项目文件
  server.resource(
    "file-reader",
    new URL("file://projects/{path}"),
    async (uri, { path: filePath }) => {
      // 安全检查：防止路径遍历
      const safePath = filePath.replace(/\.\./g, "").replace(/^\//, "");
      const fullPath = path.join(process.cwd(), safePath);

      if (!fullPath.startsWith(process.cwd())) {
        return {
          contents: [{
            uri: uri.href,
            mimeType: "text/plain",
            text: "Error: Path traversal detected",
          }],
        };
      }

      try {
        const content = fs.readFileSync(fullPath, "utf-8");
        const ext = path.extname(fullPath);
        const mimeMap: Record<string, string> = {
          ".ts": "text/typescript",
          ".js": "text/javascript",
          ".json": "application/json",
          ".md": "text/markdown",
          ".yaml": "text/yaml",
          ".yml": "text/yaml",
        };

        return {
          contents: [{
            uri: uri.href,
            mimeType: mimeMap[ext] || "text/plain",
            text: content,
          }],
        };
      } catch {
        return {
          contents: [{
            uri: uri.href,
            mimeType: "text/plain",
            text: `Error: File not found - ${safePath}`,
          }],
        };
      }
    }
  );
}

// src/prompts/code-review.ts
import { z } from "zod";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

export function registerCodeReviewPrompts(server: McpServer) {
  server.prompt(
    "review-code",
    "生成结构化的代码审查提示",
    {
      language: z.string().describe("编程语言"),
      focus: z.enum(["security", "performance", "readability", "all"]).describe("审查重点"),
      code: z.string().describe("待审查的代码"),
    },
    async ({ language, focus, code }) => {
      const focusMap = {
        security: "安全漏洞（OWASP Top 10、注入、XSS、认证问题）",
        performance: "性能瓶颈（时间复杂度、内存泄漏、不必要的计算）",
        readability: "可读性（命名规范、函数长度、注释质量）",
        all: "以上所有方面",
      };

      return {
        messages: [
          {
            role: "user",
            content: {
              type: "text",
              text: `请审查以下 ${language} 代码，重点关注 ${focusMap[focus]}。

## 代码
\`\`\`${language}
${code}
\`\`\`

## 审查要求
1. 列出发现的问题，按严重程度排序（Critical > Warning > Info）
2. 每个问题给出具体的修改建议
3. 总结代码的整体质量评分（1-10）`,
            },
          },
        ],
      };
    }
  );
}

// src/index.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { registerCodeMetricsTools } from "./tools/code-metrics.js";
import { registerProjectResources } from "./resources/project-context.js";
import { registerCodeReviewPrompts } from "./prompts/code-review.js";

const server = new McpServer({
  name: "devtool-server",
  version: "1.0.0",
});

// 注册所有能力
registerCodeMetricsTools(server);
registerProjectResources(server);
registerCodeReviewPrompts(server);

async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("DevTool MCP Server v1.0.0 running on stdio");
}

main().catch(console.error);

graph LR
    subgraph "MCP Server (devtool-server)"
        T[Tools] --> T1[analyze_complexity]
        T --> T2[format_json]
        T --> T3[generate_scaffold]

        R[Resources] --> R1["config://project"]
        R --> R2["file://projects/{path}"]

        P[Prompts] --> P1[review-code]
    end

    CC[Claude Code] -->|JSON-RPC| Server

    style Server fill:#1a1a2e,color:#fff
    style CC fill:#6c5ce7,color:#fff

// src/tools/annotations.ts
import { z } from "zod";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

export function registerAnnotatedTools(server: McpServer) {
  // 只读工具 —— 安全，无需确认
  server.tool(
    "search_files",
    { 
      pattern: z.string().describe("搜索模式（glob）"),
      directory: z.string().optional().default(".").describe("搜索目录"),
    },
    {
      title: "搜索文件",
      readOnlyHint: true,        // 只读，无副作用
      openWorldHint: true,       // 访问外部资源
    },
    async ({ pattern, directory }) => {
      // 实际实现用 fast-glob 等
      return {
        content: [{
          type: "text",
          text: `Searching for "${pattern}" in ${directory}...`,
        }],
      };
    }
  );

  // 破坏性工具 —— 需要用户明确确认
  server.tool(
    "delete_files",
    {
      pattern: z.string().describe("要删除的文件模式"),
    },
    {
      title: "删除文件",
      destructiveHint: true,     // 破坏性操作！
      readOnlyHint: false,
    },
    async ({ pattern }) => {
      return {
        content: [{
          type: "text",
          text: `Deleted files matching: ${pattern}`,
        }],
      };
    }
  );
}

// src/tools/structured-output.ts
import { z } from "zod";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

// 定义输出 Schema
const SearchResultSchema = z.object({
  query: z.string(),
  totalMatches: z.number(),
  files: z.array(z.object({
    path: z.string(),
    line: z.number(),
    preview: z.string(),
    relevance: z.number().min(0).max(1),
  })),
  executionTimeMs: z.number(),
});

export function registerStructuredTools(server: McpServer) {
  server.tool(
    "grep_code",
    "在代码库中搜索文本模式，返回结构化结果",
    {
      query: z.string().describe("搜索关键词"),
      max_results: z.number().optional().default(20),
    },
    {
      // 输出 Schema —— 客户端可以据此验证
      outputSchema: SearchResultSchema,
    },
    async ({ query, max_results }) => {
      const startTime = Date.now();

      // 模拟搜索逻辑
      const results = [
        { path: "src/index.ts", line: 42, preview: `// found ${query} here`, relevance: 0.95 },
        { path: "src/tools/code-metrics.ts", line: 15, preview: `const ${query} = ...`, relevance: 0.82 },
      ].slice(0, max_results);

      return {
        structuredContent: {
          query,
          totalMatches: results.length,
          files: results,
          executionTimeMs: Date.now() - startTime,
        },
        // 仍然可以提供文本回退给不支持结构化输出的客户端
        content: [{
          type: "text",
          text: `Found ${results.length} matches for "${query}"`,
        }],
      };
    }
  );
}

// src/tools/elicitation.ts
import { z } from "zod";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

export function registerElicitationTools(server: McpServer) {
  server.tool(
    "deploy_service",
    "部署服务到指定环境（需要用户确认）",
    {
      service_name: z.string().describe("服务名称"),
      environment: z.enum(["staging", "production"]).describe("目标环境"),
    },
    async ({ service_name, environment }, extra) => {
      // 关键操作前，使用 Elicitation 向用户确认
      const confirmation = await extra.elicitInput({
        message: `即将部署 ${service_name} 到 ${environment} 环境。确认继续？`,
        inputSchema: {
          type: "object" as const,
          properties: {
            confirmed: {
              type: "boolean" as const,
              description: "确认部署",
            },
            rollout_percentage: {
              type: "number" as const,
              description: "灰度发布百分比（1-100）",
              default: 100,
            },
          },
          required: ["confirmed"],
        },
      });

      if (!confirmation?.confirmed) {
        return {
          content: [{
            type: "text",
            text: "部署已取消",
          }],
          isError: true,
        };
      }

      const rollout = confirmation.rollout_percentage ?? 100;
      return {
        content: [{
          type: "text",
          text: `✅ ${service_name} 已部署到 ${environment}（灰度 ${rollout}%）`,
        }],
      };
    }
  );
}

sequenceDiagram
    participant User as 用户
    participant Client as MCP Client<br/>(Claude Code)
    participant Server as MCP Server

    User->>Client: 调用 deploy_service
    Client->>Server: tools/call {service_name, environment}
    Server->>Client: elicitation/request {确认部署?}
    Client->>User: 显示确认对话框
    User->>Client: confirmed=true, rollout=30%
    Client->>Server: elicitation/response
    Server->>Client: 工具执行结果
    Client->>User: 显示部署成功

graph TB
    subgraph "本地传输 (Stdio)"
        S1[Claude Code] -->|stdin/stdout| S2[MCP Server 进程]
    end

    subgraph "远程传输 (Streamable HTTP)"
        R1[任意 MCP Client] -->|HTTP POST| R2[MCP Server<br/>Cloudflare Workers]
        R2 -->|SSE Stream| R1
    end

    style S2 fill:#00b894,color:#fff
    style R2 fill:#0984e3,color:#fff

// src/transports/http.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamable-http.js";
import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
import express from "express";
import { randomUUID } from "crypto";

export async function startHttpTransport(server: McpServer, port: number) {
  const app = express();
  app.use(express.json());

  // 会话管理：每个客户端连接对应一个 transport 实例
  const transports: Map<string, StreamableHTTPServerTransport> = new Map();

  // MCP 消息端点
  app.post("/mcp", async (req, res) => {
    const sessionId = req.headers["mcp-session-id"] as string | undefined;
    let transport: StreamableHTTPServerTransport;

    if (sessionId && transports.has(sessionId)) {
      // 已有会话：复用 transport
      transport = transports.get(sessionId)!;
    } else if (isInitializeRequest(req.body)) {
      // 新会话：创建 transport
      transport = new StreamableHTTPServerTransport({
        sessionIdGenerator: randomUUID,
      });
      transports.set(transport.sessionId!, transport);

      // 清理断开的会话
      transport.onclose = () => {
        transports.delete(transport.sessionId!);
      };

      await server.connect(transport);
    } else {
      res.status(400).json({
        jsonrpc: "2.0",
        error: { code: -32000, message: "Bad Request: no valid session" },
        id: null,
      });
      return;
    }

    await transport.handleRequest(req, res, req.body);
  });

  // SSE 端点（用于服务器推送通知）
  app.get("/mcp", async (req, res) => {
    const sessionId = req.headers["mcp-session-id"] as string;
    const transport = transports.get(sessionId);
    if (!transport) {
      res.status(400).send("No active session");
      return;
    }
    await transport.handleRequest(req, res);
  });

  // DELETE 端点（关闭会话）
  app.delete("/mcp", async (req, res) => {
    const sessionId = req.headers["mcp-session-id"] as string;
    const transport = transports.get(sessionId);
    if (transport) {
      await transport.handleRequest(req, res);
      transports.delete(sessionId);
    }
  });

  app.listen(port, () => {
    console.error(`Streamable HTTP server listening on port ${port}`);
  });
}

// src/index.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { startHttpTransport } from "./transports/http.js";
import { registerCodeMetricsTools } from "./tools/code-metrics.js";
import { registerAnnotatedTools } from "./tools/annotations.js";
import { registerStructuredTools } from "./tools/structured-output.js";
import { registerElicitationTools } from "./tools/elicitation.js";
import { registerProjectResources } from "./resources/project-context.js";
import { registerCodeReviewPrompts } from "./prompts/code-review.js";

function createServer(): McpServer {
  const server = new McpServer({
    name: "devtool-server",
    version: "1.0.0",
  });

  registerCodeMetricsTools(server);
  registerAnnotatedTools(server);
  registerStructuredTools(server);
  registerElicitationTools(server);
  registerProjectResources(server);
  registerCodeReviewPrompts(server);

  return server;
}

async function main() {
  const mode = process.env.MCP_TRANSPORT || "stdio";
  const server = createServer();

  if (mode === "stdio") {
    const transport = new StdioServerTransport();
    await server.connect(transport);
    console.error("DevTool MCP Server running on stdio");
  } else if (mode === "http") {
    const port = parseInt(process.env.PORT || "3000", 10);
    await startHttpTransport(server, port);
  } else {
    console.error(`Unknown transport: ${mode}. Use "stdio" or "http"`);
    process.exit(1);
  }
}

main().catch(console.error);

# 本地 Stdio 模式（Claude Code 使用）
MCP_TRANSPORT=stdio npx tsx src/index.ts

# 远程 HTTP 模式（多客户端共享）
MCP_TRANSPORT=http PORT=3000 npx tsx src/index.ts

// src/workers/index.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamable-http.js";
import { z } from "zod";

const server = new McpServer({
  name: "devtool-server-remote",
  version: "1.0.0",
});

// 注册 Tools（不能使用 Node.js API）
server.tool(
  "hash_text",
  "计算文本的 SHA-256 哈希值",
  { text: z.string().describe("输入文本") },
  async ({ text }) => {
    const encoder = new TextEncoder();
    const data = encoder.encode(text);
    const hashBuffer = await crypto.subtle.digest("SHA-256", data);
    const hashArray = Array.from(new Uint8Array(hashBuffer));
    const hashHex = hashArray.map(b => b.toString(16).padStart(2, "0")).join("");

    return {
      content: [{
        type: "text",
        text: `SHA-256: ${hashHex}`,
      }],
    };
  }
);

server.tool(
  "base64_encode",
  "Base64 编码/解码",
  {
    input: z.string().describe("输入字符串"),
    operation: z.enum(["encode", "decode"]).describe("操作类型"),
  },
  async ({ input, operation }) => {
    const result = operation === "encode"
      ? btoa(unescape(encodeURIComponent(input)))
      : decodeURIComponent(escape(atob(input)));

    return {
      content: [{
        type: "text",
        text: result,
      }],
    };
  }
);

// Workers 入口
export default {
  async fetch(request: Request): Promise<Response> {
    const url = new URL(request.url);

    if (url.pathname === "/mcp" && request.method === "POST") {
      const transport = new StreamableHTTPServerTransport({
        sessionIdGenerator: undefined, // 无状态模式
      });
      await server.connect(transport);

      const body = await request.json();
      return transport.handleRequest(request, body);
    }

    // 健康检查
    if (url.pathname === "/health") {
      return new Response(JSON.stringify({ status: "ok", version: "1.0.0" }), {
        headers: { "Content-Type": "application/json" },
      });
    }

    return new Response("Not Found", { status: 404 });
  },
};

# wrangler.toml
name = "mcp-devtool-server"
main = "src/workers/index.ts"
compatibility_date = "2025-06-18"
compatibility_flags = ["nodejs_compat"]

[observability]
enabled = true

npx wrangler deploy

{
  "mcpServers": {
    "devtool-remote": {
      "type": "streamable-http",
      "url": "https://mcp-devtool-server.<your-subdomain>.workers.dev/mcp"
    }
  }
}

claude mcp add devtool-remote --transport streamable-http \
  --url https://mcp-devtool-server.<your-subdomain>.workers.dev/mcp

sequenceDiagram
    participant Client as MCP Client
    participant Server as MCP Server
    participant Auth as Authorization Server<br/>(Cloudflare Access)

    Client->>Server: POST /mcp (无 token)
    Server-->>Client: HTTP 401 + WWW-Authenticate
    Client->>Auth: OAuth 2.1 Authorization Request
    Auth->>Client: Authorization Code
    Client->>Auth: Token Exchange
    Auth->>Client: Access Token
    Client->>Server: POST /mcp (Bearer Token)
    Server->>Server: 验证 Token
    Server-->>Client: 200 OK + MCP Response

// src/middleware/auth.ts
import { verifyJwt } from "./jwt-utils.js";

interface AuthConfig {
  audience: string;
  issuer: string;
  jwksUri: string;
}

export function createAuthMiddleware(config: AuthConfig) {
  return async (request: Request): Promise<{ authorized: boolean; error?: Response }> => {
    const authHeader = request.headers.get("Authorization");

    if (!authHeader?.startsWith("Bearer ")) {
      return {
        authorized: false,
        error: new Response("Unauthorized", {
          status: 401,
          headers: {
            "WWW-Authenticate": `Bearer realm="mcp", audience="${config.audience}"`,
          },
        }),
      };
    }

    const token = authHeader.slice(7);

    try {
      const payload = await verifyJwt(token, {
        audience: config.audience,
        issuer: config.issuer,
        jwksUri: config.jwksUri,
      });

      // Token 有效
      return { authorized: true };
    } catch {
      return {
        authorized: false,
        error: new Response("Invalid token", { status: 401 }),
      };
    }
  };
}

// src/workers/index-with-auth.ts
import { createAuthMiddleware } from "../middleware/auth.js";

const auth = createAuthMiddleware({
  audience: "https://mcp-devtool-server.your-domain.workers.dev",
  issuer: "https://your-auth-domain.cloudflareaccess.com",
  jwksUri: "https://your-auth-domain.cloudflareaccess.com/cdn-cgi/access/certs",
});

export default {
  async fetch(request: Request): Promise<Response> {
    const url = new URL(request.url);

    // MCP 端点需要认证
    if (url.pathname === "/mcp") {
      const { authorized, error } = await auth(request);
      if (!authorized) return error!;

      // ... 处理 MCP 请求
    }

    // 健康检查不需要认证
    if (url.pathname === "/health") {
      return new Response(JSON.stringify({ status: "ok" }));
    }

    return new Response("Not Found", { status: 404 });
  },
};

{
  "mcpServers": {
    "devtool-remote-auth": {
      "type": "streamable-http",
      "url": "https://mcp-devtool-server.<subdomain>.workers.dev/mcp",
      "headers": {
        "Authorization": "Bearer ${MCP_ACCESS_TOKEN}"
      }
    }
  }
}

npx @modelcontextprotocol/inspector npx tsx src/index.ts

// tests/tools.test.ts
import { describe, it, expect } from "vitest";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
import { spawn } from "child_process";

describe("DevTool MCP Server", () => {
  let client: Client;

  beforeAll(async () => {
    const transport = new StdioClientTransport({
      command: "npx",
      args: ["tsx", "src/index.ts"],
    });

    client = new Client({
      name: "test-client",
      version: "1.0.0",
    });

    await client.connect(transport);
  });

  it("应该列出所有注册的 Tools", async () => {
    const tools = await client.listTools();
    const toolNames = tools.tools.map(t => t.name);

    expect(toolNames).toContain("get_timestamp");
    expect(toolNames).toContain("analyze_complexity");
    expect(toolNames).toContain("format_json");
  });

  it("应该正确分析代码复杂度", async () => {
    const result = await client.callTool({
      name: "analyze_complexity",
      arguments: {
        code: "if (a) { for (let i = 0; i < 10; i++) { if (b) { console.log(i); } } }",
      },
    });

    const content = result.content as Array<{ type: string; text: string }>;
    const parsed = JSON.parse(content[0].text);
    expect(parsed.complexity).toBeGreaterThan(1);
  });

  it("应该格式化 JSON 并排序键", async () => {
    const result = await client.callTool({
      name: "format_json",
      arguments: {
        input: '{"z":1,"a":2}',
        sort_keys: true,
      },
    });

    const content = result.content as Array<{ type: string; text: string }>;
    expect(content[0].text).toBe('{\n  "a": 2,\n  "z": 1\n}');
  });

  afterAll(async () => {
    await client.close();
  });
});

mcp-devtool-server/
├── src/
│   ├── index.ts                  # 主入口（双传输）
│   ├── tools/
│   │   ├── code-metrics.ts       # 代码复杂度分析
│   │   ├── annotations.ts        # Tool Annotations 示例
│   │   ├── structured-output.ts  # 结构化输出示例
│   │   └── elicitation.ts        # Elicitation 示例
│   ├── resources/
│   │   └── project-context.ts    # 项目上下文资源
│   ├── prompts/
│   │   └── code-review.ts        # 代码审查提示模板
│   ├── transports/
│   │   └── http.ts               # Streamable HTTP 传输
│   ├── middleware/
│   │   └── auth.ts               # OAuth 2.1 认证
│   └── workers/
│       ├── index.ts              # Workers 入口
│       └── index-with-auth.ts    # 带 Auth 的 Workers 入口
├── tests/
│   └── tools.test.ts             # 单元测试
├── .mcp.json                     # 本地 Claude Code 配置
├── wrangler.toml                 # Cloudflare Workers 配置
├── tsconfig.json
└── package.json

graph TB
    subgraph "DevOps MCP Server"
        direction TB

        subgraph "Tools"
            T1[analyze_complexity<br/>代码复杂度分析]
            T2[format_json<br/>JSON格式化]
            T3[hash_text<br/>哈希计算]
            T4[deploy_service<br/>服务部署+确认]
            T5[grep_code<br/>代码搜索]
        end

        subgraph "Resources"
            R1[config://project<br/>项目配置]
            R2[file://projects/path<br/>文件读取]
        end

        subgraph "Prompts"
            P1[review-code<br/>代码审查模板]
        end
    end

    subgraph "部署方式"
        D1[Stdio 本地]
        D2[HTTP 远程]
        D3[Workers Cloudflare]
    end

    DevOps --> D1
    DevOps --> D2
    DevOps --> D3

    style DevOps fill:#1a1a2e,color:#fff

# 克隆并安装
git clone <your-repo> && cd mcp-devtool-server
npm install

# 本地测试
npm run dev

# Inspector 调试
npx @modelcontextprotocol/inspector npm run dev

# 运行测试
npx vitest

# 部署到 Cloudflare
npx wrangler deploy

# Claude Code 接入远程服务器
claude mcp add devtools --transport streamable-http \
  --url https://mcp-devtool-server.your-subdomain.workers.dev/mcp