huxy-node-server 1.0.0-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 yiru
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,490 @@
+# Huxy Node Server
+
+[![Node.js Version](https://img.shields.io/badge/node.js-%3E%3D20.0.0-brightgreen)](https://nodejs.org/)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![Express.js](https://img.shields.io/badge/express.js-5.x-blue)](https://expressjs.com/)
+
+一个精炼、高性能的 Express.js 服务器模板，为现代 Node.js 应用程序设计，提供灵活的功能和最佳实践。
+
+## 🚀 特性
+
+### 核心功能
+- **现代 ES 模块支持**：使用 `"type": "module"` 完全支持 ES Modules
+- **高性能日志**：集成 Pino 日志系统，支持彩色输出和多级别日志
+- **安全防护**：内置 Helmet 安全中间件，提供 CSP、XSS 等多种安全防护
+- **请求限制**：基于 IP 的请求速率限制，防止 DDoS 和暴力攻击
+- **跨域支持**：灵活的 CORS 配置，支持多域名和凭证
+- **压缩支持**：自动 GZIP 压缩响应，减少带宽使用
+- **健康检查**：内置 `/health` 端点，监控服务器状态
+- **优雅关闭**：处理 SIGTERM 和 SIGINT 信号，确保服务器优雅关闭
+
+### 生产环境特性
+- **环境变量支持**：通过 dotenv 管理配置，支持 `.env` 文件
+- **错误处理**：全局错误处理中间件，提供详细错误日志
+- **请求日志**：详细的 HTTP 请求日志，包括响应时间、状态码等
+- **端口检查**：自动检测端口是否被占用，并自动选择可用端口
+- **内存监控**：实时监控服务器内存使用情况
+- **多网络接口支持**：自动检测本地 IP 地址，支持多网卡环境
+
+### 开发者友好
+- **热重载**：开发环境支持 `--watch` 模式，自动重载代码
+- **详细文档**：完整的 API 文档和使用示例
+- **模块化设计**：清晰的代码结构，易于扩展和定制
+- **TypeScript 友好**：代码结构适合 TypeScript 迁移
+
+## 📦 安装
+
+```bash
+# 通过 npm 安装
+npm install huxy-node-server
+
+# 或者通过 yarn 安装
+yarn add huxy-node-server
+
+# 或者通过 pnpm 安装
+pnpm add huxy-node-server
+```
+
+## 🚀 快速开始
+
+### 基本使用
+
+```javascript
+import { startServer } from 'huxy-node-server';
+
+// 启动服务器
+const { app, config, httpServer } = await startServer({
+  port: 3000,
+  host: '0.0.0.0',
+  basepath: '/api',
+  // 其他配置...
+}, (config, app, httpServer) => {
+  // 可以在这里添加自定义路由
+  app.get('/hello', (req, res) => {
+    res.json({ message: 'Hello World!' });
+  });
+});
+```
+
+### 静态文件服务
+
+```javascript
+import { startStatic } from 'huxy-node-server';
+
+// 启动静态文件服务器
+const server = await startStatic({
+  port: 9000,
+  basepath: '/',
+  buildPath: './dist',  // 静态文件目录
+});
+```
+
+## 🛠️ 配置选项
+
+### 服务器配置
+
+| 选项 | 类型 | 默认值 | 描述 |
+|------|------|--------|------|
+| `port` | number | 3000 | 服务器端口 |
+| `host` | string | '0.0.0.0' | 服务器主机 |
+| `basepath` | string | '/' | 基础路径前缀 |
+| `nodeEnv` | string | 'development' | 运行环境 |
+| `appName` | string | 'HuxyServer' | 应用名称 |
+
+### 安全配置
+
+```javascript
+{
+  helmet: {
+    contentSecurityPolicy: {
+      directives: {
+        defaultSrc: ["'self'"],
+        styleSrc: ["'self'", "'unsafe-inline'"],
+        scriptSrc: ["'self'"],
+        imgSrc: ["'self'", "data:", "https:"]
+      }
+    },
+    crossOriginEmbedderPolicy: false
+  }
+}
+```
+
+### CORS 配置
+
+```javascript
+{
+  cors: {
+    origin: ['http://example.com', 'http://localhost:3000'], // 或 '*'
+    credentials: true
+  }
+}
+```
+
+### 请求速率限制
+
+```javascript
+{
+  rateLimit: {
+    windowMs: 900000, // 15 分钟
+    limit: 100, // 每个窗口内最大请求数
+    message: {
+      error: '请求过于频繁，请稍后再试'
+    }
+  }
+}
+```
+
+### 日志配置
+
+```javascript
+{
+  logLevel: 30, // 日志级别 (10=trace, 20=debug, 30=info, 40=warn, 50=error, 60=fatal)
+}
+```
+
+## 🌍 环境变量
+
+可以通过环境变量配置服务器：
+
+```bash
+# .env 文件
+NODE_ENV=production
+PORT=3000
+HOST=0.0.0.0
+BASEPATH=/api
+CORS_ORIGIN=http://example.com,http://localhost:3000
+RATE_LIMIT_WINDOW_MS=900000
+RATE_LIMIT_MAX_REQUESTS=100
+LOG_LEVEL=30
+```
+
+或者通过命令行参数：
+
+```bash
+node server.js port=3000 host=localhost
+```
+
+## 📂 目录结构
+
+```
+.
+├── src/
+│   ├── app.js              # Express 应用配置
+│   ├── config.js           # 默认配置
+│   ├── server.js           # 服务器启动逻辑
+│   ├── routes.js           # 默认路由
+│   ├── middleware.js       # 中间件集合
+│   ├── logger.js           # 日志系统
+│   ├── utils.js            # 工具函数
+│   ├── staticServer.js     # 静态文件服务器
+│   └── resolvePath.js      # 路径解析工具
+├── example.js             # 使用示例
+└── package.json
+```
+
+## 🔧 高级用法
+
+### 自定义中间件
+
+```javascript
+import { startServer } from 'huxy-node-server';
+import customMiddleware from './customMiddleware';
+
+const { app } = await startServer({
+  port: 3000,
+}, (config, app) => {
+  // 添加自定义中间件
+  app.use(customMiddleware);
+  
+  // 添加自定义路由
+  app.get('/custom', (req, res) => {
+    res.json({ custom: 'route' });
+  });
+});
+```
+
+### 自定义错误处理
+
+```javascript
+import { startServer } from 'huxy-node-server';
+
+const { app } = await startServer({
+  port: 3000,
+}, (config, app) => {
+  // 添加自定义错误处理
+  app.use((err, req, res, next) => {
+    if (err instanceof CustomError) {
+      res.status(400).json({ error: err.message });
+    } else {
+      next(err);
+    }
+  });
+});
+```
+
+### 自定义日志
+
+```javascript
+import { startServer, createLogger } from 'huxy-node-server';
+
+const customLogger = createLogger('custom-module', {
+  level: 'debug',
+  transport: {
+    target: 'pino-pretty',
+    options: { colorize: true }
+  }
+});
+
+customLogger.info('自定义日志消息');
+```
+
+### 与数据库集成
+
+```javascript
+import { startServer } from 'huxy-node-server';
+import mongoose from 'mongoose';
+
+const { app } = await startServer({
+  port: 3000,
+}, async (config, app) => {
+  // 连接到 MongoDB
+  await mongoose.connect(config.DATABASE_URL, {
+    useNewUrlParser: true,
+    useUnifiedTopology: true,
+  });
+  
+  // 添加数据库中间件
+  app.use((req, res, next) => {
+    req.db = mongoose.connection;
+    next();
+  });
+  
+  // 添加 API 路由
+  app.get('/api/users', async (req, res) => {
+    const users = await req.db.collection('users').find().toArray();
+    res.json({ success: true, data: users });
+  });
+});
+```
+
+## 📊 API 文档
+
+### `startServer(config, callback)`
+
+启动 Express 服务器
+
+**参数:**
+
+- `config` (Object): 服务器配置对象
+- `callback` (Function): 可选的回调函数，在服务器启动后调用
+
+**返回:** Promise<{app, config, httpServer}>
+
+### `startStatic(config, callback)`
+
+启动静态文件服务器
+
+**参数:**
+
+- `config` (Object): 服务器配置对象
+- `callback` (Function): 可选的回调函数，在服务器启动后调用
+
+**返回:** Promise<{app, config, httpServer}>
+
+### `createLogger(name, customConfig)`
+
+创建自定义日志实例
+
+**参数:**
+
+- `name` (String): 日志实例名称
+- `customConfig` (Object): 自定义配置
+
+**返回:** Pino 日志实例
+
+### `logger`
+
+默认日志实例
+
+### 工具函数
+
+- `dateTime()`: 获取当前时间字符串
+- `localIPs()`: 获取本地 IP 地址列表
+- `nodeArgs()`: 解析命令行参数
+- `getEnvConfig()`: 获取环境变量配置
+- `checkPort()`: 检查端口是否可用
+- `resolvePath()`: 解析文件路径
+
+## 🛡️ 安全最佳实践
+
+### 1. 环境变量
+
+永远不要在代码中硬编码敏感信息，使用环境变量：
+
+```bash
+# .env 文件
+JWT_SECRET=your_secret_key_here
+DATABASE_URL=your_database_url
+```
+
+### 2. HTTPS
+
+在生产环境中，始终使用 HTTPS。可以使用反向代理（如 Nginx）或直接配置：
+
+```javascript
+import https from 'https';
+import fs from 'fs';
+
+const options = {
+  key: fs.readFileSync('server.key'),
+  cert: fs.readFileSync('server.cert')
+};
+
+https.createServer(options, app).listen(443);
+```
+
+### 3. 速率限制
+
+根据您的应用需求调整速率限制：
+
+```javascript
+{
+  rateLimit: {
+    windowMs: 15 * 60 * 1000, // 15 分钟
+    limit: 100, // 每个 IP 每个窗口内最大请求数
+    message: '太多请求，请稍后再试'
+  }
+}
+```
+
+### 4. CORS
+
+在生产环境中，限制 CORS 来源：
+
+```javascript
+{
+  cors: {
+    origin: ['https://yourdomain.com', 'https://yourapp.com'],
+    credentials: true
+  }
+}
+```
+
+### 5. 安全头
+
+根据需要调整 Helmet 配置：
+
+```javascript
+{
+  helmet: {
+    contentSecurityPolicy: {
+      directives: {
+        defaultSrc: ["'self'"],
+        scriptSrc: ["'self'", "'unsafe-inline'", "https://cdn.example.com"],
+        // 其他 CSP 指令...
+      }
+    }
+  }
+}
+```
+
+## 🚀 部署
+
+### Docker 部署
+
+```dockerfile
+# Dockerfile
+FROM node:20-alpine
+
+WORKDIR /app
+
+COPY package*.json ./
+RUN npm install --production
+
+COPY . .
+
+EXPOSE 3000
+
+CMD ["node", "src/index.js"]
+```
+
+构建并运行：
+
+```bash
+docker build -t huxy-server .
+docker run -p 3000:3000 -d huxy-server
+```
+
+### PM2 部署
+
+```bash
+# 安装 PM2
+npm install -g pm2
+
+# 启动服务
+pm2 start src/index.js --name huxy-server
+
+# 保存进程列表
+pm2 save
+
+# 设置开机启动
+pm2 startup
+```
+
+### Nginx 反向代理
+
+```nginx
+server {
+    listen 80;
+    server_name yourdomain.com;
+
+    location / {
+        proxy_pass http://localhost:3000;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+        proxy_set_header Host $host;
+        proxy_cache_bypass $http_upgrade;
+    }
+}
+```
+
+## 📝 许可证
+
+MIT © [ahyiru](https://github.com/ahyiru)
+
+## 🤝 贡献
+
+欢迎贡献！请遵循以下步骤：
+
+1. Fork 仓库
+2. 创建您的特性分支 (`git checkout -b feature/AmazingFeature`)
+3. 提交您的更改 (`git commit -m 'Add some AmazingFeature'`)
+4. 推送到分支 (`git push origin feature/AmazingFeature`)
+5. 打开一个 Pull Request
+
+## 📞 支持
+
+如果您有任何问题或建议，请通过以下方式联系：
+
+- GitHub Issues: https://github.com/ahyiru/huxy-node-server/issues
+- 电子邮件: ahyiru@example.com
+
+## 📄 详细文档
+
+- [文档索引](https://github.com/ahyiru/huxy-node-server/blob/main/docs/INDEX.md)
+- [API 文档](https://github.com/ahyiru/huxy-node-server/blob/main/docs/API.md)
+- [配置指南](https://github.com/ahyiru/huxy-node-server/blob/main/docs/CONFIGURATION.md)
+- [部署指南](https://github.com/ahyiru/huxy-node-server/blob/main/docs/DEPLOYMENT.md)
+- [更新日志](https://github.com/ahyiru/huxy-node-server/blob/main/CHANGELOG.md)
+
+## 📚 相关资源
+
+- [Express.js 文档](https://expressjs.com/)
+- [Pino 日志文档](https://getpino.io/)
+- [Helmet 安全文档](https://helmetjs.github.io/)
+- [Node.js 文档](https://nodejs.org/docs/)
+
+---
+
+✨ **Huxy Node Server** - 为现代 Web 应用程序提供强大、可靠的后端解决方案！

package/example.js

@@ -0,0 +1,34 @@
+import {startServer, startStatic, logger, createLogger, dateTime} from './src/index.js';
+
+logger.info(dateTime());
+
+const testLogger = createLogger('test');
+
+testLogger.info({x: 123}, '测试');
+logger.error({status: 400}, 'HTTP请求错误');
+
+// startServer
+const {app, config, httpServer} = await startServer({
+  port: 8080,
+  host: 'localhost',
+  // ...
+}, (config, app, httpServer) => {
+  app.get('/config', (req, res) => {
+    logger.info('详细配置：', config);
+    res.status(200).json({ 
+      result: config,
+    });
+  });
+});
+
+// startStatic
+const huxyServer = await startStatic({
+  port: 9000,
+  basepath: '/',
+  buildPath: './build',
+}, (config, app) => {
+  logger.info(config);
+});
+
+
+// 启动服务可加参数如：node example.js port=8080 或 PORT=8080 node example.js

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "huxy-node-server",
+  "version": "1.0.0-beta.0",
+  "description": "一个精炼、高性能的 Express.js 服务器模板，为现代 Node.js 应用程序设计，提供灵活的功能和最佳实践。",
+  "type": "module",
+  "module": "./src/index.js",
+  "exports": {
+    ".": {
+      "import": "./src/index.js"
+    },
+    "./*": {
+      "import": "./src/*.js"
+    }
+  },
+  "scripts": {
+    "start": "node ./src/index.js",
+    "dev": "NODE_ENV=development node --watch ./src/index.js"
+  },
+  "keywords": [
+    "express",
+    "nodejs",
+    "esm",
+    "server",
+    "huxy"
+  ],
+  "author": "ahyiru",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ahyiru/huxy-node-server/issues"
+  },
+  "homepage": "https://github.com/ahyiru/huxy-node-server#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ahyiru/huxy-node-server.git"
+  },
+  "dependencies": {
+    "compression": "^1.8.1",
+    "cors": "^2.8.5",
+    "dotenv": "^17.2.3",
+    "express": "^5.2.1",
+    "express-rate-limit": "^8.2.1",
+    "helmet": "^8.1.0",
+    "pino": "^10.1.0",
+    "pino-http": "^11.0.0",
+    "pino-pretty": "^13.1.3"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/src/index.js

@@ -0,0 +1,226 @@
+import T from 'express';
+import V from 'helmet';
+import F from 'cors';
+import {rateLimit as K, ipKeyGenerator as W} from 'express-rate-limit';
+import z from 'compression';
+import X from 'pino-http';
+import {createServer as B} from 'node:http';
+import U from 'pino';
+import w from 'node:os';
+import D from 'node:net';
+var m = (t = new Date()) => t.toLocaleString('zh-CN', {timeZone: 'Asia/Shanghai', hour12: !1}),
+  l = t => {
+    let o = t ? 'https' : 'http',
+      e = w.networkInterfaces(),
+      r = [];
+    return (Object.keys(e).map(i => r.push(...e[i])), r.filter(i => i.family === 'IPv4').map(i => `${o}://${i.address}`));
+  },
+  x = t => {
+    let o = t ?? process.argv.slice(2) ?? [],
+      e = {};
+    return (
+      o.map(r => {
+        let [n, s] = r.split('=');
+        e[n] = s;
+      }),
+      e
+    );
+  },
+  H = {
+    NODE_ENV: 'nodeEnv',
+    PORT: 'port',
+    STATIC_PORT: 'staticPort',
+    HOST: 'host',
+    BASEPATH: 'basepath',
+    CORS_ORIGIN: 'cors.origin',
+    RATE_LIMIT_WINDOW_MS: 'rateLimit.windowMs',
+    RATE_LIMIT_MAX_REQUESTS: 'rateLimit.limit',
+    LOG_LEVEL: 'logLevel',
+    API_PREFIX: 'apiPrefix',
+    JWT_SECRET: 'secret',
+    AUTH_TOKEN: 'authToken',
+  },
+  M = (t, o, e) => {
+    let [r, n] = t.split('.');
+    r && n ? (e[r] || (e[r] = {}), (e[r][n] = o)) : (e[r] = o);
+  },
+  u = (t = {}, o = H) => {
+    let {env: e} = process;
+    Object.keys(o).map(n => {
+      let s = e[n];
+      s && M(o[n], s, t);
+    });
+    let r = {...t, ...x()};
+    return ((r.port = r.staticPort || r.port), (r.isDev = r.NODE_ENV === 'development'), r);
+  },
+  d = (t, o = '127.0.0.1') =>
+    new Promise(e => {
+      let r = D.createServer();
+      (r.once('error', n => {
+        (r.close(), e((n.code === 'EADDRINUSE', !1)));
+      }),
+        r.once('listening', () => {
+          (r.close(), e(!0));
+        }),
+        r.listen(Number(t), o));
+    });
+import 'dotenv';
+var k = {
+    nodeEnv: 'production',
+    isDev: !1,
+    port: parseInt(process.env.PORT || '3000', 10),
+    host: process.env.HOST || '0.0.0.0',
+    basepath: process.env.BASEPATH || '/',
+    cors: {origin: process.env.CORS_ORIGIN?.split(',') || '*', credentials: !0},
+    rateLimit: {
+      windowMs: parseInt(process.env.RATE_LIMIT_WINDOW_MS || '900000', 10),
+      limit: parseInt(process.env.RATE_LIMIT_MAX_REQUESTS || '100', 10),
+      message: {error: '\u8BF7\u6C42\u8FC7\u4E8E\u9891\u7E41\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5'},
+    },
+    helmet: {
+      contentSecurityPolicy: {directives: {defaultSrc: ["'self'"], styleSrc: ["'self'", "'unsafe-inline'"], scriptSrc: ["'self'"], imgSrc: ["'self'", 'data:', 'https:']}},
+      crossOriginEmbedderPolicy: !1,
+    },
+    logLevel: process.env.LOG_LEVEL || 30,
+  },
+  f = k;
+var c = (t, o) =>
+    U({
+      name: t,
+      level: f.logLevel,
+      transport: {target: 'pino-pretty', options: {colorize: !0}, ignore: 'pid,hostname,level,time', translateTime: 'UTC:yyyy-mm-dd HH:MM:ss', customColors: 'err:red,info:blue'},
+      ...o,
+    }),
+  P = () => {
+    let t = c('http-request');
+    return (o, e, r) => {
+      let n = Date.now();
+      (e.on('finish', () => {
+        let s = Date.now() - n,
+          i = {method: o.method, url: o.originalUrl, status: e.statusCode, duration: `${s}ms`, ip: o.ip, userAgent: o.get('User-Agent'), timestamp: m()};
+        e.statusCode >= 500 ? t.error(i, 'HTTP\u8BF7\u6C42\u9519\u8BEF') : e.statusCode >= 400 ? t.warn(i, 'HTTP\u5BA2\u6237\u7AEF\u9519\u8BEF') : t.info(i, 'HTTP\u8BF7\u6C42');
+      }),
+        r());
+    };
+  },
+  a = c('huxy');
+var y = c('error-handler'),
+  b = t => (o, e, r) => {
+    (y.error({message: 'Not Found', timestamp: m(), url: o.originalUrl, method: o.method, ip: o.ip, userAgent: o.get('User-Agent')}, '\u627E\u4E0D\u5230\u8DEF\u5F84'),
+      e.status(404).json({success: !1, timestamp: m(), status: 404, message: `\u8DEF\u7531 ${o.method} ${o.originalUrl} \u4E0D\u5B58\u5728`, url: o.originalUrl}));
+  },
+  A = t => (o, e, r, n) => {
+    let s = o.status || 500,
+      i = o.message;
+    (y.error({message: i, timestamp: m(), stack: o.stack, url: e.originalUrl, method: e.method, ip: e.ip, userAgent: e.get('User-Agent')}, '\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF'),
+      r.status(s).json({success: !1, timestamp: m(), message: t.isDev ? i : '\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF', stack: t.isDev ? o.stack : void 0}));
+  };
+var L = t => (o, e, r) => {
+  (o.path.match(/\.(js|css|png|jpe?g|ico|webp|svg|mpeg|webm|m4a)$/) ? e.set('Cache-Control', 'public, max-age=31536000, immutable') : e.set('Cache-Control', 'no-cache'), r());
+};
+import {Router as j} from 'express';
+var G = t => {
+    let o = j();
+    return (
+      o.use('/health', (e, r) => {
+        r.status(200).json({status: 'OK', timestamp: m(), uptime: process.uptime(), environment: t.nodeEnv, memoryUsage: process.memoryUsage(), pid: process.pid});
+      }),
+      o.get('/', (e, r) => {
+        r.status(200).json({message: 'Node.js \u670D\u52A1\u5668\u8FD0\u884C\u4E2D', timestamp: m(), environment: t.nodeEnv});
+      }),
+      o
+    );
+  },
+  N = G;
+var Q = (t, o = {}) => (
+    t.disable('x-powered-by'),
+    t.set('trust proxy', 1),
+    t.use(V(o.helmet)),
+    t.use(F(o.cors)),
+    t.use(K({keyGenerator: e => W(e.ip) || e.headers['x-huxy-auth'] || e.headers['x-api-key'] || e.headers.authorization, ...o.rateLimit})),
+    t.use(z()),
+    t.use(T.json({limit: '20mb'})),
+    t.use(T.urlencoded({extended: !0, limit: '20mb'})),
+    t.use(X({logger: a, quietReqLogger: !0, autoLogging: !1})),
+    t.use(P()),
+    t.use(L(o)),
+    t
+  ),
+  J = t => {
+    let o = e => {
+      (a.info(`\u6536\u5230 ${e} \u4FE1\u53F7, \u{1F6D1} \u6B63\u5728\u5173\u95ED\u670D\u52A1\u5668...`),
+        t.close(() => {
+          (a.info('\u{1F44B} \u670D\u52A1\u5668\u5DF2\u5173\u95ED'), process.exit(0));
+        }),
+        setTimeout(() => {
+          (a.error('\u274C \u5F3A\u5236\u5173\u95ED\u670D\u52A1\u5668'), process.exit(1));
+        }, 5e3));
+    };
+    (process.on('SIGTERM', () => o('SIGTERM')),
+      process.on('SIGINT', () => o('SIGINT')),
+      process.on('uncaughtException', e => {
+        (a.error(e, `\u672A\u6355\u83B7\u7684\u5F02\u5E38: ${e.message}`), process.exit(1));
+      }),
+      process.on('unhandledRejection', (e, r) => {
+        (a.error({reason: e, promise: r}, '\u672A\u5904\u7406\u7684 Promise \u62D2\u7EDD'), process.exit(1));
+      }));
+  },
+  Z = async (t, o) => {
+    let e = u(t),
+      {port: r} = e;
+    (await d(r, e.host)) || ((e.port = Number(r) + 1), a.warn(`\u7AEF\u53E3 ${r} \u5DF2\u88AB\u5360\u7528\uFF0C\u73B0\u5728\u4F7F\u7528\u7AEF\u53E3 ${e.port}`));
+    let s = T();
+    Q(s, e);
+    let i = B(s);
+    return (o?.(i, s, e), s.use(N(e)), s.use(b(e)), s.use(A(e)), J(i), {app: s, httpServer: i, config: e});
+  },
+  R = Z;
+var Y = (t, o, e) =>
+    R({...f, ...t}, (r, n, s) => {
+      let {port: i, host: p, nodeEnv: h, basepath: I, appName: C = 'HuxyServer'} = s;
+      r.listen(i, p, () => {
+        if (!e) {
+          let $ = l()
+            .filter(v => v !== `http://${p}`)
+            .map(v => `http://${v}:${i}${I}`);
+          (a.info(`-----------------------${C}-----------------------`),
+            a.info(`\u{1F680} \u670D\u52A1\u8FD0\u884C\u5728\u3010${h}\u3011\u73AF\u5883: http://${p}:${i}${I}`),
+            a.info(`-----------------[${m()}]------------------`),
+            a.info({ips: $}, '\u672C\u5730\u5730\u5740\uFF1A'));
+        }
+        o?.(s, n, r);
+      });
+    }),
+  g = Y;
+import oe from 'express';
+import {fileURLToPath as q} from 'node:url';
+import {dirname as ee, resolve as te} from 'node:path';
+var E = (t = import.meta.url) => ee(q(t)),
+  S = t => te(E(), t),
+  _ = S;
+var re = {port: 9e3, host: 'localhost', basepath: '/', buildPath: './build'},
+  se = (t, o) =>
+    g({...re, ...t}, (e, r, n) => {
+      let {basepath: s, buildPath: i} = e;
+      (r.use(s, oe.static(i, {maxAge: '1y', immutable: !0})),
+        r.get(`${s}/{*splat}`.replace('//', '/'), (p, h) => {
+          h.sendFile(_(i, 'index.html'));
+        }),
+        o?.(e, r, n));
+    }),
+  O = se;
+var Ye = {startServer: g, startStatic: O, logger: a, createLogger: c, dateTime: m, localIPs: l, nodeArgs: x, getEnvConfig: u, checkPort: d, getDirName: E, resolvePath: S};
+export {
+  d as checkPort,
+  c as createLogger,
+  m as dateTime,
+  Ye as default,
+  E as getDirName,
+  u as getEnvConfig,
+  l as localIPs,
+  a as logger,
+  x as nodeArgs,
+  S as resolvePath,
+  g as startServer,
+  O as startStatic,
+};