vk-ssl-auto-deploy 0.3.0 → 0.6.1

package/README.md

@@ -189,7 +189,6 @@ pm2-startup uninstall
 ```json
 {
   "port": 6001,
-  "routerName": "api",
 	"certSaveDir": "/vk-cert",
 	"ipWhitelist": [],
 	"callbackCommand": [
@@ -199,7 +198,6 @@ pm2-startup uninstall
 ```
 
 - `port`: 服务监听端口（默认 6001）（一般无需改动）
-- `routerName`: API 路由前缀（默认 "api"，即访问路径为 `/api/...`）（一般无需改动）
 - `certSaveDir`: 证书存储目录，最终证书路径为 `${certSaveDir}/${证书id}/`（一般无需改动）
 - `ipWhitelist`: IP白名单，默认为空，表示不限制IP，如果需要限制IP，可以填写IP地址，多个IP地址用逗号分隔
 - `callbackCommand`: 证书部署成功后执行的服务器命令，一般用于重载nginx配置等
@@ -353,91 +351,6 @@ npm run delete
 npm run list
 ```
 
-## 证书自动部署API
-
-### 接口说明
-
-证书续期后台可以通过HTTP POST请求将证书文件自动部署到本项目。
-
-### 请求地址
-
-```
-POST http://your-domain:3000/api/deploy-cert
-```
-
-### 请求参数
-
-- Content-Type: `multipart/form-data`
-- `name`: 证书名称（必填），用于创建子目录，例如 `aaa` 会创建 `cert/aaa` 目录
-- `file`: zip格式的证书文件（必填）
-
-### 返回格式
-
-成功响应：
-```json
-{
-  "code": 0,
-  "msg": "证书部署成功",
-  "path": "cert/aaa",
-  "fileCount": 11
-}
-```
-
-失败响应：
-```json
-{
-  "code": 错误码,
-  "msg": "错误信息"
-}
-```
-
-### 错误码说明
-
-- `1001`: 缺少参数 name
-- `1002`: 缺少文件
-- `1003`: name参数包含非法字符
-- `2001`: 解压zip文件失败
-- `5000`: 服务器内部错误
-
-### 证书文件说明
-
-上传的zip文件解压后应包含以下内容：
-
-- 私钥.pem（私钥文件）
-- 证书.pem（证书文件，包含证书链）
-- 中间证书.pem（中间证书文件，pem格式）
-- cert.crt（证书文件，包含证书链，与证书.pem内容一致）
-- cert.key（私钥文件，pem格式，与私钥.pem内容一致）
-- intermediate.crt（中间证书文件，pem格式，中间证书.pem内容一致）
-- cert.der（der格式证书文件）
-- cert.jks（jks格式证书文件，java服务器使用）
-- cert.p7b（p7b格式证书文件）
-- cert.pfx（pfx格式证书文件，iis服务器使用）
-- one.pem（证书和私钥简单合并成一个文件，pem格式，crt正文+key正文）
-
-### 使用示例
-
-使用curl命令：
-```bash
-curl -X POST http://localhost:3000/api/deploy-cert \
-  -F "name=example" \
-  -F "file=@/path/to/cert.zip"
-```
-
-使用JavaScript（fetch）：
-```javascript
-const formData = new FormData();
-formData.append('name', 'example');
-formData.append('file', fileBlob);
-
-fetch('http://localhost:3000/api/deploy-cert', {
-  method: 'POST',
-  body: formData
-})
-.then(res => res.json())
-.then(data => console.log(data));
-```
-
 ## License
 
 MIT

package/app.js

@@ -25,7 +25,7 @@ app.use(express.static(path.join(__dirname, 'public')));
 
 app.use('/', indexRouter);
 app.use('/test', testRouter);
-app.use(`/${config.routerName}`, certRouter);
+app.use(`/api/cert`, certRouter);
 
 // catch 404 and forward to error handler
 app.use((req, res, next) => {

package/config.json

@@ -1,9 +1,8 @@
 {
 	"port": 6001,
-	"routerName": "api",
-	"ipWhitelist": [],
 	"certSaveDir": "/vk-cert",
-	"callbackCommand": [
-		"/www/server/nginx/sbin/nginx -s reload"
-	]
+	"nginxDir": "/www/server/nginx/sbin/nginx",
+	"key": "",
+	"domains": [],
+	"callbackCommand": []
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "vk-ssl-auto-deploy",
-	"version": "0.3.0",
+	"version": "0.6.1",
 	"description": "SSL证书自动部署工具 - 提供HTTP API接口，支持证书文件自动上传和部署",
 	"main": "app.js",
 	"bin": {
@@ -49,13 +49,16 @@
 	},
 	"dependencies": {
 		"adm-zip": "^0.5.16",
+		"axios": "^1.6.0",
+		"chalk": "^4.1.2",
 		"cookie-parser": "~1.4.4",
 		"debug": "~2.6.9",
 		"ejs": "~2.6.1",
 		"express": "~4.16.1",
 		"http-errors": "~1.6.3",
 		"morgan": "~1.9.1",
-		"multer": "^2.0.2"
+		"multer": "^2.0.2",
+		"node-forge": "^1.3.1"
 	},
 	"optionalDependencies": {
 		"pm2": "^5.3.0"

package/routes/cert.js

@@ -1,240 +1,740 @@
 const express = require('express');
 const router = express.Router();
-const multer = require('multer');
-const AdmZip = require('adm-zip');
 const fs = require('fs');
 const path = require('path');
 const { exec } = require('child_process');
 const { promisify } = require('util');
+const crypto = require('crypto');
+const axios = require('axios');
+const forge = require('node-forge');
+const chalk = require('chalk');
 const config = require('../config.json');
-const { validateCertFile } = require('../utils/certValidator');
-const { getClientIP, isIPInWhitelist } = require('../utils/ipValidator');
 
 const execAsync = promisify(exec);
 
-// 使用内存存储
-const upload = multer({
-	storage: multer.memoryStorage(),
-	limits: {
-		fileSize: 10 * 1024 * 1024 // 限制文件大小为10MB
-	}
-});
+// 日志工具 - 带颜色输出（仅使用5种颜色：白色、灰色、黄色、绿色、红色）
+const logger = {
+	// 错误 - 红色
+	error: (...args) => console.log(chalk.red(...args)),
+	// 警告 - 黄色
+	warn: (...args) => console.log(chalk.yellow(...args)),
+	// 成功 - 绿色
+	success: (...args) => console.log(chalk.green(...args)),
+	// 信息 - 白色
+	info: (...args) => console.log(...args),
+	// 次要信息 - 灰色
+	dim: (...args) => console.log(chalk.gray(...args)),
+	// 普通日志 - 白色
+	log: (...args) => console.log(...args),
+	// 步骤标题 - 白色
+	step: (...args) => console.log(...args),
+	// 分隔线 - 灰色
+	divider: () => console.log(chalk.gray('─'.repeat(60)))
+};
+
+// 无忧SSL API配置
+const WUYOU_API_BASE = 'https://openapi-ssl.vk168.top/http'; // 请勿修改
+const API_KEY = config.key;
+
+// QPS限制：每次API调用后等待时间（毫秒）
+const API_CALL_DELAY = 1000; // 确保QPS不超过1
+
+// 定时任务状态
+let scheduledTaskTimer = null;
+let lastExecutionDate = null;
+let isTaskRunning = false;
+let scheduledExecutionTime = null; // 固定的执行时间 { hour, minute }
+
+// 文件锁路径
+const LOCK_FILE = path.join(__dirname, '..', '.cert-deploy.lock');
+const LOCK_TIMEOUT = 10 * 60 * 1000; // 锁超时时间：10分钟
+
+/**
+ * 延迟函数
+ */
+function sleep(ms) {
+	return new Promise(resolve => setTimeout(resolve, ms));
+}
 
 /**
- * POST /api/deploy-cert
- * 接收证书zip文件并自动部署
- * 
- * 参数：
- * - name: 证书名称（用于创建子目录）
- * - file: zip文件
- * 
- * 返回：
- * - 成功: { code: 0, msg: '证书部署成功', path: 'cert/xxx' }
- * - 失败: { code: 错误码, msg: '错误信息' }
+ * 尝试获取文件锁
+ * @returns {boolean} 是否成功获取锁
  */
-router.post('/deploy-cert', upload.single('file'), async (req, res, next) => {
+function acquireLock() {
 	try {
-		// 0. IP白名单验证
-		const clientIP = getClientIP(req);
-		if (!isIPInWhitelist(clientIP, config.ipWhitelist)) {
-			console.warn(`[IP白名单拦截] IP: ${clientIP} 尝试部署证书但不在白名单中`);
-			return res.json({
-				code: 4030,
-				msg: 'IP地址不在白名单中，访问被拒绝',
-				ip: clientIP
-			});
+		// 检查锁文件是否存在
+		if (fs.existsSync(LOCK_FILE)) {
+			// 检查锁文件是否超时
+			const lockStat = fs.statSync(LOCK_FILE);
+			const lockAge = Date.now() - lockStat.mtimeMs;
+
+			if (lockAge > LOCK_TIMEOUT) {
+				// 锁已超时，删除旧锁
+				logger.warn('[文件锁] 检测到超时的锁文件，已清理');
+				fs.unlinkSync(LOCK_FILE);
+			} else {
+				// 锁仍然有效，其他实例正在执行
+				logger.dim('[文件锁] 其他实例正在执行任务，跳过');
+				return false;
+			}
 		}
 
-		console.log(`[证书部署请求] 来源IP: ${clientIP}`);
+		// 创建锁文件
+		const lockData = {
+			pid: process.pid,
+			startTime: new Date().toISOString(),
+			hostname: require('os').hostname()
+		};
+		fs.writeFileSync(LOCK_FILE, JSON.stringify(lockData, null, 2), 'utf8');
+		logger.dim('[文件锁] 成功获取锁');
+		return true;
+	} catch (error) {
+		logger.error('[文件锁] 获取锁失败:', error.message);
+		return false;
+	}
+}
 
-		// 1. 验证参数
-		if (!req.body.name) {
-			return res.json({ code: 1001, msg: '缺少参数: name' });
+/**
+ * 释放文件锁
+ */
+function releaseLock() {
+	try {
+		if (fs.existsSync(LOCK_FILE)) {
+			fs.unlinkSync(LOCK_FILE);
+			logger.dim('[文件锁] 锁已释放');
 		}
+	} catch (error) {
+		logger.error('[文件锁] 释放锁失败:', error.message);
+	}
+}
 
-		if (!req.file) {
-			return res.json({ code: 1002, msg: '缺少文件: file' });
+/**
+ * 调用无忧SSL API - 获取证书列表
+ * @param {number} pageIndex - 页码
+ * @param {number} pageSize - 每页数量
+ * @returns {Promise<Object>} API响应
+ */
+async function getCertList(pageIndex = 1, pageSize = 10000) {
+	try {
+		logger.info(`[API调用] 获取证书列表 - 页码: ${pageIndex}, 每页: ${pageSize}`);
+
+		const params = {
+			pageIndex,
+			pageSize,
+			status: 3,
+			key: API_KEY
+		};
+
+		// 添加domains过滤条件
+		if (config.domains && Array.isArray(config.domains) && config.domains.length > 0) {
+			params.domains = config.domains.join(',');
 		}
 
-		const certName = req.body.name;
+		const response = await axios.post(
+			`${WUYOU_API_BASE}/api/listCert`, params, {
+				timeout: 60000
+			}
+		);
+
+		logger.success(`[API响应] 获取证书列表成功 - 共 ${response.data?.data?.total || 0} 条记录`);
+
+		// QPS限制：调用后等待
+		await sleep(API_CALL_DELAY);
 
-		// 验证name参数，防止路径注入
-		if (certName.includes('..') || certName.includes('/') || certName.includes('\\')) {
-			return res.json({ code: 1003, msg: 'name参数包含非法字符' });
+		return response.data;
+	} catch (error) {
+		logger.error('[API错误] 获取证书列表失败:', error.message);
+		throw error;
+	}
+}
+
+/**
+ * 调用无忧SSL API - 批量下载证书
+ * @param {Array<string>} certIds - 证书ID列表（最多100个）
+ * @returns {Promise<Object>} API响应
+ */
+async function downloadCerts(certIds) {
+	try {
+		logger.info(`[API调用] 批量下载证书 - 数量: ${certIds.length}`);
+		const params = {
+			certIds,
+			type: "nginx",
+			key: API_KEY
+		};
+
+		const response = await axios.post(
+			`${WUYOU_API_BASE}/api/certDownload`, params, {
+				timeout: 60000
+			}
+		);
+
+		logger.success(`[API响应] 批量下载证书成功 - ${response.data?.data?.total} 个证书`);
+
+		// QPS限制：调用后等待
+		await sleep(API_CALL_DELAY);
+
+		return response.data;
+	} catch (error) {
+		logger.error('[API错误] 批量下载证书失败:', error.message);
+		throw error;
+	}
+}
+
+/**
+ * 解析证书内容，获取有效期等信息
+ * 支持 RSA、EC (ECDSA) 等多种算法
+ * @param {string} certContent - 证书内容（PEM格式）
+ * @returns {Object} 证书信息
+ */
+function parseCertificate(certContent) {
+	try {
+		// 优先使用 Node.js 内置的 crypto 模块，支持 RSA、EC 等多种算法
+		// X509Certificate 在 Node.js 15.6.0+ 可用
+		if (crypto.X509Certificate) {
+			const cert = new crypto.X509Certificate(certContent);
+
+			// 解析 subject 和 issuer 中的 CN
+			const parseCN = (dn) => {
+				const cnMatch = dn.match(/CN=([^,]+)/);
+				return cnMatch ? cnMatch[1] : '';
+			};
+
+			return {
+				notBefore: new Date(cert.validFrom),
+				notAfter: new Date(cert.validTo),
+				subject: parseCN(cert.subject),
+				issuer: parseCN(cert.issuer)
+			};
 		}
 
-		// 2. 创建cert目录和子目录
-		const projectRoot = path.join(__dirname, '..');
-		// 使用配置文件中的 certSaveDir，支持绝对路径和相对路径
-		const certBaseDir = path.isAbsolute(config.certSaveDir) ?
-			config.certSaveDir :
-			path.join(projectRoot, config.certSaveDir);
-		const certDir = path.resolve(certBaseDir, certName);
-		const userCertDir = certDir.replace(/\\/g, '/');
+		// 降级方案：尝试使用 node-forge（可能不支持 EC 算法）
+		// 如果证书是 EC 算法，这里可能会失败，但至少尝试一下
+		try {
+			const cert = forge.pki.certificateFromPem(certContent);
+			return {
+				notBefore: cert.validity.notBefore,
+				notAfter: cert.validity.notAfter,
+				subject: cert.subject.attributes.find(attr => attr.name === 'commonName')?.value || '',
+				issuer: cert.issuer.attributes.find(attr => attr.name === 'commonName')?.value || ''
+			};
+		} catch (forgeError) {
+			// node-forge 不支持 EC 算法，提示需要升级 Node.js
+			if (forgeError.message && forgeError.message.includes('OID is not RSA')) {
+				logger.error('[证书解析错误] 证书使用 EC 算法，需要 Node.js 15.6.0+ 版本支持');
+			} else {
+				logger.error('[证书解析错误]', forgeError.message);
+			}
+			return null;
+		}
+	} catch (error) {
+		logger.error('[证书解析错误]', error.message);
+		return null;
+	}
+}
 
-		// 确保cert根目录存在
-		if (!fs.existsSync(certBaseDir)) {
-			fs.mkdirSync(certBaseDir, { recursive: true });
+/**
+ * 检查本地证书文件的有效期
+ * @param {string} certFilePath - 证书文件路径（.crt或.pem）
+ * @returns {number} 剩余天数，如果文件不存在或解析失败返回-1
+ */
+function getCertRemainingDays(certFilePath) {
+	try {
+		if (!fs.existsSync(certFilePath)) {
+			return -1;
 		}
 
-		// 如果目标目录已存在，先删除（实现覆盖更新）
-		if (fs.existsSync(certDir)) {
-			fs.rmSync(certDir, { recursive: true, force: true });
+		const certContent = fs.readFileSync(certFilePath, 'utf8');
+		const certInfo = parseCertificate(certContent);
+
+		if (!certInfo) {
+			return -1;
 		}
 
-		// 创建目标目录
+		const now = new Date();
+		const expiryDate = new Date(certInfo.notAfter);
+		const remainingMs = expiryDate - now;
+		const remainingDays = Math.floor(remainingMs / (1000 * 60 * 60 * 24));
+
+		return remainingDays;
+	} catch (error) {
+		logger.error('[证书检查错误]', error.message);
+		return -1;
+	}
+}
+
+/**
+ * 根据域名列表生成文件名
+ * @param {Array<string>} domains - 域名列表
+ * @returns {string} 文件名（不含扩展名）
+ */
+function generateFileName(domains) {
+	if (!domains || domains.length === 0) {
+		return 'unknown';
+	}
+
+	// 移除通配符并排序，找出主域名
+	const cleanDomains = domains.map(d => d.replace(/^\*\./, '')).sort();
+	const mainDomain = cleanDomains[0];
+
+	// 统计有多少个不同的主域名
+	const uniqueDomains = [...new Set(cleanDomains)];
+
+	if (uniqueDomains.length === 1) {
+		return mainDomain;
+	} else {
+		return `${mainDomain}-${uniqueDomains.length}`;
+	}
+}
+
+/**
+ * 保存证书文件
+ * @param {string} fileName - 文件名（不含扩展名）
+ * @param {string} certContent - 证书内容
+ * @param {string} keyContent - 私钥内容
+ */
+function saveCertFiles(fileName, certContent, keyContent) {
+	const certDir = path.isAbsolute(config.certSaveDir) ?
+		config.certSaveDir :
+		path.join(__dirname, '..', config.certSaveDir);
+
+	// 确保目录存在
+	if (!fs.existsSync(certDir)) {
 		fs.mkdirSync(certDir, { recursive: true });
+		logger.dim(`[目录创建] ${certDir}`);
+	}
 
-		// 3. 解压zip文件并进行安全验证
-		try {
-			const zip = new AdmZip(req.file.buffer);
-			const zipEntries = zip.getEntries();
-
-			// 统计信息
-			const stats = {
-				total: 0, // 总文件数
-				saved: 0, // 成功保存的文件数
-				filtered: 0, // 被过滤的文件数
-				savedFiles: [], // 保存的文件列表
-				filteredFiles: [] // 被过滤的文件列表（含原因）
-			};
+	// 保存三个文件
+	const crtFile = path.join(certDir, `${fileName}.crt`);
+	const keyFile = path.join(certDir, `${fileName}.key`);
+	const pemFile = path.join(certDir, `${fileName}.pem`);
 
-			// 遍历并验证每个文件
-			zipEntries.forEach((entry) => {
-				if (!entry.isDirectory) {
-					stats.total++;
-
-					const filename = path.basename(entry.entryName);
-					const entryData = entry.getData();
-
-					// 安全验证
-					const validation = validateCertFile(filename, entryData, entry.entryName);
-
-					if (validation.valid) {
-						// 验证通过，保存文件
-						try {
-							const entryPath = path.join(certDir, entry.entryName);
-
-							// 确保父目录存在
-							const entryDir = path.dirname(entryPath);
-							if (!fs.existsSync(entryDir)) {
-								fs.mkdirSync(entryDir, { recursive: true });
-							}
-
-							// 写入文件
-							fs.writeFileSync(entryPath, entryData);
-
-							stats.saved++;
-							stats.savedFiles.push(entry.entryName);
-
-							console.log(`[文件已保存] ${entry.entryName} (${entryData.length} bytes)`);
-						} catch (writeError) {
-							console.error(`[文件写入失败] ${entry.entryName}:`, writeError.message);
-							stats.filtered++;
-							stats.filteredFiles.push({
-								filename: entry.entryName,
-								reason: '文件写入失败: ' + writeError.message
-							});
-						}
-					} else {
-						// 验证失败，过滤该文件
-						stats.filtered++;
-						stats.filteredFiles.push({
-							filename: entry.entryName,
-							reason: validation.reason
-						});
+	fs.writeFileSync(crtFile, certContent, 'utf8');
+	fs.writeFileSync(keyFile, keyContent, 'utf8');
+	fs.writeFileSync(pemFile, certContent, 'utf8'); // pem内容与crt相同
 
-						console.warn(`[文件已过滤] ${entry.entryName}: ${validation.reason}`);
-					}
-				}
+	logger.success(`[证书保存] ${fileName}.crt, ${fileName}.key, ${fileName}.pem`);
+}
+
+/**
+ * 重载Nginx配置
+ */
+async function reloadNginx() {
+	if (!config.nginxDir || !config.nginxDir.trim()) {
+		logger.dim('[Nginx重载] 未配置nginxDir，跳过重载');
+		return { success: true, message: '未配置nginxDir' };
+	}
+
+	const nginxCommand = `${config.nginxDir} -s reload`;
+
+	try {
+		logger.info(`[Nginx重载] 执行命令: ${nginxCommand}`);
+		const { stdout, stderr } = await execAsync(nginxCommand, {
+			timeout: 30000
+		});
+
+		logger.success('[Nginx重载] 成功');
+		if (stdout) logger.dim(`[输出] ${stdout.trim()}`);
+		if (stderr) logger.warn(`[错误输出] ${stderr.trim()}`);
+
+		return { success: true, message: 'Nginx重载成功', output: stdout, error: stderr };
+	} catch (error) {
+		logger.error('[Nginx重载] 失败:', error.message);
+		return { success: false, message: 'Nginx重载失败', error: error.message };
+	}
+}
+
+/**
+ * 执行证书自动部署任务
+ */
+async function executeDeployTask() {
+	if (isTaskRunning) {
+		logger.warn('[任务执行] 已有任务正在执行，跳过本次执行');
+		return { success: false, message: '任务正在执行中' };
+	}
+
+	// 尝试获取文件锁
+	if (!acquireLock()) {
+		return { success: false, message: '无法获取文件锁，其他实例正在执行' };
+	}
+
+	isTaskRunning = true;
+	const startTime = new Date();
+	logger.divider();
+	logger.step(`\n[任务开始] ${startTime.toLocaleString()}\n`);
+	logger.divider();
+
+	const result = {
+		success: false,
+		message: '',
+		startTime,
+		endTime: null,
+		duration: 0,
+		stats: {
+			totalCerts: 0,
+			checkedCerts: 0,
+			needUpdateCerts: 0,
+			downloadedCerts: 0,
+			failedCerts: 0
+		},
+		details: []
+	};
+
+	try {
+		// 步骤1：获取证书列表
+		logger.step('\n[步骤1] 获取证书列表...');
+		const certListResponse = await getCertList(1, 10000);
+
+		if (!certListResponse || certListResponse.code !== 0) {
+			throw new Error(`获取证书列表失败: ${certListResponse?.message || '未知错误'}`);
+		}
+
+		const certList = certListResponse.data?.rows || [];
+		result.stats.totalCerts = certList.length;
+		logger.success(`[步骤1] 共获取 ${certList.length} 个证书\n`);
+
+		if (certList.length === 0) {
+			result.success = true;
+			result.message = '没有需要处理的证书';
+			return result;
+		}
+
+		// 步骤2：检查本地证书，筛选需要更新的证书
+		logger.step('[步骤2] 检查本地证书有效期...');
+		const certsToUpdate = [];
+		const certDir = path.isAbsolute(config.certSaveDir) ?
+			config.certSaveDir :
+			path.join(__dirname, '..', config.certSaveDir);
+
+		// 先收集所有证书的有效期信息
+		const certStatusList = [];
+		for (const cert of certList) {
+			result.stats.checkedCerts++;
+
+			const fileName = generateFileName(cert.domains);
+			const certFilePath = path.join(certDir, `${fileName}.crt`);
+			const remainingDays = getCertRemainingDays(certFilePath);
+
+			certStatusList.push({
+				cert,
+				fileName,
+				remainingDays
 			});
+		}
+
+		// 按有效期降序排序（不存在的证书排在最后）
+		certStatusList.sort((a, b) => {
+			if (a.remainingDays === -1 && b.remainingDays === -1) return 0;
+			if (a.remainingDays === -1) return 1; // 不存在的排后面
+			if (b.remainingDays === -1) return -1; // 不存在的排后面
+			return b.remainingDays - a.remainingDays; // 降序排列
+		});
+
+		// 按排序后的顺序打印日志
+		for (const { cert, fileName, remainingDays } of certStatusList) {
+			if (remainingDays === -1) {
+				// 证书文件不存在
+				logger.warn(`[需要下载] ${fileName} - 本地证书不存在`);
+				certsToUpdate.push(cert);
+				result.details.push({
+					certId: cert._id,
+					domains: cert.domains,
+					fileName,
+					reason: '本地证书不存在',
+					remainingDays: -1
+				});
+			} else if (remainingDays < 14) {
+				// 证书有效期不足14天
+				logger.warn(`[需要更新] ${fileName} - 剩余有效期: ${remainingDays} 天`);
+				certsToUpdate.push(cert);
+				result.details.push({
+					certId: cert._id,
+					domains: cert.domains,
+					fileName,
+					reason: `有效期不足14天（剩余${remainingDays}天）`,
+					remainingDays
+				});
+			} else {
+				logger.dim(`[无需更新] ${fileName} - 剩余有效期: ${remainingDays} 天`);
+			}
+		}
+
+		result.stats.needUpdateCerts = certsToUpdate.length;
+		logger.success(`[步骤2] 需要更新 ${certsToUpdate.length} 个证书\n`);
+
+		if (certsToUpdate.length === 0) {
+			result.success = true;
+			result.message = '所有证书均在有效期内，无需更新';
+			return result;
+		}
+
+		// 步骤3：分批下载证书（每批最多100个）
+		logger.step('[步骤3] 开始下载证书...');
+		const batchSize = 100;
+		const batches = [];
+
+		for (let i = 0; i < certsToUpdate.length; i += batchSize) {
+			batches.push(certsToUpdate.slice(i, i + batchSize));
+		}
+
+		logger.info(`[步骤3] 共分 ${batches.length} 批下载`);
 
-			// 检查是否至少保存了一个文件
-			if (stats.saved === 0) {
-				// 如果没有任何有效文件，删除创建的目录
-				if (fs.existsSync(certDir)) {
-					fs.rmSync(certDir, { recursive: true, force: true });
+		for (let batchIndex = 0; batchIndex < batches.length; batchIndex++) {
+			const batch = batches[batchIndex];
+			logger.info(`\n[批次 ${batchIndex + 1}/${batches.length}] 下载 ${batch.length} 个证书...`);
+
+			const certIds = batch.map(cert => cert._id);
+
+			try {
+				const downloadResponse = await downloadCerts(certIds);
+
+				if (!downloadResponse || downloadResponse.code !== 0) {
+					throw new Error(`下载失败: ${downloadResponse?.message || '未知错误'}`);
 				}
 
-				return res.json({
-					code: 2002,
-					msg: 'zip文件中没有有效的证书文件',
-					stats: stats
+				const downloadedCerts = downloadResponse.data?.certs || [];
+				logger.success(`[批次 ${batchIndex + 1}/${batches.length}] 成功下载 ${downloadedCerts.length} 个证书`);
+
+				// 步骤4：保存证书文件
+				for (const certData of downloadedCerts) {
+					try {
+						const fileName = generateFileName(certData.domains);
+						saveCertFiles(fileName, certData.cert_data.pem, certData.cert_data.key);
+						result.stats.downloadedCerts++;
+
+						// 更新详情
+						const detail = result.details.find(d => d.certId === certData._id);
+						if (detail) {
+							detail.success = true;
+							detail.savedFiles = [`${fileName}.crt`, `${fileName}.key`, `${fileName}.pem`];
+						}
+					} catch (saveError) {
+						logger.error(`[保存失败] 证书ID: ${certData._id}`, saveError.message);
+						result.stats.failedCerts++;
+
+						const detail = result.details.find(d => d.certId === certData._id);
+						if (detail) {
+							detail.success = false;
+							detail.error = saveError.message;
+						}
+					}
+				}
+			} catch (batchError) {
+				logger.error(`[批次 ${batchIndex + 1}/${batches.length}] 下载失败:`, batchError.message);
+				result.stats.failedCerts += batch.length;
+
+				// 标记该批次的所有证书为失败
+				batch.forEach(cert => {
+					const detail = result.details.find(d => d.certId === cert._id);
+					if (detail) {
+						detail.success = false;
+						detail.error = batchError.message;
+					}
 				});
 			}
+		}
 
-			console.log(`[证书部署成功] 名称: ${certName}, 路径: ${userCertDir}, 保存: ${stats.saved}个, 过滤: ${stats.filtered}个`);
+		logger.success(`\n[步骤3] 证书下载完成 - 成功: ${result.stats.downloadedCerts}, 失败: ${result.stats.failedCerts}\n`);
+
+		// 步骤5：重载Nginx
+		if (result.stats.downloadedCerts > 0) {
+			logger.step('[步骤4] 重载Nginx配置...');
+			const nginxResult = await reloadNginx();
+			result.nginxReload = nginxResult;
+			if (nginxResult.success) {
+				logger.success(`[步骤4] Nginx重载成功\n`);
+			} else {
+				logger.error(`[步骤4] Nginx重载失败\n`);
+			}
+		}
 
-			// 4. 执行回调命令
-			const commandResults = [];
-			if (config.callbackCommand && Array.isArray(config.callbackCommand) && config.callbackCommand.length > 0) {
-				console.log(`[开始执行回调命令] 共${config.callbackCommand.length}个命令`);
+		result.success = true;
+		result.message = `任务完成 - 成功更新 ${result.stats.downloadedCerts} 个证书`;
 
-				for (let i = 0; i < config.callbackCommand.length; i++) {
-					const command = config.callbackCommand[i];
-					const commandResult = {
-						command: command,
-						index: i + 1,
-						success: false,
-						output: '',
-						error: ''
-					};
+	} catch (error) {
+		logger.error('[任务执行错误]', error);
+		result.success = false;
+		result.message = `任务失败: ${error.message}`;
+		result.error = error.stack;
+	} finally {
+		isTaskRunning = false;
+		releaseLock(); // 释放文件锁
+		result.endTime = new Date();
+		result.duration = Math.floor((result.endTime - result.startTime) / 1000);
+
+		logger.divider();
+		logger.step(`\n[任务结束] ${result.endTime.toLocaleString()}`);
+		if (result.success) {
+			logger.success(`[任务结果] ✓ 成功 - ${result.message}`);
+		} else {
+			logger.error(`[任务结果] ✗ 失败 - ${result.message}`);
+		}
+		logger.info(`[执行时长] ${result.duration} 秒`);
+		logger.info(
+			`[统计信息] 总数: ${result.stats.totalCerts}, 检查: ${result.stats.checkedCerts}, 需更新: ${result.stats.needUpdateCerts}, 已下载: ${result.stats.downloadedCerts}, 失败: ${result.stats.failedCerts}`
+		);
+		logger.dim(`[证书保存目录] ${config.certSaveDir}`);
+		logger.divider();
+		console.log('');
+	}
 
-					try {
-						console.log(`[执行命令 ${i + 1}/${config.callbackCommand.length}] ${command}`);
-						const { stdout, stderr } = await execAsync(command, {
-							timeout: 30000, // 30秒超时
-							maxBuffer: 1024 * 1024 // 1MB buffer
-						});
+	return result;
+}
 
-						commandResult.success = true;
-						commandResult.output = stdout ? stdout.trim() : '';
-						if (stderr) {
-							commandResult.error = stderr.trim();
-						}
+/**
+ * 初始化定时任务
+ * 服务启动时随机确定一个执行时间（9:00-10:59之间），每天在该固定时间执行
+ */
+function initScheduledTask() {
+	logger.info('[定时任务] 初始化定时任务...');
 
-						console.log(`[命令执行成功 ${i + 1}/${config.callbackCommand.length}] ${command}`);
-						if (stdout) console.log(`[命令输出] ${stdout.trim()}`);
-						if (stderr) console.warn(`[命令stderr] ${stderr.trim()}`);
+	// 清除旧的定时器
+	if (scheduledTaskTimer) {
+		clearInterval(scheduledTaskTimer);
+	}
 
-					} catch (cmdError) {
-						commandResult.success = false;
-						commandResult.error = cmdError.message;
-						if (cmdError.stdout) commandResult.output = cmdError.stdout.trim();
-						if (cmdError.stderr) commandResult.error += '\n' + cmdError.stderr.trim();
+	// 生成固定的随机执行时间（只在服务启动时生成一次）
+	if (!scheduledExecutionTime) {
+		// 生成9:00-10:59之间的随机分钟数（0-119分钟）
+		const randomMinute = Math.floor(Math.random() * 120);
+		scheduledExecutionTime = {
+			hour: 9 + Math.floor(randomMinute / 60),
+			minute: randomMinute % 60
+		};
+
+		// scheduledExecutionTime = {
+		// 	hour: 20,
+		// 	minute: 42
+		// }
+
+		logger.success(
+			`[定时任务] 已设定执行时间为每天 ${scheduledExecutionTime.hour}:${scheduledExecutionTime.minute.toString().padStart(2, '0')}`
+		);
+	}
 
-						console.error(`[命令执行失败 ${i + 1}/${config.callbackCommand.length}] ${command}:`, cmdError.message);
-					}
+	// 每秒检查一次，覆盖式输出当前时间
+	scheduledTaskTimer = setInterval(() => {
+		try {
+			const now = new Date();
+			const currentHour = now.getHours();
+			const currentMinute = now.getMinutes();
+			const currentSecond = now.getSeconds();
+			const currentDate = now.toDateString();
+
+			// 只在任务未执行时，覆盖式输出倒计时（不换行）
+			if (!isTaskRunning) {
+				// 计算下次执行时间
+				const targetTime = new Date(now);
+				targetTime.setHours(scheduledExecutionTime.hour, scheduledExecutionTime.minute, 0, 0);
+
+				// 如果今天的执行时间已过，则计算明天的执行时间
+				if (now >= targetTime) {
+					targetTime.setDate(targetTime.getDate() + 1);
+				}
 
-					commandResults.push(commandResult);
+				// 计算剩余时间（毫秒）
+				const remainingMs = targetTime - now;
+				const remainingSeconds = Math.floor(remainingMs / 1000);
+				const hours = Math.floor(remainingSeconds / 3600);
+				const minutes = Math.floor((remainingSeconds % 3600) / 60);
+				const seconds = remainingSeconds % 60;
+
+				// 格式化倒计时文本
+				let countdownText = '';
+				if (hours > 0) {
+					countdownText = `${hours}小时${minutes}分${seconds}秒 后执行`;
+				} else if (minutes > 0) {
+					countdownText = `${minutes}分${seconds}秒 后执行`;
+				} else {
+					countdownText = `${seconds}秒 后执行`;
 				}
 
-				console.log(`[回调命令执行完成] 成功: ${commandResults.filter(r => r.success).length}个, 失败: ${commandResults.filter(r => !r.success).length}个`);
+				process.stdout.write(`\r[定时任务] 将在 ${countdownText}${' '.repeat(5)}`);
 			}
 
-			return res.json({
-				code: 0,
-				msg: '证书部署成功',
-				path: userCertDir,
-				stats: {
-					total: stats.total,
-					saved: stats.saved,
-					filtered: stats.filtered,
-					savedFiles: stats.savedFiles,
-					filteredFiles: stats.filteredFiles
-				},
-				commandResults: commandResults.length > 0 ? commandResults : undefined
-			});
+			// 只在秒数为 0 时检查是否到达执行时间
+			if (currentSecond === 0) {
+				if (currentHour === scheduledExecutionTime.hour && currentMinute === scheduledExecutionTime.minute) {
+					// 检查今天是否已经执行过
+					if (lastExecutionDate !== currentDate) {
+						// 换行后输出触发信息
+						console.log('');
+						logger.success(
+							`[定时任务] 触发执行 - 当前时间: ${currentHour}:${currentMinute.toString().padStart(2, '0')}`
+						);
+						lastExecutionDate = currentDate;
+
+						// 异步执行任务，使用try-catch确保异常不会影响定时器
+						executeDeployTask().catch(error => {
+							logger.error('[定时任务] 执行失败:', error);
+						});
+					}
+				}
+			}
+		} catch (error) {
+			// 捕获定时器内的所有异常，确保定时器不会停止
+			console.log(''); // 换行
+			logger.error('[定时任务] 检查时发生异常:', error);
+		}
+	}, 1000); // 每秒检查一次
+
+	logger.success(
+		`[定时任务] 定时任务已启动 - 每天 ${scheduledExecutionTime.hour}:${scheduledExecutionTime.minute.toString().padStart(2, '0')} 执行`
+	);
+}
 
-		} catch (zipError) {
-			console.error('[解压失败]', zipError);
-			return res.json({ code: 2001, msg: '解压zip文件失败: ' + zipError.message });
+/**
+ * GET /api/cert/status
+ * 获取任务状态
+ */
+router.get('/status', (req, res) => {
+	res.json({
+		code: 0,
+		msg: 'success',
+		data: {
+			isTaskRunning,
+			lastExecutionDate,
+			scheduledTaskEnabled: !!scheduledTaskTimer,
+			scheduledExecutionTime: scheduledExecutionTime ?
+				`${scheduledExecutionTime.hour}:${scheduledExecutionTime.minute.toString().padStart(2, '0')}` : null,
+			config: {
+				certSaveDir: config.certSaveDir,
+				nginxDir: config.nginxDir,
+				domainsFilter: config.domains
+			}
 		}
+	});
+});
 
-	} catch (error) {
-		console.error('[证书部署错误]', error);
-		return res.json({ code: 5000, msg: '服务器内部错误: ' + error.message });
+/**
+ * GET /api/cert/execute
+ * 手动触发任务执行
+ */
+router.get('/execute', async (req, res) => {
+	logger.info('[手动执行] 收到手动执行请求');
+
+	if (isTaskRunning) {
+		return res.json({
+			code: 1001,
+			msg: '任务正在执行中，请稍后再试',
+			data: null
+		});
 	}
+
+	// 异步执行任务，立即返回响应
+	executeDeployTask().catch(error => {
+		logger.error('[手动执行] 任务执行失败:', error);
+	});
+
+	res.json({
+		code: 0,
+		msg: '任务已开始执行，请通过 /api/cert/status 查看执行状态',
+		data: {
+			startTime: new Date().toISOString()
+		}
+	});
 });
 
+// 启动时初始化定时任务
+initScheduledTask();
+
 module.exports = router;