mm_monitor 1.0.6 → 1.2.0

package/README.md

@@ -0,0 +1,128 @@
+# mm_monitor
+
+mm_monitor 是一个网站运行状态监听告警模块，按固定心跳间隔轮询检测目标 URL 是否可正常访问（HTTP 200），检测到异常时自动通过短信（短信宝接口）与邮件通知运维人员，并支持异常后的冷却重跑，避免连续重复告警。适合对线上服务做轻量级存活监控。
+
+## 项目信息
+
+- **当前版本**: 1.0.6
+- **更新日期**: 2026-10-04
+- **Gitee地址**: https://gitee.com/qiuwenwu91/mm_monitor
+- **依赖**:
+  - mm_https ^1.6.7（HTTP 客户端，用于探活请求）
+  - mm_phone ^1.0.2（短信发送，采用短信宝 API 接口）
+  - mm_email ^1.0.8（邮件发送）
+
+## 特点
+
+- 心跳轮询检测多个监听项，间隔可配置（默认 30 秒）。
+- 探活失败后间隔 1 秒自动复检一次，两次均失败才告警，减少误报。
+- 同一轮异常只告警一次（内部 `sended` 标志去重）。
+- 告警后停止轮询，进入冷却期（默认 3600 秒）后自动重新运行，避免连续通知轰炸。
+- 短信 + 邮件双通道通知，各通道可通过 `state` 开关独立启用。
+- 单项检测异常被 try/catch 捕获并记录日志，不影响其余监听项。
+
+## 安装
+
+```bash
+npm install mm_monitor
+```
+
+## 基本使用
+
+```javascript
+const Monitor = require('mm_monitor');
+
+const monitor = new Monitor({
+  phone: {                 // 短信通道（短信宝）
+    state: 1,              // 是否启用
+    username: 'your-sms-user',
+    password: 'your-sms-password'
+  },
+  email: {                 // 邮件通道
+    state: 1,
+    host: 'smtp.qq.com',
+    username: 'ops@qq.com',
+    password: 'your-smtp-authcode'
+  },
+  listen: [
+    {
+      name: 'AI考勤系统',   // 网站名称
+      url: 'https://example.com/api/health', // 探活地址
+      email: 'ops@qq.com',  // 告警邮箱
+      phone: '13800000000', // 告警手机号
+      content: '【考勤系统】服务器异常，请尽快进行维护！' // 告警内容
+    }
+  ],
+  interval: 30,             // 心跳间隔（秒）
+  interval_again: 3600      // 告警后冷却时长（秒）
+});
+
+monitor.run();              // 启动监听
+```
+
+## API 说明
+
+导出唯一类 `Monitor`。
+
+### 构造函数
+
+`new Monitor(config)` — `config` 会与内置默认配置合并（`Object.assign`），并自动调用 `init` 初始化短信、邮件通道实例。
+
+| 配置项 | 类型 | 默认值 | 说明 |
+| --- | --- | --- | --- |
+| phone | `Object` | `{ state: 1, username: '', password: '' }` | 短信通道配置，传给 `mm_phone`（短信宝接口）；`state` 为是否启用 |
+| email | `Object` | `{ state: 1, host: 'smtp.qq.com', username: '', password: '' }` | 邮件通道配置，传给 `mm_email`；`password` 一般为 SMTP 授权码 |
+| listen | `Array` | `[]` | 监听项列表，每项含 `name`（网站名称）、`url`（探活地址）、`email`（告警邮箱）、`phone`（告警手机号）、`content`（告警内容） |
+| interval | `Number` | `30` | 心跳轮询间隔，单位秒 |
+| interval_again | `Number` | `3600` | 出现异常并告警后的冷却时长，单位秒，到期后自动重新 `run` |
+
+### 实例方法
+
+| 方法 | 签名 | 返回值 | 说明 |
+| --- | --- | --- | --- |
+| init | `await init(config)` | `Promise` | 合并配置到 `this.config`，创建 `mm_phone` 短信实例与 `mm_email` 邮件实例。构造函数已自动调用 |
+| checkServer | `await checkServer(url)` | `Boolean` | 用 `mm_https` GET 请求 `url`，响应状态码为 200 返回 `true`，否则 `false` |
+| notiy | `await notiy(o)` | `Promise` | 发送告警（方法名拼写以源码为准）。解构 `o` 的 `phone`、`email`、`title`、`content`：先 `sms.send(phone, content)`，再 `email.send(title || '服务器异常', content, null, email)` |
+| loop | `await loop()` | `Promise` | 执行一轮巡检：逐项 `checkServer`，失败则 1 秒后复检；仍未恢复且本轮未告警过则调用 `notiy`。若本轮发生告警，停止定时器并在 `interval_again` 秒后重新 `run` |
+| run | `await run()` | `Promise` | 重置告警标志，按 `interval` 秒周期启动 `setInterval` 循环执行 `loop` |
+
+> 注意：运行依赖全局工具对象 `$`（`$.log` 日志、`$.sleep` 延时），需在已加载相应基础库的环境中使用。
+
+## 使用示例
+
+### 场景一：从配置文件启动监听
+
+```javascript
+const Monitor = require('mm_monitor');
+
+const config = './config.json'.loadJson(); // 含 phone/email/listen/interval 等
+const monitor = new Monitor(config);
+monitor.run();
+```
+
+### 场景二：监听多个站点
+
+```javascript
+const monitor = new Monitor({
+  phone: { state: 1, username: 'sms-user', password: 'sms-pass' },
+  email: { state: 1, host: 'smtp.qq.com', username: 'ops@qq.com', password: 'authcode' },
+  listen: [
+    { name: '官网',   url: 'https://www.example.com',        email: 'ops@qq.com', phone: '13800000000', content: '【官网】服务器异常，请尽快维护！' },
+    { name: 'API服务', url: 'https://api.example.com/health', email: 'ops@qq.com', phone: '13800000000', content: '【API】服务不可用，请尽快维护！' }
+  ],
+  interval: 60
+});
+monitor.run();
+```
+
+### 场景三：仅手动单次探活（不启动定时器）
+
+```javascript
+const Monitor = require('mm_monitor');
+
+const monitor = new Monitor({});
+(async () => {
+  const ok = await monitor.checkServer('https://www.example.com');
+  console.log(ok ? '服务正常' : '服务异常');
+})();
+```

package/example/index.js

@@ -0,0 +1,48 @@
+/**
+ * mm_monitor 最小可运行示例
+ * @description 演示 Monitor 类的实例化、工厂获取实例与核心方法存在性。
+ * 注意：不会真正发起网站检测与短信/邮件通知；phone/email 配置为示例假值，实际使用时请替换为真实配置。
+ */
+const { Monitor, monitorAdmin } = require('../index.js');
+
+/** 示例假配置（实际使用时替换为真实的手机号/邮箱通知配置） */
+const CONFIG = {
+  phone: {
+    state: 0,
+    username: 'example_user',
+    password: 'example_password'
+  },
+  email: {
+    state: 0,
+    host: 'smtp.qq.com',
+    username: 'example@qq.com',
+    password: 'example_code'
+  },
+  listen: [],
+  interval: 60
+};
+
+/**
+ * 主函数
+ */
+function main() {
+  console.log('== mm_monitor 示例开始 ==');
+
+  // 实例化（仅初始化配置与通知器，不启动监听）
+  const monitor = new Monitor(CONFIG);
+  console.log('实例化 Monitor 成功');
+  console.log('监听列表:', Array.isArray(monitor.config.listen) ? monitor.config.listen.length + ' 项' : '无效');
+
+  // 通过工厂函数获取按作用域缓存的实例
+  const inst = monitorAdmin('example', { listen: [] });
+  console.log('monitorAdmin 获取实例:', inst instanceof Monitor);
+
+  // 核心方法存在性检查（不真正执行，避免联网检测与发送通知）
+  const METHODS = ['init', 'checkServer', 'notiy', 'loop', 'run'];
+  const missing = METHODS.filter((name) => typeof inst[name] !== 'function');
+  console.log('核心方法检查:', missing.length === 0 ? '全部存在' : '缺失: ' + missing.join(','));
+
+  console.log('== mm_monitor 示例结束 ==');
+}
+
+main();

package/index.js

@@ -1,143 +1,16 @@
-const Http = require('mm_https');
-const SMS = require('mm_phone');
-const Email = require('mm_email');
-
-/**
- * 短信通知类: 采用短信宝的API接口
- */
-class Monitor {
-	/**
-	 * 构造函数
-	 * @param {Object} config 配置参数
-	 */
-	constructor(config) {
-		this.config = {
-			phone: {
-				// 是否启用
-				state: 1,
-				// 用户名
-				username: '',
-				// 密码，一般为授权码
-				password: ''
-			},
-			email: {
-				// 是否启用
-				state: 1,
-				// 服务器地址
-				host: 'smtp.qq.com',
-				// 用户名
-				username: 'xxxxxx@qq.com',
-				// 密码，一般为授权码
-				password: ''
-			},
-			listen: [
-				// {
-				// 	// 网站名称
-				// 	name: "AI考勤系统",
-				// 	// URL地址
-				// 	url: "https://xxx.xxx.com/xxx/xxx/xxx",
-				// 	// 推送到邮箱
-				// 	email: "xxx@qq.com",
-				// 	// 发送短信到
-				// 	phone: "xxx",
-				// 	// 推送的内容
-				// 	content: "【xxx】服务器异常，请尽快进行维护！--xxx系统"
-				// }
-			],
-			// 心跳间隔时长
-			interval: 30,
-			interval_again: 3600
-		}
-		// 是否已发送，用于避免重复发送
-		this.sended = false;
-		this.init(config);
-	}
-}
-
-/**
- * 初始化
- * @param {Object} config 配置
- */
-Monitor.prototype.init = async function(config) {
-	Object.assign(this.config, config);
-	this.sms = new SMS(this.config.phone);
-	this.email = new Email(this.config.email);
-}
-
-/**
- * 检测访问是否正常
- * @param {String} url 服务器地址
- */
-Monitor.prototype.checkServer = async function(url) {
-	var http = new Http();
-	var res = await http.get(url);
-	if (res.status == 200) {
-		return true;
-	} else {
-		return false;
-	}
-}
-
-/**
- * 通知
- * @param {Object} o 通知的对象信息
- */
-Monitor.prototype.notiy = async function(o) {
-	var {
-		phone,
-		email,
-		title,
-		content
-	} = o;
-	await this.sms.send(phone, content);
-	await this.email.send(title || "服务器异常", content, null, email);
-}
-
-/**
- * 循环检测
- */
-Monitor.prototype.loop = async function() {
-	var lt = this.config.listen;
-	var hasBug = false;
-	for (var i = 0; i < lt.length; i++) {
-		var o = lt[i];
-		try {
-			var bl = await this.checkServer(o.url);
-			if (!bl) {
-				$.sleep(1000);
-				bl = await this.checkServer(o.url);
-				if (!bl) {
-					$.log.debug("发生异常", (new Date()).toStr('yyyy-MM-dd hh:mm:ss'), o);
-					if (!this.sended) {
-						this.sended = true;
-						await this.notiy(o);
-						hasBug = true;
-					}
-				}
-			}
-		} catch (err) {
-			$.log.error(err);
-		}
-		$.sleep(1000);
-	}
-	if (hasBug) {
-		// 如果出现异常，则先暂停运行
-		clearInterval(this.timer);
-		// 等过了N久后再运行，避免连续通知
-		setTimeout(async () => {
-			await this.run();
-		}, this.config.interval_again * 1000);
-	}
-}
-
-/**
- * 运行监听
- */
-Monitor.prototype.run = async function() {
-	this.sended = false;
-	this.timer = setInterval(async () => {
-		await this.loop();
-	}, this.config.interval * 1000);
-}
-
-module.exports = Monitor;
+const Monitor = require('./lib/monitor');
+const { reg } = require('mm_admin');
+
+const admin = reg('mm_monitor');
+admin.setClass(Monitor);
+
+module.exports = {
+  Monitor,
+  admin,
+  monitorAdmin(scope, config = {}) {
+    return admin.get(scope || 'os', config);
+  }
+};
+/* mm-tool-logic-export 工具能力层：其它模块可 require("<pkg>").tools.<name> 直接引用 */
+Object.defineProperty(module.exports, 'tools', { enumerable: true, configurable: true,
+  get: function () { return require('./lib/tools'); } });

package/lib/monitor.js

@@ -0,0 +1,146 @@
+const Http = require('mm_https');
+const { sleep, date } = require('mm_helper');
+const SMS = require('mm_phone').Phone;
+const Email = require('mm_email').Mail;
+
+/**
+ * 短信通知类: 采用短信宝的API接口
+ */
+class Monitor {
+	/**
+	 * 构造函数
+	 * @param {Object} config 配置参数
+	 */
+	constructor(config) {
+		this.config = {
+			phone: {
+				// 是否启用
+				state: 1,
+				// 用户名
+				username: '',
+				// 密码，一般为授权码
+				password: ''
+			},
+			email: {
+				// 是否启用
+				state: 1,
+				// 服务器地址
+				host: 'smtp.qq.com',
+				// 用户名
+				username: 'xxxxxx@qq.com',
+				// 密码，一般为授权码
+				password: ''
+			},
+			listen: [
+				// {
+				// 	// 网站名称
+				// 	name: "AI考勤系统",
+				// 	// URL地址
+				// 	url: "https://xxx.xxx.com/xxx/xxx/xxx",
+				// 	// 推送到邮箱
+				// 	email: "xxx@qq.com",
+				// 	// 发送短信到
+				// 	phone: "xxx",
+				// 	// 推送的内容
+				// 	content: "【xxx】服务器异常，请尽快进行维护！--xxx系统"
+				// }
+			],
+			// 心跳间隔时长
+			interval: 30,
+			interval_again: 3600
+		}
+		// 是否已发送，用于避免重复发送
+		this.sended = false;
+		// 日志记录器（可经 config.logger 注入，缺省使用 console）
+		this._logger = config && config.logger ? config.logger : console;
+		this.init(config);
+	}
+}
+
+/**
+ * 初始化
+ * @param {Object} config 配置
+ */
+Monitor.prototype.init = async function(config) {
+	Object.assign(this.config, config);
+	this.sms = new SMS(this.config.phone);
+	this.email = new Email(this.config.email);
+}
+
+/**
+ * 检测访问是否正常
+ * @param {String} url 服务器地址
+ */
+Monitor.prototype.checkServer = async function(url) {
+	var http = new Http();
+	var res = await http.get(url);
+	if (res.status == 200) {
+		return true;
+	} else {
+		return false;
+	}
+}
+
+/**
+ * 通知
+ * @param {Object} o 通知的对象信息
+ */
+Monitor.prototype.notiy = async function(o) {
+	var {
+		phone,
+		email,
+		title,
+		content
+	} = o;
+	await this.sms.send(phone, content);
+	await this.email.send(title || "服务器异常", content, null, email);
+}
+
+/**
+ * 循环检测
+ */
+Monitor.prototype.loop = async function() {
+	var lt = this.config.listen;
+	var hasBug = false;
+	for (var i = 0; i < lt.length; i++) {
+		var o = lt[i];
+		try {
+			var bl = await this.checkServer(o.url);
+			if (!bl) {
+				await sleep(1000);
+				bl = await this.checkServer(o.url);
+				if (!bl) {
+					this._logger.debug("发生异常", date.toStr(new Date(), 'yyyy-MM-dd hh:mm:ss'), o);
+					if (!this.sended) {
+						this.sended = true;
+						await this.notiy(o);
+						hasBug = true;
+					}
+				}
+			}
+		} catch (err) {
+			this._logger.error(err);
+		}
+		await sleep(1000);
+	}
+	if (hasBug) {
+		// 如果出现异常，则先暂停运行
+		clearInterval(this.timer);
+		// 等过了N久后再运行，避免连续通知
+		setTimeout(async () => {
+			await this.run();
+		}, this.config.interval_again * 1000);
+	}
+}
+
+/**
+ * 运行监听
+ */
+Monitor.prototype.run = async function() {
+	this.sended = false;
+	this.timer = setInterval(async () => {
+		await this.loop();
+	}, this.config.interval * 1000);
+}
+
+module.exports = Monitor;

package/lib/tools/health/index.js

@@ -0,0 +1,99 @@
+/**
+ * 健康检查观察器
+ * 通过 os/process 模块读取真实系统状态
+ */
+var os = require('os');
+
+function getDir() {
+  return $?.run_path || process.cwd();
+}
+
+async function main(params, ctx, options) {
+  var checks = params.checks || ['memory', 'cpu', 'disk'];
+  var results = [];
+  var all_healthy = true;
+
+  for (var i = 0; i < checks.length; i++) {
+    var name = checks[i];
+    var result = { name: name };
+
+    switch (name) {
+      case 'memory': {
+        var total = os.totalmem();
+        var free = os.freemem();
+        var used_pct = Math.round((1 - free / total) * 100);
+        result.status = used_pct > 90 ? 'warn' : 'ok';
+        result.value = used_pct + '%';
+        result.detail = { total: total, free: free, used_pct: used_pct };
+        break;
+      }
+      case 'cpu': {
+        var cpus = os.cpus();
+        var load = os.loadavg();
+        result.status = load[0] > cpus.length * 0.8 ? 'warn' : 'ok';
+        result.value = (load[0] || 0).toFixed(2);
+        result.detail = {
+          cores: cpus.length,
+          load_1m: load[0],
+          load_5m: load[1],
+          load_15m: load[2]
+        };
+        break;
+      }
+      case 'disk': {
+        try {
+          var stat = require('fs').statfsSync(getDir());
+          var used_pct = Math.round((1 - stat.bfree / stat.blocks) * 100);
+          result.status = used_pct > 90 ? 'warn' : 'ok';
+          result.value = used_pct + '%';
+          result.detail = {
+            total_blocks: stat.blocks,
+            free_blocks: stat.bfree,
+            used_pct: used_pct
+          };
+        } catch (e) {
+          result.status = 'error';
+          result.value = '';
+          result.detail = { error: e.message };
+          all_healthy = false;
+        }
+        break;
+      }
+      case 'uptime': {
+        var uptime = process.uptime();
+        result.status = 'ok';
+        result.value = Math.floor(uptime) + 's';
+        result.detail = { uptime_seconds: uptime };
+        break;
+      }
+      case 'process': {
+        var mem = process.memoryUsage();
+        result.status = mem.heapUsed / mem.heapTotal > 0.9 ? 'warn' : 'ok';
+        result.value = Math.round(mem.heapUsed / 1024 / 1024) + 'MB';
+        result.detail = {
+          pid: process.pid,
+          heap_used: mem.heapUsed,
+          heap_total: mem.heapTotal,
+          rss: mem.rss
+        };
+        break;
+      }
+      default: {
+        result.status = 'unknown';
+        result.value = '';
+        break;
+      }
+    }
+
+    if (result.status !== 'ok') {
+      all_healthy = false;
+    }
+    results.push(result);
+  }
+
+  ctx.output.health = results;
+  ctx.output = { healthy: all_healthy, checks: results };
+  return ctx.output;
+}
+
+module.exports = { main };

package/lib/tools/index.js

@@ -0,0 +1,16 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+/** 模块能力层：懒加载工具实现，避免模块入口被 require 时加载全部实现 */
+module.exports = new Proxy({}, {
+  get(_t, key) {
+    if (typeof key !== 'string') return undefined;
+    if (!fs.existsSync(path.join(__dirname, key, 'index.js'))) return undefined;
+    return require('./' + key);
+  },
+  has(_t, key) {
+    return typeof key === 'string' && fs.existsSync(path.join(__dirname, key, 'index.js'));
+  },
+  ownKeys() { return fs.readdirSync(__dirname, { withFileTypes: true }).filter(e => e.isDirectory()).map(e => e.name); },
+  getOwnPropertyDescriptor(_t, key) { return this.has(_t, key) ? { enumerable: true, configurable: true } : undefined; }
+});

package/lib/tools/monitor/index.js

@@ -0,0 +1,299 @@
+const os = require('os');
+const fs = require('fs');
+const net = require('net');
+const child_process = require('child_process');
+const Http = require('mm_https');
+
+const ACTIONS = ['get_system', 'get_processes', 'check_port', 'check_service'];
+
+module.exports = {
+  /**
+   * 系统监控
+   * @param {object} params 监控参数
+   * @param {string} params.action 操作类型
+   * @param {number} params.top 进程数量
+   * @param {string} params.host 主机地址
+   * @param {number} params.port 端口号
+   * @param {number} params.timeout 超时时间(毫秒)
+   * @param {string} params.url 服务地址
+   * @returns {object} 监控结果
+   */
+  async monitor(params) {
+    let { action } = params;
+    if (!action) {
+      throw new TypeError('操作类型(action)不能为空');
+    }
+    if (ACTIONS.indexOf(action) === -1) {
+      throw new Error('不支持的操作类型: ' + action);
+    }
+    switch (action) {
+      case 'get_system':
+        return await this.getSystem();
+      case 'get_processes':
+        return await this.getProc(params.top);
+      case 'check_port':
+        return await this.checkPort(params.host, params.port, params.timeout);
+      case 'check_service':
+        return await this.checkService(params.url, params.timeout);
+    }
+  },
+
+  /**
+   * 获取系统信息
+   * @returns {object} 系统信息
+   */
+  async getSystem() {
+    return {
+      hostname: os.hostname(),
+      platform: os.platform(),
+      arch: os.arch(),
+      uptime: os.uptime(),
+      cpu: this.getCpu(),
+      memory: this.getMemory(),
+      disk: this.getDisk(),
+      network: this.getNetwork(),
+      loadavg: os.loadavg()
+    };
+  },
+
+  /**
+   * 获取CPU使用率
+   * @returns {object} CPU信息
+   */
+  getCpu() {
+    let cpus = os.cpus();
+    let total = 0;
+    let idle = 0;
+    for (let cpu of cpus) {
+      for (let type in cpu.times) {
+        total += cpu.times[type];
+      }
+      idle += cpu.times.idle;
+    }
+    let usage = total > 0 ? (1 - idle / total) * 100 : 0;
+    return {
+      cores: cpus.length,
+      model: cpus.length > 0 ? cpus[0].model : '',
+      usage_percent: parseFloat(usage.toFixed(1))
+    };
+  },
+
+  /**
+   * 获取内存使用情况
+   * @returns {object} 内存信息
+   */
+  getMemory() {
+    let total = os.totalmem();
+    let free = os.freemem();
+    return {
+      total: total,
+      free: free,
+      used: total - free,
+      usage_percent: total > 0 ? parseFloat(((1 - free / total) * 100).toFixed(1)) : 0
+    };
+  },
+
+  /**
+   * 获取磁盘使用情况
+   * @returns {Array} 磁盘信息列表
+   */
+  getDisk() {
+    let list = [];
+    try {
+      if (typeof fs.statfsSync === 'function') {
+        let stat = fs.statfsSync(process.cwd());
+        let total = stat.blocks * stat.bsize;
+        let free = stat.bavail * stat.bsize;
+        list.push({
+          path: process.cwd(),
+          total: total,
+          free: free,
+          usage_percent: total > 0 ? parseFloat(((1 - free / total) * 100).toFixed(1)) : 0
+        });
+      }
+    } catch (error) {
+      void error;
+      // 获取磁盘失败时返回空列表
+    }
+    return list;
+  },
+
+  /**
+   * 获取网络接口信息
+   * @returns {Array} 网络接口列表
+   */
+  getNetwork() {
+    let list = [];
+    let ifaces = os.networkInterfaces();
+    for (let key in ifaces) {
+      let addrs = ifaces[key];
+      for (let addr of addrs) {
+        if (addr.family === 'IPv4' && !addr.internal) {
+          list.push({ name: key, address: addr.address, mac: addr.mac });
+        }
+      }
+    }
+    return list;
+  },
+
+  /**
+   * 获取进程列表
+   * @param {number} top 进程数量
+   * @returns {object} 进程列表
+   */
+  async getProc(top) {
+    let limit = top || 20;
+    let is_win = process.platform === 'win32';
+    let cmd = is_win ? 'tasklist /FO CSV' : 'ps -eo pid,pcpu,pmem,comm --sort=-pcpu';
+    try {
+      let output = child_process.execSync(cmd, { encoding: 'utf-8', maxBuffer: 5242880 }); // eslint-disable-line mm_eslint/variable-name
+      let list = this.parseProc(output, is_win).slice(0, limit);
+      return { list: list, count: list.length };
+    } catch (error) {
+      void error;
+      return { list: [], count: 0 };
+    }
+  },
+
+  /**
+   * 解析进程输出
+   * @param {string} output 命令输出
+   * @param {boolean} is_win 是否Windows
+   * @returns {Array} 进程列表
+   */
+  parseProc(output, is_win) {
+    let list = [];
+    let lines = output.trim().split('\n');
+    for (let i = 1; i < lines.length; i++) {
+      let line = lines[i].trim();
+      if (!line) {
+        continue;
+      }
+      let item = is_win ? this.parseWinLine(line) : this.parseUnixLine(line);
+      if (item) {
+        list.push(item);
+      }
+    }
+    return list;
+  },
+
+  /**
+   * 解析Windows进程行
+   * @param {string} line 行内容
+   * @returns {object|null} 进程信息
+   */
+  parseWinLine(line) {
+    let cols = line.split('","');
+    if (cols.length < 3) {
+      return null;
+    }
+    let name = cols[0].replace(/"/g, '');
+    let pid = parseInt(cols[1], 10);
+    let mem = cols[cols.length - 1].replace(/"/g, '').replace(/[^\d]/g, '');
+    return {
+      pid: pid,
+      name: name,
+      memory_kb: parseInt(mem, 10) || 0
+    };
+  },
+
+  /**
+   * 解析Unix进程行
+   * @param {string} line 行内容
+   * @returns {object|null} 进程信息
+   */
+  parseUnixLine(line) {
+    let parts = line.trim().split(/\s+/);
+    if (parts.length < 4) {
+      return null;
+    }
+    return {
+      pid: parseInt(parts[0], 10),
+      cpu_percent: parseFloat(parts[1]),
+      mem_percent: parseFloat(parts[2]),
+      name: parts.slice(3).join(' ')
+    };
+  },
+
+  /**
+   * 检测端口是否开放
+   * @param {string} host 主机地址
+   * @param {number} port 端口号
+   * @param {number} timeout 超时时间
+   * @returns {object} 检测结果
+   */
+  checkPort(host, port, timeout) {
+    if (!host) {
+      throw new TypeError('主机(host)不能为空');
+    }
+    if (!port) {
+      throw new TypeError('端口(port)不能为空');
+    }
+    let timeout_ms = timeout || 3000;
+    return new Promise((resolve) => {
+      let socket = net.connect(port, host);
+      socket.setTimeout(timeout_ms);
+      socket.on('connect', () => {
+        socket.destroy();
+        resolve({ open: true, host: host, port: port });
+      });
+      socket.on('timeout', () => {
+        socket.destroy();
+        resolve({ open: false, host: host, port: port });
+      });
+      socket.on('error', () => {
+        resolve({ open: false, host: host, port: port });
+      });
+    });
+  },
+
+  /**
+   * 检测HTTP服务连通性
+   * @param {string} url 服务地址
+   * @param {number} timeout 超时时间
+   * @returns {object} 检测结果
+   */
+  async checkService(url, timeout) {
+    if (!url) {
+      throw new TypeError('服务地址(url)不能为空');
+    }
+    try {
+      let http = new Http({ rejectUnauthorized: false }); // eslint-disable-line mm_eslint/variable-name
+      let start = Date.now();
+      let res = await http.get(url);
+      let cost = Date.now() - start;
+      let status = typeof res.status === 'number' ? res.status : (res.status && res.status.code);
+      return {
+        ok: status >= 200 && status < 500,
+        url: url,
+        status: status || 0,
+        ms: cost
+      };
+    } catch (error) {
+      return { ok: false, url: url, status: 0, ms: 0, msg: error.message };
+    }
+  },
+
+  /**
+   * 主函数
+   * @param {object} params 参数
+   * @returns {object} 执行结果
+   */
+  async main(params, ctx, options) {
+    try {
+      let result = await this.monitor(params);
+      return { code: 0, msg: '操作成功', data: result };
+    } catch (error) {
+      return {
+        code: 10000,
+        msg: '系统监控失败！原因：' + error.message,
+        data: null,
+        error: {
+          name: error.name,
+          message: error.message,
+          stack: error.stack
+        }
+      };
+    }
+  }
+};

package/package.json

@@ -1,33 +1,40 @@
-{
-    "name": "mm_monitor",
-    "version": "1.0.6",
-    "description": "超级美眉监听器，用于监听网站运行是否异常并给运维人员发短信、邮箱通知",
-    "main": "index.js",
-    "scripts": {
-        "test": "node test.js"
-    },
-    "repository": {
-        "type": "git",
-        "url": "git+https://gitee.com/qiuwenwu91/mm_monitor.git"
-    },
-    "keywords": [
-        "mvc",
-        "web",
-        "view",
-        "model",
-        "controller",
-        "render",
-        "template"
-    ],
-    "author": "邱文武",
-    "license": "ISC",
-    "bugs": {
-        "url": "https://gitee.com/qiuwenwu91/mm_monitor/issues"
-    },
-    "homepage": "https://gitee.com/qiuwenwu91/mm_monitor#readme",
-    "dependencies": {
-        "mm_email": "^1.0.8",
-        "mm_https": "^1.6.7",
-        "mm_phone": "^1.0.2"
-    }
-}
+{
+    "name": "mm_monitor",
+    "version": "1.2.0",
+    "description": "超级美眉监听器，用于监听网站运行是否异常并给运维人员发短信、邮箱通知",
+    "main": "index.js",
+    "scripts": {
+        "test": "node test.js"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://gitee.com/qiuwenwu91/mm_monitor.git"
+    },
+    "keywords": [
+        "mm_mod",
+        "mm_crosscut",
+        "mm_alerting",
+        "mvc",
+        "web",
+        "view",
+        "model",
+        "controller",
+        "render",
+        "template"
+    ],
+    "layer": "infrastructure",
+    "group": "observability",
+    "author": "邱文武",
+    "license": "ISC",
+    "bugs": {
+        "url": "https://gitee.com/qiuwenwu91/mm_monitor/issues"
+    },
+    "homepage": "https://gitee.com/qiuwenwu91/mm_monitor#readme",
+    "dependencies": {
+        "mm_admin": "^1.1.0",
+        "mm_email": "^1.1.0",
+        "mm_helper": "^1.0.3",
+        "mm_https": "^1.7.1",
+        "mm_phone": "^1.0.2"
+    }
+}

package/test.js

@@ -1,13 +1,32 @@
-const Monitor = require('./index.js');
-
-/**
- * 测试html转为json
- * @param {String} file html文件
- */
-async function test() {
-	var config = "./config.json".loadJson();
-	var m = new Monitor(config);
-	m.run();
-}
-
-test();
+'use strict';
+const assert = require('assert');
+const mod = require('./index.js');
+
+/**
+ * 运行 mm_monitor 模块测试
+ * 仅验证导出结构与实例化，不调用 run() 以避免真实联网与发送通知
+ * @returns {Promise<void>}
+ */
+async function runTest() {
+  // 验证导出结构
+  assert.strictEqual(typeof mod.Monitor, 'function', '应导出 Monitor');
+  assert.ok(mod.admin, '应导出 admin');
+  assert.strictEqual(typeof mod.monitorAdmin, 'function', '应导出 monitorAdmin 函数');
+
+  // 实例化 Monitor（不调用 run，避免真实请求）
+  const monitor = new mod.Monitor({ listen: [], interval: 60 });
+  assert.ok(monitor instanceof mod.Monitor, 'Monitor 应可实例化');
+  assert.ok(monitor.config, '实例应包含 config');
+  assert.ok(Array.isArray(monitor.config.listen), 'config 应包含 listen 数组');
+
+  // 验证 admin 工厂获取实例
+  const inst = mod.monitorAdmin('test_scope', { listen: [] });
+  assert.ok(inst instanceof mod.Monitor, 'monitorAdmin 返回的实例应为 Monitor 类型');
+}
+
+runTest().then(() => {
+  console.log('mm_monitor 模块测试通过');
+}).catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/tool/health/index.js

@@ -0,0 +1,7 @@
+'use strict';
+/**
+ * health —— 工具契约适配层
+ * 业务实现归位于模块 lib/tools/health/，本文件只把模块能力暴露给加载器。
+ * 其它模块可直接 require('mm_monitor').tools.health 复用。
+ */
+module.exports = require('../../lib/tools/health');

package/tool/health/tool.json

@@ -0,0 +1,46 @@
+{
+  "name": "health",
+  "handler": "observer",
+  "title": "健康检查观察器",
+  "description": "检查系统各组件的健康状态（内存/CPU/磁盘等）。适用场景：系统体检、运维监控或启动前置检查时。工作流提示：checks 指定待检查组件列表（默认 memory/cpu/disk），返回 healthy 判断整体是否健康、checks 为各组件检查结果。",
+  "type": "data",
+  "params": {
+    "type": "object",
+    "properties": {
+      "checks": {
+        "type": "array",
+        "description": "待检查组件列表，默认 ['memory', 'cpu', 'disk']"
+      }
+    }
+  },
+  "returns": {
+    "type": "object",
+    "description": "健康检查结果",
+    "properties": {
+      "healthy": {
+        "type": "boolean",
+        "description": "系统是否健康"
+      },
+      "checks": {
+        "type": "array",
+        "description": "检查结果列表"
+      },
+      "error": {
+        "type": "object",
+        "description": "错误信息，仅调用出错时返回",
+        "properties": {
+          "code": {
+            "type": "string",
+            "description": "错误码"
+          },
+          "message": {
+            "type": "string",
+            "description": "错误描述"
+          }
+        }
+      }
+    }
+  },
+  "options": {},
+  "group": "monitor"
+}

package/tool/monitor/index.js

@@ -0,0 +1,7 @@
+'use strict';
+/**
+ * monitor —— 工具契约适配层
+ * 业务实现归位于模块 lib/tools/monitor/，本文件只把模块能力暴露给加载器。
+ * 其它模块可直接 require('mm_monitor').tools.monitor 复用。
+ */
+module.exports = require('../../lib/tools/monitor');

package/tool/monitor/tool.json

@@ -0,0 +1,73 @@
+{
+  "name": "monitor",
+  "title": "系统监控",
+  "description": "监控系统CPU、内存、磁盘、网络、进程，检测端口开放和服务连通性。触发关键词：系统监控、CPU使用率、内存使用、磁盘空间、进程列表、端口检测、服务检测",
+  "category": "系统工具",
+  "group": "system",
+  "type": "function",
+  "main": "./index.js",
+  "params": {
+    "type": "object",
+    "properties": {
+      "action": {
+        "type": "string",
+        "description": "操作类型：get_system(系统信息)/get_processes(进程列表)/check_port(端口检测)/check_service(服务检测)",
+        "enum": [
+          "get_system",
+          "get_processes",
+          "check_port",
+          "check_service"
+        ]
+      },
+      "top": {
+        "type": "integer",
+        "description": "进程数量（action=get_processes时有效，默认20）",
+        "default": 20
+      },
+      "host": {
+        "type": "string",
+        "description": "主机地址（action=check_port时必填）"
+      },
+      "port": {
+        "type": "integer",
+        "description": "端口号（action=check_port时必填）"
+      },
+      "url": {
+        "type": "string",
+        "description": "服务地址（action=check_service时必填）"
+      },
+      "timeout": {
+        "type": "integer",
+        "description": "超时时间（毫秒，默认3000）",
+        "default": 3000
+      }
+    },
+    "required": [
+      "action"
+    ]
+  },
+  "returns": {
+    "type": "object",
+    "properties": {
+      "code": {
+        "type": "number",
+        "description": "返回代码，0表示成功",
+        "default": 0
+      },
+      "msg": {
+        "type": "string",
+        "description": "返回消息",
+        "default": ""
+      },
+      "data": {
+        "type": "object",
+        "description": "监控结果数据"
+      }
+    },
+    "required": [
+      "code",
+      "msg"
+    ]
+  },
+  "handler": "manager"
+}