certctl-cli 1.0.6 → 1.0.10

package/API.md

@@ -236,62 +236,229 @@ function fixCertificateChain(domain, certPath) {
 
 ---
 
-## 方式二：完整的 Node.js SDK（需要额外开发）
+## 方式二：完整 SDK（含自动续期和证书链验证）
 
-如果你需要更优雅的 API，可以开发一个包装器。以下是一个设计提案：
+我们提供了完整的 SDK 封装，包含自动续期、证书链验证与修复等高级功能。
 
-### 安装方式
+### 安装
 
 ```bash
-npm install certctl-sdk
+npm install certctl-cli
 ```
 
-### 期望的 API 设计
+### 使用 SDK
 
 ```javascript
-const { CertctlClient } = require('certctl-sdk');
+const { CertctlSDK } = require('certctl-cli/examples/certctl-sdk');
 
-// 创建客户端
-const client = new CertctlClient({
+// 创建 SDK 实例
+const sdk = new CertctlSDK({
   email: 'admin@example.com',
   outputDir: './certs',
-  staging: false // 是否为测试环境
+  
+  // DNS 配置（用于自动续期）
+  dns: {
+    provider: 'aliyun',
+    accessKeyId: process.env.ALI_KEY,
+    accessKeySecret: process.env.ALI_SECRET
+  },
+  
+  // 自动续期配置
+  autoRenew: true,              // 开启自动续期
+  renewBeforeDays: 30,          // 到期前30天续期
+  checkInterval: 24 * 60 * 60 * 1000,  // 每天检查
 });
 
-// 申请证书
-const cert = await client.apply({
-  domain: 'example.com',
+// 监听事件
+sdk.on('apply:success', ({ domain, certInfo }) => {
+  console.log(`✅ 证书申请成功: ${domain}`);
+});
+
+sdk.on('verify:fixing', ({ domain }) => {
+  console.log(`🔧 正在自动修复证书链: ${domain}`);
+});
+
+sdk.on('autoRenew:trigger', ({ domain, reason }) => {
+  console.log(`🔄 自动续期: ${domain} (${reason})`);
+});
+
+// 申请证书（自动验证并修复证书链）
+const result = await sdk.apply('example.com', {
+  verifyChain: true,    // 申请后验证证书链
+  autoFix: true,        // 链不完整时自动修复
+});
+
+// 返回结果
+// {
+//   success: true,
+//   domain: 'example.com',
+//   paths: { cert: '...', key: '...' },
+//   chainValid: true,      // 证书链是否完整
+//   chainLength: 2,        // 证书链长度
+//   expireDays: 89         // 剩余天数
+// }
+```
+
+### SDK 配置选项
+
+| 选项 | 类型 | 默认值 | 说明 |
+|------|------|--------|------|
+| `email` | string | - | Let's Encrypt 账户邮箱 |
+| `outputDir` | string | './certs' | 证书输出目录 |
+| `autoRenew` | boolean | true | 是否开启自动续期 |
+| `renewBeforeDays` | number | 30 | 到期前多少天续期 |
+| `checkInterval` | number | 86400000 | 检查间隔（毫秒） |
+| `dns` | object | null | DNS 配置用于自动续期 |
+
+### SDK 方法
+
+#### `apply(domain, options)` - 申请证书
+
+```javascript
+const result = await sdk.apply('example.com', {
+  email: 'admin@example.com',      // 可选
+  verifyChain: true,                // 验证证书链
+  autoFix: true,                    // 自动修复
+  dns: { provider: 'aliyun', ... }  // 可选
+});
+```
+
+#### `verify(domain, options)` - 验证证书（含自动修复）
+
+```javascript
+const result = await sdk.verify('example.com', {
+  autoFix: true  // 验证失败时自动修复证书链
+});
+
+// 返回结果
+// {
+//   valid: true,           // 是否通过
+//   chainValid: true,      // 证书链完整
+//   chainLength: 2,
+//   expireDays: 89,
+//   domainMatch: true,
+//   notExpired: true
+// }
+```
+
+#### `renew(domain, options)` - 续期证书
+
+```javascript
+const result = await sdk.renew('example.com', {
+  autoFix: true   // 续期后自动修复
+});
+```
+
+#### `checkRenewal(domain)` - 检查是否需要续期
+
+```javascript
+const status = await sdk.checkRenewal('example.com');
+
+// 返回结果
+// {
+//   needRenew: false,      // 是否需要续期
+//   reason: '...',         // 原因
+//   expireDays: 89,
+//   chainValid: true
+// }
+```
+
+#### `startAutoRenew(domains)` - 启动自动续期服务
+
+```javascript
+// 启动自动续期监控
+sdk.startAutoRenew(['example.com', 'api.example.com']);
+
+// 服务会自动：
+// 1. 定期检查证书有效期
+// 2. 证书链不完整时自动修复
+// 3. 即将过期时自动续期
+// 4. 通过事件通知状态变化
+```
+
+#### `stopAutoRenew()` - 停止自动续期
+
+```javascript
+sdk.stopAutoRenew();
+```
+
+### SDK 事件
+
+| 事件名 | 参数 | 说明 |
+|--------|------|------|
+| `apply:success` | `{ domain, certInfo }` | 证书申请成功 |
+| `verify:fixing` | `{ domain }` | 正在修复证书链 |
+| `verify:success` | `{ domain, ... }` | 验证通过 |
+| `autoRenew:trigger` | `{ domain, reason }` | 触发自动续期 |
+| `autoRenew:error` | `{ domain, error }` | 自动续期失败 |
+
+### Express HTTP API + 自动续期完整示例
+
+```javascript
+const express = require('express');
+const { CertctlSDK } = require('certctl-cli/examples/certctl-sdk');
+
+const app = express();
+app.use(express.json());
+
+// 创建 SDK 实例
+const sdk = new CertctlSDK({
+  email: process.env.ACME_EMAIL,
+  outputDir: './certs',
+  autoRenew: true,
+  renewBeforeDays: 30,
   dns: {
     provider: 'aliyun',
-    accessKeyId: 'your-key',
-    accessKeySecret: 'your-secret'
+    accessKeyId: process.env.ALI_KEY,
+    accessKeySecret: process.env.ALI_SECRET
   }
 });
 
-console.log(cert.paths);
-// {
-//   cert: './certs/example.com/example.com.pem',
-//   key: './certs/example.com/example.com.key'
-// }
+// 监听事件
+sdk.on('apply:success', ({ domain }) => console.log(`[${new Date().toISOString()}] 申请成功: ${domain}`));
+sdk.on('autoRenew:trigger', ({ domain, reason }) => console.log(`[${new Date().toISOString()}] 自动续期: ${domain} - ${reason}`));
+
+// API: 申请证书（自动验证并修复证书链）
+app.post('/api/certs/:domain', async (req, res) => {
+  try {
+    const result = await sdk.apply(req.params.domain, {
+      verifyChain: true,   // 验证证书链
+      autoFix: true        // 自动修复
+    });
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// API: 验证证书（自动修复）
+app.get('/api/certs/:domain/verify', async (req, res) => {
+  const result = await sdk.verify(req.params.domain, { autoFix: true });
+  res.json(result);
+});
 
-// 续期
-await client.renew('example.com');
+// API: 检查续期状态
+app.get('/api/certs/:domain/renewal-status', async (req, res) => {
+  const result = await sdk.checkRenewal(req.params.domain);
+  res.json(result);
+});
 
-// 验证
-const isValid = await client.verify('example.com');
+// 启动自动续期服务
+sdk.startAutoRenew(['example.com', 'api.example.com']);
 
-// 修复证书链
-await client.fixChain('example.com');
+app.listen(3000, () => {
+  console.log('🚀 证书管理 API 已启动');
+});
 ```
 
-### 是否需要开发 SDK？
+### 示例文件位置
+
+安装后可在 `node_modules/certctl-cli/examples/` 找到：
 
-| 场景 | 建议 |
-|------|------|
-| 只是简单调用 | 使用方式一（子进程）即可 |
-| 需要深度集成 | 可以开发 `certctl-sdk` |
-| 需要事件通知 | 子进程方式可以实时获取输出 |
-| 需要类型支持 | 可以添加 TypeScript 定义 |
+- `certctl-sdk.js` - 完整 SDK 源码
+- `sdk-usage.js` - SDK 使用示例
+- `express-server.js` - Express 集成示例
+- `basic-usage.js` - 基础调用示例
 
 ---
 

package/examples/README.md

@@ -2,49 +2,87 @@
 
 这里提供了在 Node.js 项目中使用 certctl 的各种示例。
 
-## 示例列表
+## 🚀 推荐：SDK 方式（certctl-sdk.js）
 
-### 1. basic-usage.js - 基础使用示例
+最推荐的方式，包含**自动续期**和**证书链自动修复**功能。
 
-展示如何在 Node.js 代码中调用 certctl 命令。
+### 快速开始
 
-**功能：**
-- 申请证书（支持阿里云自动验证）
-- 验证证书
-- 修复证书链
-- 续期证书
+```javascript
+const { CertctlSDK } = require('./certctl-sdk');
+
+const sdk = new CertctlSDK({
+  email: 'admin@example.com',
+  autoRenew: true,
+  dns: {
+    provider: 'aliyun',
+    accessKeyId: process.env.ALI_KEY,
+    accessKeySecret: process.env.ALI_SECRET
+  }
+});
+
+// 申请证书（自动验证并修复证书链）
+const result = await sdk.apply('example.com', {
+  verifyChain: true,
+  autoFix: true
+});
+
+// 启动自动续期监控
+sdk.startAutoRenew(['example.com', 'api.example.com']);
+```
+
+### 2. sdk-usage.js - SDK 完整使用示例
+
+展示 SDK 的所有功能：
+- 证书申请（自动验证链）
+- 自动续期服务
+- 事件监听
+- 批量管理
 
 **运行：**
 ```bash
-# 使用手动验证
-node basic-usage.js example.com
-
-# 使用阿里云自动验证（需设置环境变量）
-export ALI_KEY=your-access-key
-export ALI_SECRET=your-access-secret
+export ALI_KEY=your-key
+export ALI_SECRET=your-secret
 export ACME_EMAIL=admin@example.com
-node basic-usage.js example.com
+node sdk-usage.js example.com
 ```
 
-### 2. express-server.js - Express HTTP API
+### 3. certctl-sdk.js - SDK 源码
 
-提供一个完整的 HTTP API 服务，通过 REST API 管理证书。
+完整的 SDK 实现，包含：
+- 自动续期机制
+- 证书链验证与修复
+- 事件通知
+- 完整错误处理
+
+可直接复制到你的项目中使用。
+
+---
+
+## 基础示例
+
+### 4. basic-usage.js - 基础使用示例
+
+展示如何在 Node.js 代码中调用 certctl 命令。
 
 **功能：**
-- 列出所有证书
-- 申请新证书
-- 续期证书
+- 申请证书（支持阿里云自动验证）
 - 验证证书
 - 修复证书链
-- 下载证书文件
+- 续期证书
 
-**安装：**
+**运行：**
 ```bash
-npm install express certctl-cli
+node basic-usage.js example.com
 ```
 
+### 5. express-server.js - Express HTTP API
+
+提供一个完整的 HTTP API 服务，通过 REST API 管理证书。
+
 **运行：**
 ```bash
+npm install express
 node express-server.js
 ```
 
@@ -57,28 +95,17 @@ curl http://localhost:3000/api/certs
 # 申请证书（阿里云自动验证）
 curl -X POST http://localhost:3000/api/certs/example.com \
   -H "Content-Type: application/json" \
-  -d '{
-    "dns": {
-      "provider": "aliyun",
-      "accessKeyId": "your-key",
-      "accessKeySecret": "your-secret"
-    }
-  }'
+  -d '{"dns":{"provider":"aliyun","accessKeyId":"xxx","accessKeySecret":"xxx"}}'
 
 # 验证证书
-curl -X POST http://localhost:3000/api/certs/example.com/verify
+curl http://localhost:3000/api/certs/example.com/verify
 
 # 续期证书
 curl -X POST http://localhost:3000/api/certs/example.com/renew
-
-# 修复证书链
-curl -X POST http://localhost:3000/api/certs/example.com/fix-chain
-
-# 下载证书
-curl http://localhost:3000/api/certs/example.com/download?type=cert -o cert.pem
-curl http://localhost:3000/api/certs/example.com/download?type=key -o key.pem
 ```
 
-## 完整 API 文档
+---
+
+## 📚 完整 API 文档
 
 更多详细信息请参考：[API.md](../API.md)

package/examples/certctl-sdk.js

@@ -0,0 +1,517 @@
+/**
+ * Certctl 完整 SDK 封装
+ * 
+ * 特性：
+ * - 自动续期（定时检查）
+ * - 证书链验证与自动修复
+ * - 事件通知
+ * - 完整错误处理
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const EventEmitter = require('events');
+
+class CertctlSDK extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    
+    this.config = {
+      email: options.email || process.env.ACME_EMAIL,
+      outputDir: options.outputDir || './certs',
+      binaryPath: options.binaryPath || 'certctl',
+      // 自动续期配置
+      autoRenew: options.autoRenew !== false, // 默认开启
+      renewBeforeDays: options.renewBeforeDays || 30, // 到期前30天续期
+      checkInterval: options.checkInterval || 24 * 60 * 60 * 1000, // 每天检查一次
+      // DNS 配置（用于自动续期）
+      dns: options.dns || null, // { provider, accessKeyId, accessKeySecret }
+    };
+
+    this.timers = new Map(); // 存储定时器
+    this.isRunning = false;
+  }
+
+  /**
+   * ==========================================
+   * 核心命令执行
+   * ==========================================
+   */
+
+  _exec(args, options = {}) {
+    return new Promise((resolve, reject) => {
+      const { captureOutput = true, timeout = 300000 } = options;
+      
+      this.emit('command:start', { command: 'certctl', args });
+
+      const proc = spawn(this.config.binaryPath, args, {
+        stdio: captureOutput ? 'pipe' : 'inherit',
+        timeout
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      if (captureOutput) {
+        proc.stdout.on('data', (data) => {
+          stdout += data.toString();
+          this.emit('command:stdout', data.toString());
+        });
+
+        proc.stderr.on('data', (data) => {
+          stderr += data.toString();
+          this.emit('command:stderr', data.toString());
+        });
+      }
+
+      proc.on('error', (error) => {
+        this.emit('command:error', error);
+        reject(error);
+      });
+
+      proc.on('close', (code) => {
+        const result = { code, stdout, stderr, args };
+        
+        if (code === 0) {
+          this.emit('command:success', result);
+          resolve(result);
+        } else {
+          this.emit('command:fail', result);
+          reject(new Error(`Command failed with code ${code}: ${stderr || stdout}`));
+        }
+      });
+    });
+  }
+
+  /**
+   * ==========================================
+   * 证书申请
+   * ==========================================
+   */
+
+  /**
+   * 申请证书
+   * @param {string} domain - 域名
+   * @param {Object} options - 选项
+   * @param {string} options.email - 邮箱（可选，使用全局配置）
+   * @param {Object} options.dns - DNS 配置（可选）
+   * @param {boolean} options.verifyChain - 申请后是否验证证书链（默认 true）
+   * @param {boolean} options.autoFix - 验证失败时是否自动修复（默认 true）
+   */
+  async apply(domain, options = {}) {
+    const opts = { ...this.config, ...options };
+    
+    this.emit('apply:start', { domain });
+
+    try {
+      // 1. 构建参数
+      const args = [
+        'apply',
+        '-d', domain,
+        '-e', opts.email,
+        '-o', opts.outputDir
+      ];
+
+      // 添加 DNS 配置
+      if (opts.dns) {
+        if (opts.dns.provider === 'aliyun') {
+          args.push('--dns', 'aliyun');
+          args.push('--ali-key', opts.dns.accessKeyId);
+          args.push('--ali-secret', opts.dns.accessKeySecret);
+        } else if (opts.dns.provider === 'tencentcloud') {
+          args.push('--dns', 'tencentcloud');
+          args.push('--tencent-id', opts.dns.secretId);
+          args.push('--tencent-secret', opts.dns.secretKey);
+        }
+      }
+
+      // 2. 执行申请
+      await this._exec(args);
+
+      // 3. 获取证书信息
+      let certInfo = this._getCertPaths(domain);
+
+      // 4. 验证证书链（可选）
+      if (opts.verifyChain !== false) {
+        const verifyResult = await this.verify(domain, { 
+          autoFix: opts.autoFix 
+        });
+        certInfo = { ...certInfo, ...verifyResult };
+      }
+
+      // 5. 启动自动续期监控（如果开启）
+      if (this.config.autoRenew) {
+        this._startRenewMonitor(domain);
+      }
+
+      this.emit('apply:success', { domain, certInfo });
+      
+      return {
+        success: true,
+        domain,
+        ...certInfo
+      };
+
+    } catch (error) {
+      this.emit('apply:error', { domain, error });
+      throw error;
+    }
+  }
+
+  /**
+   * ==========================================
+   * 证书验证
+   * ==========================================
+   */
+
+  /**
+   * 验证证书
+   * @param {string} domain - 域名
+   * @param {Object} options - 选项
+   * @param {boolean} options.autoFix - 验证失败时自动修复（默认 false）
+   * @returns {Object} 验证结果
+   */
+  async verify(domain, options = {}) {
+    this.emit('verify:start', { domain });
+
+    try {
+      const args = ['verify', '-d', domain, '-o', this.config.outputDir];
+      
+      // 如果需要自动修复，添加 --fix 参数
+      if (options.autoFix) {
+        args.push('--fix');
+      }
+
+      const result = await this._exec(args, { captureOutput: true });
+      
+      // 解析验证结果
+      const verifyInfo = this._parseVerifyOutput(result.stdout);
+      
+      this.emit('verify:success', { domain, ...verifyInfo });
+      
+      return {
+        valid: true,
+        domain,
+        ...verifyInfo
+      };
+
+    } catch (error) {
+      // 验证失败，尝试获取详细信息
+      const verifyInfo = this._parseVerifyOutput(error.message);
+      
+      const result = {
+        valid: false,
+        domain,
+        error: error.message,
+        ...verifyInfo
+      };
+
+      // 自动修复
+      if (options.autoFix && !verifyInfo.chainValid) {
+        this.emit('verify:fixing', { domain });
+        
+        try {
+          await this.fixChain(domain);
+          
+          // 重新验证
+          return this.verify(domain, { autoFix: false });
+        } catch (fixError) {
+          result.fixError = fixError.message;
+          this.emit('verify:fixFailed', { domain, error: fixError });
+        }
+      }
+
+      this.emit('verify:fail', result);
+      return result;
+    }
+  }
+
+  /**
+   * 解析验证输出
+   */
+  _parseVerifyOutput(output) {
+    const info = {
+      chainValid: false,
+      chainLength: 0,
+      domainMatch: false,
+      notExpired: false,
+      expireDays: 0
+    };
+
+    // 解析证书链长度
+    const chainMatch = output.match(/证书链长度[:：]\s*(\d+)/);
+    if (chainMatch) {
+      info.chainLength = parseInt(chainMatch[1]);
+      info.chainValid = info.chainLength >= 2;
+    }
+
+    // 解析剩余天数
+    const daysMatch = output.match(/剩余\s*(\d+)\s*天/);
+    if (daysMatch) {
+      info.expireDays = parseInt(daysMatch[1]);
+      info.notExpired = info.expireDays > 0;
+    }
+
+    // 检查是否通过
+    if (output.includes('✅ 证书验证通过') || output.includes('验证通过')) {
+      info.chainValid = true;
+      info.domainMatch = true;
+      info.notExpired = true;
+    }
+
+    return info;
+  }
+
+  /**
+   * ==========================================
+   * 修复证书链
+   * ==========================================
+   */
+
+  /**
+   * 修复证书链
+   * @param {string} domain - 域名
+   */
+  async fixChain(domain) {
+    this.emit('fixChain:start', { domain });
+
+    try {
+      await this._exec([
+        'fix-chain',
+        '-d', domain,
+        '-o', this.config.outputDir
+      ]);
+
+      this.emit('fixChain:success', { domain });
+      
+      return {
+        success: true,
+        domain
+      };
+
+    } catch (error) {
+      this.emit('fixChain:error', { domain, error });
+      throw error;
+    }
+  }
+
+  /**
+   * ==========================================
+   * 续期功能
+   * ==========================================
+   */
+
+  /**
+   * 手动续期证书
+   * @param {string} domain - 域名
+   * @param {Object} options - 选项
+   */
+  async renew(domain, options = {}) {
+    this.emit('renew:start', { domain });
+
+    try {
+      const args = [
+        'renew',
+        '-d', domain,
+        '-o', this.config.outputDir
+      ];
+
+      // 如果需要 DNS 自动验证，添加参数
+      if (options.dns || this.config.dns) {
+        const dns = options.dns || this.config.dns;
+        if (dns.provider === 'aliyun') {
+          args.push('--dns', 'aliyun');
+          args.push('--ali-key', dns.accessKeyId);
+          args.push('--ali-secret', dns.accessKeySecret);
+        }
+      }
+
+      await this._exec(args);
+
+      // 验证新证书
+      const verifyResult = await this.verify(domain, { 
+        autoFix: options.autoFix !== false 
+      });
+
+      this.emit('renew:success', { domain, verifyResult });
+
+      return {
+        success: true,
+        domain,
+        ...this._getCertPaths(domain),
+        ...verifyResult
+      };
+
+    } catch (error) {
+      this.emit('renew:error', { domain, error });
+      throw error;
+    }
+  }
+
+  /**
+   * 检查证书是否需要续期
+   */
+  async checkRenewal(domain) {
+    const verifyResult = await this.verify(domain);
+    
+    if (!verifyResult.valid) {
+      return {
+        needRenew: true,
+        reason: '证书无效',
+        ...verifyResult
+      };
+    }
+
+    if (verifyResult.expireDays <= this.config.renewBeforeDays) {
+      return {
+        needRenew: true,
+        reason: `证书将在 ${verifyResult.expireDays} 天后过期`,
+        ...verifyResult
+      };
+    }
+
+    return {
+      needRenew: false,
+      expireDays: verifyResult.expireDays,
+      ...verifyResult
+    };
+  }
+
+  /**
+   * 启动自动续期监控
+   */
+  startAutoRenew(domains) {
+    if (this.isRunning) {
+      console.log('自动续期服务已在运行');
+      return;
+    }
+
+    this.isRunning = true;
+    this.emit('autoRenew:start', { domains });
+
+    // 立即检查一次
+    this._checkAndRenew(domains);
+
+    // 定时检查
+    const timer = setInterval(() => {
+      this._checkAndRenew(domains);
+    }, this.config.checkInterval);
+
+    this.timers.set('autoRenew', timer);
+    
+    console.log(`✅ 自动续期服务已启动，检查间隔: ${this.config.checkInterval / 1000 / 60} 分钟`);
+  }
+
+  /**
+   * 停止自动续期
+   */
+  stopAutoRenew() {
+    this.isRunning = false;
+    
+    for (const [name, timer] of this.timers) {
+      clearInterval(timer);
+      console.log(`⏹️  已停止: ${name}`);
+    }
+    
+    this.timers.clear();
+    this.emit('autoRenew:stop');
+  }
+
+  /**
+   * 检查并续期
+   */
+  async _checkAndRenew(domains) {
+    for (const domain of domains) {
+      try {
+        const check = await this.checkRenewal(domain);
+        
+        if (check.needRenew) {
+          this.emit('autoRenew:trigger', { domain, reason: check.reason });
+          console.log(`🔄 [${new Date().toISOString()}] ${domain}: ${check.reason}，开始续期...`);
+          
+          await this.renew(domain);
+          console.log(`✅ [${new Date().toISOString()}] ${domain}: 续期成功`);
+        } else {
+          console.log(`✓ [${new Date().toISOString()}] ${domain}: 证书正常，${check.expireDays}天后过期`);
+        }
+      } catch (error) {
+        console.error(`❌ [${new Date().toISOString()}] ${domain}: 检查/续期失败 - ${error.message}`);
+        this.emit('autoRenew:error', { domain, error });
+      }
+    }
+  }
+
+  /**
+   * 为单个域名启动续期监控
+   */
+  _startRenewMonitor(domain) {
+    if (!this.config.autoRenew) return;
+
+    console.log(`🔄 已为 ${domain} 启用自动续期监控`);
+    
+    // 这里只是标记，实际的定时任务由 startAutoRenew 统一管理
+    // 或者可以单独为每个域名设置定时器
+  }
+
+  /**
+   * ==========================================
+   * 工具方法
+   * ==========================================
+   */
+
+  /**
+   * 获取证书路径
+   */
+  _getCertPaths(domain) {
+    const baseDir = path.join(this.config.outputDir, domain);
+    return {
+      domain,
+      exists: fs.existsSync(path.join(baseDir, `${domain}.pem`)),
+      paths: {
+        cert: path.join(baseDir, `${domain}.pem`),
+        key: path.join(baseDir, `${domain}.key`)
+      },
+      dir: baseDir
+    };
+  }
+
+  /**
+   * 列出所有证书
+   */
+  list() {
+    const certs = [];
+    const baseDir = this.config.outputDir;
+
+    if (!fs.existsSync(baseDir)) {
+      return certs;
+    }
+
+    const domains = fs.readdirSync(baseDir);
+    for (const domain of domains) {
+      const domainPath = path.join(baseDir, domain);
+      if (fs.statSync(domainPath).isDirectory()) {
+        certs.push(this._getCertPaths(domain));
+      }
+    }
+
+    return certs;
+  }
+
+  /**
+   * 删除证书
+   */
+  remove(domain) {
+    const certInfo = this._getCertPaths(domain);
+    
+    if (certInfo.exists) {
+      fs.rmSync(certInfo.dir, { recursive: true, force: true });
+      this.emit('remove', { domain });
+      return true;
+    }
+    
+    return false;
+  }
+}
+
+module.exports = { CertctlSDK };

package/examples/sdk-usage.js

@@ -0,0 +1,224 @@
+/**
+ * Certctl SDK 完整使用示例
+ * 
+ * 展示如何使用 SDK 实现：
+ * - 证书申请（自动验证证书链）
+ * - 自动续期
+ * - 事件监听
+ * - 批量管理
+ */
+
+const { CertctlSDK } = require('./certctl-sdk');
+
+// ==================== 配置 ====================
+const config = {
+  email: process.env.ACME_EMAIL || 'admin@example.com',
+  outputDir: './my-certs',
+  
+  // DNS 配置（用于自动续期）
+  dns: {
+    provider: 'aliyun',
+    accessKeyId: process.env.ALI_KEY,
+    accessKeySecret: process.env.ALI_SECRET
+  },
+  
+  // 自动续期配置
+  autoRenew: true,              // 开启自动续期
+  renewBeforeDays: 30,          // 到期前30天自动续期
+  checkInterval: 60 * 1000,     // 每分钟检查一次（生产环境建议每天）
+};
+
+// ==================== 创建 SDK 实例 ====================
+const sdk = new CertctlSDK(config);
+
+// ==================== 事件监听 ====================
+
+sdk.on('apply:start', ({ domain }) => {
+  console.log(`📝 开始申请证书: ${domain}`);
+});
+
+sdk.on('apply:success', ({ domain, certInfo }) => {
+  console.log(`✅ 证书申请成功: ${domain}`);
+  console.log(`   证书路径: ${certInfo.paths.cert}`);
+  console.log(`   私钥路径: ${certInfo.paths.key}`);
+  console.log(`   链完整: ${certInfo.chainValid ? '✅' : '❌'}`);
+});
+
+sdk.on('verify:fixing', ({ domain }) => {
+  console.log(`🔧 证书链不完整，正在自动修复: ${domain}`);
+});
+
+sdk.on('verify:success', ({ domain, chainValid, expireDays }) => {
+  console.log(`✅ 验证通过: ${domain} (链完整: ${chainValid}, ${expireDays}天后过期)`);
+});
+
+sdk.on('verify:fail', ({ domain, chainValid, error }) => {
+  console.error(`❌ 验证失败: ${domain}`);
+  console.error(`   错误: ${error}`);
+});
+
+sdk.on('autoRenew:trigger', ({ domain, reason }) => {
+  console.log(`🔄 触发自动续期: ${domain} (${reason})`);
+});
+
+sdk.on('autoRenew:error', ({ domain, error }) => {
+  console.error(`❌ 自动续期失败: ${domain} - ${error.message}`);
+});
+
+// ==================== 使用示例 ====================
+
+async function examples() {
+  const domain = process.argv[2] || 'example.com';
+
+  console.log('========================================');
+  console.log('Certctl SDK 使用示例');
+  console.log('========================================\n');
+
+  // -------------------- 示例 1: 申请证书（自动验证链） --------------------
+  console.log('\n📌 示例 1: 申请证书（自动验证证书链）\n');
+  
+  try {
+    // 申请证书，自动验证并修复证书链
+    const result = await sdk.apply(domain, {
+      verifyChain: true,    // 申请后验证证书链
+      autoFix: true,        // 链不完整时自动修复
+    });
+
+    console.log('\n申请结果:', result);
+
+  } catch (error) {
+    console.error('申请失败:', error.message);
+  }
+
+  // -------------------- 示例 2: 手动验证证书 --------------------
+  console.log('\n📌 示例 2: 手动验证证书\n');
+
+  const verifyResult = await sdk.verify(domain, { autoFix: true });
+  console.log('验证结果:', {
+    有效: verifyResult.valid,
+    链完整: verifyResult.chainValid,
+    链长度: verifyResult.chainLength,
+    剩余天数: verifyResult.expireDays,
+  });
+
+  // -------------------- 示例 3: 检查是否需要续期 --------------------
+  console.log('\n📌 示例 3: 检查续期状态\n');
+
+  const renewalStatus = await sdk.checkRenewal(domain);
+  console.log('续期检查:', {
+    需要续期: renewalStatus.needRenew,
+    原因: renewalStatus.reason,
+    剩余天数: renewalStatus.expireDays,
+  });
+
+  // -------------------- 示例 4: 手动续期 --------------------
+  if (renewalStatus.needRenew) {
+    console.log('\n📌 示例 4: 手动续期\n');
+    
+    try {
+      const renewResult = await sdk.renew(domain, { autoFix: true });
+      console.log('续期结果:', renewResult);
+    } catch (error) {
+      console.error('续期失败:', error.message);
+    }
+  }
+
+  // -------------------- 示例 5: 列出所有证书 --------------------
+  console.log('\n📌 示例 5: 列出所有证书\n');
+  
+  const allCerts = sdk.list();
+  console.log(`共有 ${allCerts.length} 个证书:`);
+  for (const cert of allCerts) {
+    console.log(`  - ${cert.domain}: ${cert.exists ? '✅' : '❌'}`);
+  }
+
+  // -------------------- 示例 6: 启动自动续期服务 --------------------
+  console.log('\n📌 示例 6: 启动自动续期服务\n');
+  
+  // 启动自动续期，监控多个域名
+  const domainsToMonitor = [domain];
+  sdk.startAutoRenew(domainsToMonitor);
+
+  console.log('自动续期服务已启动，按 Ctrl+C 停止\n');
+
+  // 保持进程运行
+  process.on('SIGINT', () => {
+    console.log('\n\n正在停止服务...');
+    sdk.stopAutoRenew();
+    process.exit(0);
+  });
+}
+
+// 运行示例
+examples().catch(console.error);
+
+/*
+============================
+其他使用场景
+============================
+
+// 场景 1: 批量申请多个域名
+async function batchApply() {
+  const domains = ['api.example.com', 'app.example.com', 'cdn.example.com'];
+  
+  for (const domain of domains) {
+    try {
+      await sdk.apply(domain, { verifyChain: true, autoFix: true });
+      console.log(`✅ ${domain} 申请成功`);
+    } catch (error) {
+      console.error(`❌ ${domain} 申请失败: ${error.message}`);
+    }
+  }
+}
+
+// 场景 2: 定期验证所有证书
+async function validateAll() {
+  const certs = sdk.list();
+  
+  for (const cert of certs) {
+    const result = await sdk.verify(cert.domain, { autoFix: true });
+    
+    if (!result.valid) {
+      console.error(`⚠️  ${cert.domain} 证书异常，需要处理`);
+    }
+  }
+}
+
+// 场景 3: 在 Express 中使用
+const express = require('express');
+const app = express();
+
+// 申请证书 API
+app.post('/api/certs/:domain', async (req, res) => {
+  const { domain } = req.params;
+  
+  try {
+    const result = await sdk.apply(domain, { 
+      verifyChain: true, 
+      autoFix: true 
+    });
+    res.json({ success: true, data: result });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// 验证证书 API
+app.get('/api/certs/:domain/verify', async (req, res) => {
+  const { domain } = req.params;
+  const result = await sdk.verify(domain, { autoFix: true });
+  res.json(result);
+});
+
+// 检查续期状态 API
+app.get('/api/certs/:domain/renewal-status', async (req, res) => {
+  const { domain } = req.params;
+  const result = await sdk.checkRenewal(domain);
+  res.json(result);
+});
+
+// 启动自动续期服务
+sdk.startAutoRenew(['example.com', 'api.example.com']);
+
+app.listen(3000);
+*/

package/package.json

@@ -1,10 +1,19 @@
 {
       "name": "certctl-cli",
-      "version": "1.0.6",
+      "version": "1.0.10",
       "description": "Lightweight SSL Certificate CLI Tool",
       "bin": {
             "certctl": "bin/run.js"
       },
+      "scripts": {
+            "build": "cd .. && bash build.sh",
+            "version": "node scripts/version.js",
+            "postversion": "echo '✅ 版本已更新，运行 npm publish 发布'",
+            "release": "node scripts/release.js",
+            "release:minor": "node scripts/release.js minor",
+            "release:major": "node scripts/release.js major",
+            "publish:dry": "npm publish --dry-run"
+      },
       "files": [
             "bin/",
             "examples/",
@@ -36,4 +45,4 @@
       "engines": {
             "node": ">=14"
       }
-}
+}