使用 Node.js 实现 MCP Server

mcp-server-express/
├── src/
│   ├── app.js              # 应用入口
│   ├── config/             # 配置文件
│   │   └── index.js
│   ├── controllers/        # 控制器
│   │   ├── capabilities.controller.js
│   │   ├── tools.controller.js
│   │   └── websocket.controller.js
│   ├── services/           # 服务
│   │   ├── auth.service.js
│   │   ├── tool.service.js
│   │   └── websocket.service.js
│   ├── models/             # 数据模型
│   │   └── tool.model.js
│   ├── middleware/         # 中间件
│   │   ├── auth.middleware.js
│   │   └── logging.middleware.js
│   ├── utils/              # 工具函数
│   │   ├── logger.js
│   │   └── validator.js
│   └── routes/             # 路由
│       ├── capabilities.routes.js
│       └── tools.routes.js
├── tests/                  # 测试用例
│   ├── unit/               # 单元测试
│   └── integration/         # 集成测试
├── package.json            # 依赖配置
├── .env.example            # 环境变量示例
├── Dockerfile              # Docker 构建文件
└── docker-compose.yml      # Docker Compose 配置

const express = require('express');
const cors = require('cors');
const dotenv = require('dotenv');
const { createServer } = require('http');
const { Server } = require('socket.io');
const logger = require('./utils/logger');
const config = require('./config');

// 加载环境变量
dotenv.config();

// 创建 Express 应用
const app = express();

// 创建 HTTP 服务器
const httpServer = createServer(app);

// 创建 WebSocket 服务器
const io = new Server(httpServer, {
  cors: {
    origin: config.corsOrigins,
    methods: ['GET', 'POST', 'PUT', 'DELETE'],
    credentials: true
  }
});

// 中间件
app.use(cors({ origin: config.corsOrigins }));
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// 路由
const capabilitiesRoutes = require('./routes/capabilities.routes');
const toolsRoutes = require('./routes/tools.routes');

app.use('/api/v1/capabilities', capabilitiesRoutes);
app.use('/api/v1/tools', toolsRoutes);

// WebSocket 处理
const websocketService = require('./services/websocket.service');
websocketService.initialize(io);

// 健康检查
app.get('/health', (req, res) => {
  res.status(200).json({ status: 'healthy' });
});

// 根路径
app.get('/', (req, res) => {
  res.json({ message: 'MCP Server v2.0 is running' });
});

// 启动服务器
const PORT = process.env.PORT || 8000;
httpServer.listen(PORT, () => {
  logger.info(`MCP Server is running on port ${PORT}`);
});

module.exports = {
  // 服务器配置
  port: process.env.PORT || 8000,
  environment: process.env.NODE_ENV || 'development',
  
  // 安全配置
  jwtSecret: process.env.JWT_SECRET || 'your-secret-key',
  jwtExpiresIn: process.env.JWT_EXPIRES_IN || '30m',
  
  // 数据库配置
  databaseUrl: process.env.DATABASE_URL || 'mongodb://localhost:27017/mcp',
  
  // Redis 配置
  redisUrl: process.env.REDIS_URL || 'redis://localhost:6379/0',
  
  // CORS 配置
  corsOrigins: process.env.CORS_ORIGINS || '*',
  
  // 日志配置
  logLevel: process.env.LOG_LEVEL || 'info',
  logFile: process.env.LOG_FILE || null,
  
  // 工具配置
  toolRegistrationEnabled: process.env.TOOL_REGISTRATION_ENABLED || true,
  toolExecutionTimeout: process.env.TOOL_EXECUTION_TIMEOUT || 30,
  
  // WebSocket 配置
  websocketEnabled: process.env.WEBSOCKET_ENABLED || true
};

const logger = require('../utils/logger');
const config = require('../config');

class ToolService {
  constructor() {
    this.tools = new Map();
    this.initDefaultTools();
  }
  
  initDefaultTools() {
    // 注册默认工具
    this.registerTool({
      name: 'hello_world',
      description: '简单的 Hello World 工具',
      parameters: {
        name: {
          type: 'string',
          description: '要问候的名称',
          required: true
        },
        greeting: {
          type: 'string',
          description: '问候语',
          default: 'Hello'
        }
      },
      implementation: (params) => {
        const { name, greeting = 'Hello' } = params;
        return `${greeting}, ${name}!`;
      }
    });
    
    this.registerTool({
      name: 'add_numbers',
      description: '加法工具',
      parameters: {
        a: {
          type: 'number',
          description: '第一个数',
          required: true
        },
        b: {
          type: 'number',
          description: '第二个数',
          required: true
        }
      },
      implementation: (params) => {
        const { a, b } = params;
        return a + b;
      }
    });
  }
  
  registerTool(tool) {
    if (!config.toolRegistrationEnabled) {
      throw new Error('Tool registration is disabled');
    }
    
    logger.info(`Registering tool: ${tool.name}`);
    this.tools.set(tool.name, {
      ...tool,
      usageCount: 0,
      createdAt: new Date(),
      updatedAt: new Date()
    });
  }
  
  getTool(toolName) {
    return this.tools.get(toolName);
  }
  
  async executeTool(toolName, params, userId) {
    const tool = this.getTool(toolName);
    if (!tool) {
      throw new Error(`Tool ${toolName} not found`);
      
    }
    
    try {
      // 验证参数
      this.validateParams(tool, params);
      
      // 执行工具
      let result;
      if (typeof tool.implementation === 'function') {
        if (tool.implementation.constructor.name === 'AsyncFunction') {
          // 异步执行
          result = await Promise.race([
            tool.implementation(params),
            new Promise((_, reject) => 
              setTimeout(() => reject(new Error('Tool execution timed out')), config.toolExecutionTimeout * 1000)
            )
          ]);
        } else {
          // 同步执行
          result = tool.implementation(params);
        }
      } else {
        throw new Error(`Tool ${toolName} has no implementation`);
      }
      
      // 更新使用次数
      tool.usageCount += 1;
      tool.updatedAt = new Date();
      this.tools.set(toolName, tool);
      
      logger.info(`Tool ${toolName} executed successfully by user ${userId}`);
      return { success: true, result };
    } catch (error) {
      logger.error(`Tool ${toolName} execution failed: ${error.message}`);
      return { success: false, error: error.message };
    }
  }
  
  validateParams(tool, params) {
    // 简单的参数验证
    const requiredParams = Object.keys(tool.parameters).filter(
      key => tool.parameters[key].required
    );
    
    for (const param of requiredParams) {
      if (!(param in params)) {
        throw new Error(`Missing required parameter: ${param}`);
      }
    }
  }
  
  listTools() {
    return Array.from(this.tools.values()).map(tool => ({
      name: tool.name,
      description: tool.description,
      parameters: tool.parameters,
      version: tool.version || '1.0.0',
      author: tool.author || 'unknown',
      usageCount: tool.usageCount,
      createdAt: tool.createdAt,
      updatedAt: tool.updatedAt
    }));
  }
}

module.exports = new ToolService();

const toolService = require('../services/tool.service');
const authService = require('../services/auth.service');
const logger = require('../utils/logger');

class ToolsController {
  // 获取工具列表
  static async getTools(req, res) {
    try {
      const tools = toolService.listTools();
      res.status(200).json(tools);
    } catch (error) {
      logger.error(`Error getting tools: ${error.message}`);
      res.status(500).json({ error: 'Internal server error' });
    }
  }
  
  // 获取工具详情
  static async getTool(req, res) {
    try {
      const { toolName } = req.params;
      const tool = toolService.getTool(toolName);
      if (!tool) {
        return res.status(404).json({ error: `Tool ${toolName} not found` });
      }
      res.status(200).json(tool);
    } catch (error) {
      logger.error(`Error getting tool ${req.params.toolName}: ${error.message}`);
      res.status(500).json({ error: 'Internal server error' });
    }
  }
  
  // 注册工具
  static async registerTool(req, res) {
    try {
      // 验证权限
      const token = req.headers.authorization?.split(' ')[1];
      if (!token) {
        return res.status(401).json({ error: 'Unauthorized' });
      }
      
      const user = authService.verifyToken(token);
      if (!user) {
        return res.status(401).json({ error: 'Invalid token' });
      }
      
      // 检查用户权限
      if (!user.scopes.includes('tool:register')) {
        return res.status(403).json({ error: 'Insufficient permissions' });
      }
      
      // 注册工具
      toolService.registerTool(req.body);
      res.status(201).json({ message: 'Tool registered successfully' });
    } catch (error) {
      logger.error(`Error registering tool: ${error.message}`);
      res.status(400).json({ error: error.message });
    }
  }
  
  // 执行工具
  static async executeTool(req, res) {
    try {
      const { toolName } = req.params;
      const params = req.body;
      
      // 验证权限
      const token = req.headers.authorization?.split(' ')[1];
      let userId = 'anonymous';
      
      if (token) {
        const user = authService.verifyToken(token);
        if (user) {
          userId = user.id;
        }
      }
      
      // 执行工具
      const result = await toolService.executeTool(toolName, params, userId);
      res.status(200).json(result);
    } catch (error) {
      logger.error(`Error executing tool ${req.params.toolName}: ${error.message}`);
      res.status(400).json({ error: error.message });
    }
  }
}

module.exports = ToolsController;

const logger = require('../utils/logger');
const toolService = require('./tool.service');

class WebSocketService {
  initialize(io) {
    this.io = io;
    this.connections = new Map();
    
    io.on('connection', (socket) => {
      const connectionId = socket.id;
      logger.info(`New WebSocket connection: ${connectionId}`);
      
      // 存储连接
      this.connections.set(connectionId, { socket, userId: 'anonymous' });
      
      // 处理 ping 消息
      socket.on('ping', () => {
        socket.emit('pong', { timestamp: new Date().toISOString() });
      });
      
      // 处理工具调用
      socket.on('tool_call', async (data) => {
        try {
          const result = await toolService.executeTool(
            data.toolName,
            data.params,
            connectionId
          );
          socket.emit('tool_result', {
            correlationId: data.correlationId,
            result
          });
        } catch (error) {
          socket.emit('tool_error', {
            correlationId: data.correlationId,
            error: error.message
          });
        }
      });
      
      // 处理断开连接
      socket.on('disconnect', () => {
        logger.info(`WebSocket connection closed: ${connectionId}`);
        this.connections.delete(connectionId);
        
        // 广播用户断开连接
        io.emit('user_disconnected', { connectionId });
      });
    });
  }
  
  sendMessage(connectionId, message) {
    const connection = this.connections.get(connectionId);
    if (connection) {
      connection.socket.emit('message', message);
    }
  }
  
  broadcast(message) {
    this.io.emit('broadcast', message);
  }
  
  getConnectionCount() {
    return this.connections.size;
  }
  
  getConnections() {
    return Array.from(this.connections.keys());
  }
}

module.exports = new WebSocketService();

mcp-server-nestjs/
├── src/
│   ├── main.ts             # 应用入口
│   ├── app.module.ts        # 根模块
│   ├── config/             # 配置文件
│   │   └── config.service.ts
│   ├── capabilities/       # 能力协商模块
│   │   ├── capabilities.controller.ts
│   │   ├── capabilities.module.ts
│   │   └── capabilities.service.ts
│   ├── tools/              # 工具模块
│   │   ├── tool.controller.ts
│   │   ├── tool.module.ts
│   │   ├── tool.service.ts
│   │   ├── tool.model.ts
│   │   └── dto/            # 数据传输对象
│   │       ├── create-tool.dto.ts
│   │       └── execute-tool.dto.ts
│   ├── auth/               # 认证模块
│   │   ├── auth.controller.ts
│   │   ├── auth.module.ts
│   │   ├── auth.service.ts
│   │   └── jwt.strategy.ts
│   ├── websocket/          # WebSocket 模块
│   │   ├── websocket.gateway.ts
│   │   └── websocket.module.ts
│   ├── middleware/         # 中间件
│   │   └── logging.middleware.ts
│   └── shared/             # 共享模块
│       ├── logger/         # 日志服务
│       └── validator/      # 验证服务
├── test/                   # 测试用例
│   ├── app.e2e-spec.ts
│   └── jest-e2e.json
├── package.json            # 依赖配置
├── tsconfig.json           # TypeScript 配置
├── .env.example            # 环境变量示例
├── Dockerfile              # Docker 构建文件
└── docker-compose.yml      # Docker Compose 配置

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { Logger } from '@nestjs/common';
import { ConfigService } from './config/config.service';
import { LoggingMiddleware } from './middleware/logging.middleware';

async function bootstrap() {
  const logger = new Logger('Bootstrap');
  
  // 创建 Nest 应用
  const app = await NestFactory.create(AppModule);
  
  // 获取配置
  const configService = app.get(ConfigService);
  
  // 中间件
  app.use(LoggingMiddleware);
  
  // CORS 配置
  app.enableCors({
    origin: configService.get('CORS_ORIGINS'),
    methods: ['GET', 'POST', 'PUT', 'DELETE'],
    credentials: true,
  });
  
  // 全局前缀
  app.setGlobalPrefix('api/v1');
  
  // 启动服务器
  const port = configService.get('PORT');
  await app.listen(port);
  
  logger.log(`MCP Server is running on http://localhost:${port}`);
}

bootstrap();

import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { CapabilitiesModule } from './capabilities/capabilities.module';
import { ToolsModule } from './tools/tool.module';
import { AuthModule } from './auth/auth.module';
import { WebSocketModule } from './websocket/websocket.module';
import { ConfigService } from './config/config.service';

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true,
      envFilePath: '.env',
    }),
    CapabilitiesModule,
    ToolsModule,
    AuthModule,
    WebSocketModule,
  ],
  controllers: [AppController],
  providers: [AppService, ConfigService],
})
export class AppModule {}

import { Module } from '@nestjs/common';
import { ToolController } from './tool.controller';
import { ToolService } from './tool.service';

@Module({
  controllers: [ToolController],
  providers: [ToolService],
  exports: [ToolService],
})
export class ToolsModule {}

import { Injectable, NotFoundException, BadRequestException } from '@nestjs/common';
import { CreateToolDto } from './dto/create-tool.dto';
import { ExecuteToolDto } from './dto/execute-tool.dto';
import { ConfigService } from '../config/config.service';

@Injectable()
export class ToolService {
  private tools: Map<string, any> = new Map();
  
  constructor(private configService: ConfigService) {
    this.initDefaultTools();
  }
  
  private initDefaultTools() {
    // 注册默认工具
    this.registerTool({
      name: 'hello_world',
      description: '简单的 Hello World 工具',
      parameters: {
        name: {
          type: 'string',
          description: '要问候的名称',
          required: true,
        },
        greeting: {
          type: 'string',
          description: '问候语',
          default: 'Hello',
        },
      },
      implementation: (params: any) => {
        const { name, greeting = 'Hello' } = params;
        return `${greeting}, ${name}!`;
      },
    });
    
    this.registerTool({
      name: 'add_numbers',
      description: '加法工具',
      parameters: {
        a: {
          type: 'number',
          description: '第一个数',
          required: true,
        },
        b: {
          type: 'number',
          description: '第二个数',
          required: true,
        },
      },
      implementation: (params: any) => {
        const { a, b } = params;
        return a + b;
      },
    });
  }
  
  registerTool(tool: CreateToolDto) {
    const toolRegistrationEnabled = this.configService.get('TOOL_REGISTRATION_ENABLED');
    if (!toolRegistrationEnabled) {
      throw new BadRequestException('Tool registration is disabled');
    }
    
    this.tools.set(tool.name, {
      ...tool,
      usageCount: 0,
      createdAt: new Date(),
      updatedAt: new Date(),
    });
    
    return tool;
  }
  
  getTool(toolName: string) {
    const tool = this.tools.get(toolName);
    if (!tool) {
      throw new NotFoundException(`Tool ${toolName} not found`);
    }
    return tool;
  }
  
  async executeTool(toolName: string, params: ExecuteToolDto, userId: string) {
    const tool = this.getTool(toolName);
    
    try {
      // 验证参数
      this.validateParams(tool, params);
      
      // 执行工具
      let result;
      if (typeof tool.implementation === 'function') {
        if (tool.implementation.constructor.name === 'AsyncFunction') {
          // 异步执行
          result = await Promise.race([
            tool.implementation(params),
            new Promise((_, reject) => 
              setTimeout(() => reject(new Error('Tool execution timed out')), this.configService.get('TOOL_EXECUTION_TIMEOUT') * 1000)
            ),
          ]);
        } else {
          // 同步执行
          result = tool.implementation(params);
        }
      } else {
        throw new Error(`Tool ${toolName} has no implementation`);
      }
      
      // 更新使用次数
      tool.usageCount += 1;
      tool.updatedAt = new Date();
      this.tools.set(toolName, tool);
      
      return { success: true, result };
    } catch (error) {
      return { success: false, error: error.message };
    }
  }
  
  private validateParams(tool: any, params: any) {
    // 简单的参数验证
    const requiredParams = Object.keys(tool.parameters).filter(
      (key) => tool.parameters[key].required,
    );
    
    for (const param of requiredParams) {
      if (!(param in params)) {
        throw new BadRequestException(`Missing required parameter: ${param}`);
      }
    }
  }
  
  listTools() {
    return Array.from(this.tools.values()).map((tool) => ({
      name: tool.name,
      description: tool.description,
      parameters: tool.parameters,
      version: tool.version || '1.0.0',
      author: tool.author || 'unknown',
      usageCount: tool.usageCount,
      createdAt: tool.createdAt,
      updatedAt: tool.updatedAt,
    }));
  }
}

import { WebSocketGateway, WebSocketServer, SubscribeMessage, OnGatewayConnection, OnGatewayDisconnect } from '@nestjs/websockets';
import { Server, Socket } from 'socket.io';
import { ToolService } from '../tools/tool.service';
import { Logger } from '@nestjs/common';

@WebSocketGateway({
  cors: {
    origin: '*',
  },
})
export class WebSocketGateway implements OnGatewayConnection, OnGatewayDisconnect {
  @WebSocketServer()
  server: Server;
  
  private readonly logger = new Logger(WebSocketGateway.name);
  private connections: Map<string, { socket: Socket; userId: string }> = new Map();
  
  constructor(private toolService: ToolService) {}
  
  handleConnection(client: Socket) {
    const connectionId = client.id;
    this.logger.log(`New WebSocket connection: ${connectionId}`);
    this.connections.set(connectionId, { socket: client, userId: 'anonymous' });
  }
  
  handleDisconnect(client: Socket) {
    const connectionId = client.id;
    this.logger.log(`WebSocket connection closed: ${connectionId}`);
    this.connections.delete(connectionId);
    
    // 广播用户断开连接
    this.server.emit('user_disconnected', { connectionId });
  }
  
  @SubscribeMessage('ping')
  handlePing(client: Socket) {
    client.emit('pong', { timestamp: new Date().toISOString() });
  }
  
  @SubscribeMessage('tool_call')
  async handleToolCall(client: Socket, data: any) {
    try {
      const result = await this.toolService.executeTool(
        data.toolName,
        data.params,
        client.id,
      );
      client.emit('tool_result', {
        correlationId: data.correlationId,
        result,
      });
    } catch (error) {
      client.emit('tool_error', {
        correlationId: data.correlationId,
        error: error.message,
      });
    }
  }
  
  @SubscribeMessage('broadcast')
  handleBroadcast(client: Socket, data: any) {
    this.server.emit('broadcast_message', {
      sender: client.id,
      message: data.message,
    });
  }
}

# 安装依赖
npm install

# 启动开发服务器
npm run dev

# 启动生产服务器
npm start

# 安装依赖
npm install

# 启动开发服务器
npm run start:dev

# 启动生产服务器
npm run start:prod

const axios = require('axios');

// 服务器配置
const BASE_URL = 'http://localhost:8000/api/v1';

// 测试工具列表
async function testListTools() {
  try {
    const response = await axios.get(`${BASE_URL}/tools`);
    console.log('List tools status:', response.status);
    console.log('List tools response:', JSON.stringify(response.data, null, 2));
  } catch (error) {
    console.error('Error listing tools:', error.message);
  }
}

// 测试 hello_world 工具
async function testHelloWorld() {
  try {
    const payload = { name: 'MCP', greeting: 'Hello' };
    const response = await axios.post(`${BASE_URL}/tools/hello_world/execute`, payload);
    console.log('Hello world status:', response.status);
    console.log('Hello world response:', JSON.stringify(response.data, null, 2));
  } catch (error) {
    console.error('Error executing hello_world:', error.message);
  }
}

// 主测试函数
async function main() {
  console.log('Testing MCP Server...');
  await testListTools();
  console.log('\n' + '='.repeat(50) + '\n');
  await testHelloWorld();
  console.log('\n' + '='.repeat(50) + '\n');
  console.log('Testing completed!');
}

main();

{
  "name": "mcp-server-express",
  "version": "1.0.0",
  "description": "MCP Server implemented with Express",
  "main": "src/app.js",
  "scripts": {
    "dev": "nodemon src/app.js",
    "start": "node src/app.js",
    "lint": "eslint src/**/*.js",
    "test": "jest"
  },
  "dependencies": {
    "express": "^4.18.2",
    "cors": "^2.8.5",
    "dotenv": "^16.3.1",
    "jsonwebtoken": "^9.0.2",
    "socket.io": "^4.7.2",
    "winston": "^3.11.0",
    "express-validator": "^7.0.1"
  },
  "devDependencies": {
    "nodemon": "^3.0.1",
    "eslint": "^8.56.0",
    "jest": "^29.7.0",
    "supertest": "^6.3.3"
  }
}

{
  "name": "mcp-server-nestjs",
  "version": "1.0.0",
  "description": "MCP Server implemented with NestJS",
  "scripts": {
    "build": "nest build",
    "start": "nest start",
    "start:dev": "nest start --watch",
    "start:debug": "nest start --debug --watch",
    "start:prod": "node dist/main",
    "lint": "eslint "{src,apps,libs,test}/**/*.ts" --fix",
    "test": "jest",
    "test:watch": "jest --watch",
    "test:cov": "jest --coverage",
    "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
    "test:e2e": "jest --config ./test/jest-e2e.json"
  },
  "dependencies": {
    "@nestjs/common": "^10.0.0",
    "@nestjs/core": "^10.0.0",
    "@nestjs/platform-express": "^10.0.0",
    "@nestjs/platform-socket.io": "^10.0.0",
    "@nestjs/websockets": "^10.0.0",
    "@nestjs/config": "^3.1.1",
    "@nestjs/jwt": "^10.2.0",
    "@nestjs/passport": "^10.0.3",
    "passport": "^0.7.0",
    "passport-jwt": "^4.0.1",
    "socket.io": "^4.7.2",
    "reflect-metadata": "^0.1.13",
    "rxjs": "^7.8.1"
  },
  "devDependencies": {
    "@nestjs/cli": "^10.0.0",
    "@nestjs/schematics": "^10.0.0",
    "@nestjs/testing": "^10.0.0",
    "@types/express": "^4.17.17",
    "@types/jest": "^29.5.2",
    "@types/node": "^20.3.1",
    "@types/passport-jwt": "^4.0.1",
    "@types/supertest": "^2.0.12",
    "@typescript-eslint/eslint-plugin": "^6.0.0",
    "@typescript-eslint/parser": "^6.0.0",
    "eslint": "^8.42.0",
    "eslint-config-prettier": "^9.0.0",
    "eslint-plugin-prettier": "^5.0.0",
    "jest": "^29.5.0",
    "prettier": "^3.0.0",
    "source-map-support": "^0.5.21",
    "supertest": "^6.3.3",
    "ts-jest": "^29.1.0",
    "ts-loader": "^9.4.3",
    "ts-node": "^10.9.1",
    "tsconfig-paths": "^4.2.0",
    "typescript": "^5.1.3"
  }
}

# 使用 Node.js 18 作为基础镜像
FROM node:18-alpine

# 设置工作目录
WORKDIR /app

# 安装系统依赖
RUN apk add --no-cache gcc g++ make python3

# 复制 package.json 和 package-lock.json
COPY package*.json ./

# 安装依赖
RUN npm ci --only=production

# 复制应用代码
COPY src ./src

# 暴露端口
EXPOSE 8000

# 设置环境变量
ENV NODE_ENV=production

# 启动应用
CMD ["node", "src/app.js"]

# 使用 Node.js 18 作为基础镜像
FROM node:18-alpine AS builder

# 设置工作目录
WORKDIR /app

# 安装系统依赖
RUN apk add --no-cache gcc g++ make python3

# 复制 package.json 和 package-lock.json
COPY package*.json ./

# 安装依赖
RUN npm ci

# 复制应用代码
COPY . .

# 构建应用
RUN npm run build

# 使用轻量级镜像
FROM node:18-alpine

# 设置工作目录
WORKDIR /app

# 复制构建结果和依赖
COPY --from=builder /app/package*.json ./
COPY --from=builder /app/dist ./dist
RUN npm ci --only=production

# 暴露端口
EXPOSE 8000

# 设置环境变量
ENV NODE_ENV=production

# 启动应用
CMD ["node", "dist/main"]