@wanghaopeng1148/deskpet 2.0.0 → 2.0.2

package/dist/node/server/plugins/actions/python-script.js

@@ -0,0 +1,180 @@
+/**
+ * python_script 动作 — 执行 Python 脚本
+ *
+ * 1) 脚本来源：优先「任务内导入」的脚本（actionParams.scriptContent，运行时写入临时文件）；
+ *    兼容旧任务：无导入内容时回退 config.scriptPath 指向的本地脚本。
+ * 2) 配置注入：把「系统设置」里的 Jenkins / Linux 服务器配置写入临时 JSON，
+ *    并通过环境变量传给脚本，脚本无需再硬编码地址与密码：
+ *      DESKPET_CONFIG       注入配置文件的绝对路径（JSON）
+ *      DESKPET_LOG_DIR      脚本日志目录（~/.deskpet/logs）
+ *      DESKPET_JENKINS_URL / _USER / _PASS
+ *      DESKPET_SERVER_HOST / _PORT / _USER / _PASS / _NAME（任务选了服务器时才有）
+ *      DESKPET_TASK_ID / DESKPET_TASK_NAME / DESKPET_PARAMS（actionParams JSON）
+ *    执行结束（含失败）会清理所有临时文件。
+ */
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { getDataRoot } from "../../utils/paths.js";
+import { resolvePythonInterpreter } from "../../utils/python-interpreter.js";
+const TEMP_DIR_NAME = 'deskpet-scripts';
+export const pythonScriptAction = async (task, ctx) => {
+    const c = task.config;
+    const params = c.actionParams ?? {};
+    const scriptContent = typeof params['scriptContent'] === 'string' ? params['scriptContent'] : '';
+    const scriptName = typeof params['scriptName'] === 'string' && params['scriptName'] ? params['scriptName'] : 'script.py';
+    const settings = ctx.config.get();
+    const servers = (settings.servers ?? []);
+    const selected = servers.find((s) => s.id === String(params['serverId'] ?? '')) ?? null;
+    const dir = join(tmpdir(), TEMP_DIR_NAME);
+    const tempFiles = [];
+    const stamp = Date.now();
+    try {
+        mkdirSync(dir, { recursive: true });
+    }
+    catch (err) {
+        return { success: false, error: `创建临时目录失败: ${String(err)}` };
+    }
+    // ── 注入配置（Jenkins / 服务器），供脚本读取 ─────────────
+    let configPath = '';
+    try {
+        const injected = {
+            jenkins: settings.jenkins ?? { url: '', username: '', password: '' },
+            servers,
+            server: selected,
+            task: { id: task.id, name: c.name, args: c.scriptArgs ?? [] },
+            params
+        };
+        configPath = join(dir, `${task.id}-${stamp}.config.json`);
+        writeFileSync(configPath, JSON.stringify(injected, null, 2), 'utf-8');
+        tempFiles.push(configPath);
+    }
+    catch (err) {
+        return { success: false, error: `写入注入配置失败: ${String(err)}` };
+    }
+    // ── 脚本来源 ────────────────────────────────────────────
+    let scriptPath = c.scriptPath || String(params['script_path'] ?? '');
+    if (scriptContent.trim()) {
+        try {
+            const p = join(dir, `${task.id}-${stamp}.py`);
+            writeFileSync(p, scriptContent, 'utf-8');
+            scriptPath = p;
+            tempFiles.push(p);
+        }
+        catch (err) {
+            cleanup(tempFiles);
+            return { success: false, error: `写入临时脚本失败: ${String(err)}` };
+        }
+    }
+    if (!scriptPath) {
+        cleanup(tempFiles);
+        return { success: false, error: '任务未导入 Python 脚本，请编辑任务上传 .py 文件' };
+    }
+    // 脚本日志目录（持久化，便于排查）
+    const logDir = join(getDataRoot(), 'logs');
+    try {
+        mkdirSync(logDir, { recursive: true });
+    }
+    catch {
+        /* 建目录失败时交给脚本自行回退 */
+    }
+    const env = {
+        // Windows 下 Python 默认用 GBK 输出，会导致中文日志乱码 → 强制 UTF-8
+        PYTHONIOENCODING: 'utf-8',
+        PYTHONUTF8: '1',
+        // 关键：关闭 Python 的输出缓冲。否则 stdout 为管道时是「块缓冲」，
+        // print() 的内容要等缓冲区满或进程结束才会到达父进程 —— 管理台就看不到实时日志。
+        // 等价于 python -u；配合 script-runner 的 onOutput 即可边跑边看。
+        PYTHONUNBUFFERED: '1',
+        DESKPET_CONFIG: configPath,
+        DESKPET_LOG_DIR: logDir,
+        DESKPET_JENKINS_URL: settings.jenkins?.url ?? '',
+        DESKPET_JENKINS_USER: settings.jenkins?.username ?? '',
+        DESKPET_JENKINS_PASS: settings.jenkins?.password ?? '',
+        DESKPET_TASK_ID: task.id,
+        DESKPET_TASK_NAME: c.name ?? '',
+        DESKPET_PARAMS: JSON.stringify(params)
+    };
+    if (selected) {
+        env['DESKPET_SERVER_NAME'] = selected.name ?? '';
+        env['DESKPET_SERVER_HOST'] = selected.host ?? '';
+        env['DESKPET_SERVER_PORT'] = String(selected.port ?? 22);
+        env['DESKPET_SERVER_USER'] = selected.username ?? '';
+        env['DESKPET_SERVER_PASS'] = selected.password ?? '';
+    }
+    ctx.log(`开始执行脚本: ${scriptName}`);
+    // ── 解释器解析 ──────────────────────────────────────────
+    // Windows 上 `python3` 往往是 Microsoft Store 的别名存根，非交互执行直接返回 9009，
+    // 这里统一解析成真实可执行文件的绝对路径（跳过存根），避免「exit_code=9009、无任何输出」。
+    const resolution = resolvePythonInterpreter(c.interpreter);
+    if (!resolution.ok) {
+        cleanup(tempFiles);
+        return { success: false, error: resolution.error };
+    }
+    ctx.log(`解释器: ${resolution.interpreter.command}`);
+    try {
+        const handle = ctx.scriptRunner.start({
+            scriptPath,
+            interpreter: resolution.interpreter.command,
+            args: c.scriptArgs,
+            timeout: c.scriptTimeout,
+            workDir: c.scriptWorkDir,
+            env,
+            // 实时把子进程输出推给管理台（调度器注入的回调）
+            onOutput: (stream, text) => ctx.onOutput?.(stream, text)
+        });
+        // 注册句柄供任务停止
+        try {
+            ctx.trackRunningScript?.(task.id, handle);
+        }
+        catch {
+            /* 调度器未注入时忽略 */
+        }
+        // 登记子进程 pid：服务中途被强杀时，靠它判断脚本是否还在后台跑
+        if (handle.pid) {
+            try {
+                ctx.onChildPid?.(handle.pid);
+            }
+            catch {
+                /* 调度器未注入时忽略 */
+            }
+        }
+        const result = await handle.result;
+        try {
+            ctx.trackRunningScript?.(task.id, null);
+        }
+        catch {
+            /* ignore */
+        }
+        if (result.timedOut) {
+            ctx.log(`执行超时 (${c.scriptTimeout}s)`);
+        }
+        else if (result.success) {
+            ctx.log(`执行成功, 退出码 ${result.exitCode}, 耗时 ${(result.elapsedMs / 1000).toFixed(1)}s`);
+        }
+        else {
+            ctx.log(`执行失败: ${result.errorMessage}`);
+        }
+        return {
+            success: result.success,
+            exitCode: result.exitCode,
+            stdout: result.stdout,
+            stderr: result.stderr,
+            error: result.errorMessage || undefined,
+            timedOut: result.timedOut
+        };
+    }
+    finally {
+        cleanup(tempFiles);
+    }
+};
+function cleanup(files) {
+    for (const f of files) {
+        try {
+            rmSync(f, { force: true });
+        }
+        catch {
+            /* 清理失败可忽略 */
+        }
+    }
+}

package/dist/node/server/plugins/actions/screenshot.js

@@ -0,0 +1,38 @@
+/**
+ * 截图动作 — macOS screencapture（全屏截图保存到指定目录）
+ */
+import { execFile } from 'node:child_process';
+import { mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export const screenshotAction = async (task) => {
+    const p = task.config.actionParams ?? {};
+    if (process.platform !== 'darwin') {
+        return { success: false, error: `截图动作暂不支持 ${process.platform}` };
+    }
+    // 目标路径：参数指定目录或默认 ~/Downloads
+    const dir = (typeof p['dir'] === 'string' && p['dir']) || join(homedir(), 'Downloads');
+    try {
+        mkdirSync(dir, { recursive: true });
+    }
+    catch {
+        /* 已存在 */
+    }
+    const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const filePath = (typeof p['file'] === 'string' && p['file']) || join(dir, `deskpet-screenshot-${ts}.png`);
+    return new Promise((resolve) => {
+        // -x 不播放快门声；-m 只截主屏（可选）
+        const args = ['-x'];
+        if (p['mainDisplayOnly'] === true)
+            args.push('-m');
+        args.push(filePath);
+        execFile('screencapture', args, { timeout: 15_000 }, (err) => {
+            if (err) {
+                resolve({ success: false, error: String(err) });
+            }
+            else {
+                resolve({ success: true, stdout: filePath });
+            }
+        });
+    });
+};

package/dist/node/server/plugins/actions/send-keystroke.js

@@ -0,0 +1,100 @@
+/**
+ * 按键序列动作 — macOS osascript System Events（模拟快捷键）
+ *
+ * 参数: keys: "cmd+shift+4" / "ctrl+c" / "return" / "cmd+alt+esc"
+ */
+import { execFile } from 'node:child_process';
+const MODIFIER_MAP = {
+    cmd: 'command down',
+    command: 'command down',
+    ctrl: 'control down',
+    control: 'control down',
+    alt: 'option down',
+    option: 'option down',
+    shift: 'shift down',
+    fn: 'fn down'
+};
+/** 组合键 → osascript keystroke 脚本；非法返回 null */
+export function buildKeystrokeScript(combo) {
+    const parts = combo
+        .split(/[+-]/)
+        .map((s) => s.trim().toLowerCase())
+        .filter(Boolean);
+    if (!parts.length)
+        return null;
+    const modifiers = [];
+    let key = '';
+    for (const part of parts) {
+        if (MODIFIER_MAP[part]) {
+            modifiers.push(MODIFIER_MAP[part]);
+        }
+        else {
+            key = part;
+        }
+    }
+    if (!key)
+        return null;
+    // 特殊键映射
+    const special = {
+        return: 'return',
+        enter: 'return',
+        tab: 'tab',
+        space: 'space',
+        delete: 'delete',
+        escape: 'escape',
+        esc: 'escape',
+        up: 'up arrow',
+        down: 'down arrow',
+        left: 'left arrow',
+        right: 'right arrow',
+        home: 'home',
+        end: 'end',
+        pageup: 'page up',
+        pagedown: 'page down'
+    };
+    if (special[key]) {
+        const using = modifiers.length ? ` using {${modifiers.join(', ')}}` : '';
+        return `tell application "System Events" to key code ${KEY_CODES[special[key]] ?? `"${special[key]}"`}${using}`;
+    }
+    if (key.length !== 1)
+        return null;
+    const using = modifiers.length ? ` using {${modifiers.join(', ')}}` : '';
+    return `tell application "System Events" to keystroke "${key}"${using}`;
+}
+// System Events 特殊键的 key code（部分键只能用 key code 表达）
+const KEY_CODES = {
+    return: 36,
+    tab: 48,
+    space: 49,
+    delete: 51,
+    escape: 53,
+    home: 115,
+    end: 119,
+    pageup: 116,
+    'page down': 121,
+    'up arrow': 126,
+    'down arrow': 125,
+    'left arrow': 123,
+    'right arrow': 124
+};
+export const sendKeystrokeAction = async (task) => {
+    if (process.platform !== 'darwin') {
+        return { success: false, error: `按键模拟暂不支持 ${process.platform}` };
+    }
+    const combo = String(task.config.actionParams?.['keys'] ?? '').trim();
+    if (!combo) {
+        return { success: false, error: '未指定按键序列（actionParams.keys，如 cmd+q）' };
+    }
+    const script = buildKeystrokeScript(combo);
+    if (!script) {
+        return { success: false, error: `无法解析按键组合: ${combo}` };
+    }
+    return new Promise((resolve) => {
+        execFile('osascript', ['-e', script], { timeout: 10_000 }, (err, stdout) => {
+            if (err)
+                resolve({ success: false, error: String(err) });
+            else
+                resolve({ success: true, stdout: `已发送按键: ${combo}\n${stdout.trim()}` });
+        });
+    });
+};

package/dist/node/server/plugins/actions/show-reminder.js

@@ -0,0 +1,7 @@
+export const showReminderAction = async (task, ctx) => {
+    const p = task.config.actionParams;
+    const text = String(p.text ?? task.config.name ?? '提醒');
+    ctx.notifier.showReminder({ text });
+    ctx.log(`提醒触发: ${text}`);
+    return { success: true };
+};

package/dist/node/server/plugins/actions/ssh-command.js

@@ -0,0 +1,123 @@
+/**
+ * ssh_command — 在「系统设置 → Linux 服务器」选中的服务器上远程执行 Shell 命令
+ *
+ * 参数（task.actionParams）:
+ *   serverId   设置里 Linux 服务器的 id
+ *   command    要执行的 Shell 命令（支持多行，会整体交给远端 shell）
+ *   timeoutMs  超时毫秒数（可选，默认 120s）
+ */
+import { Client } from 'ssh2';
+const DEFAULT_TIMEOUT_MS = 120_000;
+/** 通过 SSH 在远端执行一条命令，返回退出码与输出 */
+function execRemote(server, command, timeoutMs, onOutput) {
+    return new Promise((resolve) => {
+        let stdout = '';
+        let stderr = '';
+        let done = false;
+        const conn = new Client();
+        const finish = (r) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            try {
+                conn.end();
+            }
+            catch {
+                /* 连接已断开时忽略 */
+            }
+            resolve(r);
+        };
+        const timer = setTimeout(() => {
+            finish({
+                code: null,
+                stdout,
+                stderr,
+                error: `执行超时（超过 ${Math.round(timeoutMs / 1000)} 秒）`
+            });
+        }, timeoutMs);
+        conn
+            .on('ready', () => {
+            conn.exec(command, (err, stream) => {
+                if (err) {
+                    finish({ code: null, stdout, stderr, error: `执行命令失败: ${err.message}` });
+                    return;
+                }
+                stream
+                    .on('close', (code) => {
+                    finish({ code, stdout, stderr });
+                })
+                    .on('data', (chunk) => {
+                    const text = chunk.toString();
+                    stdout += text;
+                    try {
+                        onOutput?.('stdout', text);
+                    }
+                    catch {
+                        /* 回调异常不影响执行 */
+                    }
+                });
+                stream.stderr.on('data', (chunk) => {
+                    const text = chunk.toString();
+                    stderr += text;
+                    try {
+                        onOutput?.('stderr', text);
+                    }
+                    catch {
+                        /* 回调异常不影响执行 */
+                    }
+                });
+            });
+        })
+            .on('error', (err) => {
+            finish({
+                code: null,
+                stdout,
+                stderr,
+                error: `SSH 连接失败: ${err.message}（请检查 IP/端口/用户名/密码）`
+            });
+        })
+            .connect({
+            host: server.host,
+            port: server.port || 22,
+            username: server.username,
+            password: server.password,
+            readyTimeout: Math.min(timeoutMs, 30_000)
+        });
+    });
+}
+export const sshCommandAction = async (task, ctx) => {
+    const p = task.config.actionParams ?? {};
+    const serverId = String(p['serverId'] ?? '');
+    const command = String(p['command'] ?? '').trim();
+    if (!command) {
+        return { success: false, error: '未填写要执行的命令' };
+    }
+    const servers = (ctx.config.get().servers ?? []);
+    const server = servers.find((s) => s.id === serverId);
+    if (!server) {
+        return {
+            success: false,
+            error: `未找到服务器配置（serverId=${serverId || '空'}）。请先在「系统设置 → Linux 服务器」中添加服务器并在本任务里选择它。`
+        };
+    }
+    if (!server.host || !server.username) {
+        return { success: false, error: `服务器「${server.name || serverId}」配置不完整（缺少 IP 或用户名）` };
+    }
+    const parsedTimeout = Number(p['timeoutMs']);
+    const timeoutMs = Number.isFinite(parsedTimeout) && parsedTimeout > 0 ? parsedTimeout : DEFAULT_TIMEOUT_MS;
+    ctx.log(`SSH ${server.username}@${server.host}:${server.port || 22}`);
+    const r = await execRemote(server, command, timeoutMs, (stream, text) => ctx.onOutput?.(stream, text));
+    if (r.error) {
+        return { success: false, error: r.error, stdout: r.stdout, stderr: r.stderr };
+    }
+    const ok = r.code === 0;
+    ctx.log(`退出码 ${r.code ?? '未知'}`);
+    return {
+        success: ok,
+        exitCode: r.code,
+        stdout: r.stdout,
+        stderr: r.stderr,
+        error: ok ? undefined : `命令退出码 ${r.code}`
+    };
+};

package/dist/node/server/plugins/actions/task-chain.js

@@ -0,0 +1,24 @@
+export const taskChainAction = async (task, ctx) => {
+    const raw = task.config.actionParams?.['taskIds'];
+    let ids = [];
+    if (Array.isArray(raw))
+        ids = raw.map(String);
+    else if (typeof raw === 'string' && raw.trim()) {
+        ids = raw.split(/[,，\s]+/).filter(Boolean);
+    }
+    if (!ids.length || !ctx.requestRun) {
+        return { success: false, error: '未配置要触发的任务（taskIds）' };
+    }
+    const results = [];
+    for (const id of ids) {
+        const ok = ctx.requestRun(id, 'chain');
+        results.push(`${ok ? '✅' : '❌'} ${id}`);
+    }
+    const failed = results.filter((r) => r.startsWith('❌')).length;
+    return {
+        success: failed === 0,
+        stdout: `已触发 ${results.length - failed}/${results.length} 个任务`,
+        stderr: failed > 0 ? results.filter((r) => r.startsWith('❌')).join('\n') : undefined,
+        error: failed > 0 ? `${failed} 个任务触发失败` : undefined
+    };
+};

package/dist/node/server/plugins/actions/volume-control.js

@@ -0,0 +1,31 @@
+/**
+ * 音量控制动作 — macOS osascript（调节音量/静音切换）
+ */
+import { execFile } from 'node:child_process';
+function runOsa(script) {
+    return new Promise((resolve) => {
+        execFile('osascript', ['-e', script], { timeout: 10_000 }, (err, stdout) => {
+            if (err)
+                resolve({ success: false, error: String(err) });
+            else
+                resolve({ success: true, stdout: stdout.trim() });
+        });
+    });
+}
+export const volumeControlAction = async (task) => {
+    if (process.platform !== 'darwin') {
+        return { success: false, error: `音量控制暂不支持 ${process.platform}` };
+    }
+    const p = task.config.actionParams ?? {};
+    // 静音切换优先
+    if (typeof p['mute'] === 'boolean') {
+        return runOsa(p['mute'] ? 'set volume with mute' : 'set volume without mute');
+    }
+    const vol = Number(p['volume']);
+    if (!Number.isFinite(vol)) {
+        // 未指定参数 → 返回当前音量
+        return runOsa('output volume of (get volume settings)');
+    }
+    const clamped = Math.max(0, Math.min(100, Math.round(vol)));
+    return runOsa(`set volume output volume ${clamped}`);
+};

package/dist/node/server/plugins/index.js

@@ -0,0 +1,35 @@
+/**
+ * 注册全部内置动作
+ */
+import { clearClipboardAction, lockScreenAction, openTrashAction, refreshDesktopAction } from "./actions/builtin.js";
+import { clipboardWatchAction } from "./actions/clipboard-watch.js";
+import { httpRequestAction } from "./actions/http-request.js";
+import { jenkinsBuildAction } from "./actions/jenkins-build.js";
+import { openAppAction } from "./actions/open-app.js";
+import { pythonScriptAction } from "./actions/python-script.js";
+import { screenshotAction } from "./actions/screenshot.js";
+import { sendKeystrokeAction } from "./actions/send-keystroke.js";
+import { showReminderAction } from "./actions/show-reminder.js";
+import { sshCommandAction } from "./actions/ssh-command.js";
+import { taskChainAction } from "./actions/task-chain.js";
+import { volumeControlAction } from "./actions/volume-control.js";
+/** 全部内置动作注册 */
+export function registerBuiltinActions(registry) {
+    registry.register('python_script', pythonScriptAction);
+    registry.register('show_reminder', showReminderAction);
+    registry.register('open_app', openAppAction);
+    registry.register('http_request', httpRequestAction);
+    // 远程执行：Linux 服务器（SSH）/ Jenkins
+    registry.register('ssh_command', sshCommandAction);
+    registry.register('jenkins_build', jenkinsBuildAction);
+    registry.register('lock_screen', lockScreenAction);
+    registry.register('open_recycle_bin', openTrashAction);
+    registry.register('refresh_desktop', refreshDesktopAction);
+    registry.register('clear_clipboard', clearClipboardAction);
+    // M5 新增动作
+    registry.register('volume_control', volumeControlAction);
+    registry.register('screenshot', screenshotAction);
+    registry.register('send_keystroke', sendKeystrokeAction);
+    registry.register('task_chain', taskChainAction);
+    registry.register('clipboard_watch', clipboardWatchAction);
+}

package/dist/node/server/plugins/registry.js

@@ -0,0 +1,23 @@
+export class ActionRegistry {
+    actions = new Map();
+    register(name, executor) {
+        this.actions.set(name, executor);
+    }
+    get(name) {
+        return this.actions.get(name) ?? null;
+    }
+    has(name) {
+        return this.actions.has(name);
+    }
+    list() {
+        return [...this.actions.keys()];
+    }
+    /** 执行动作；未注册的动作返回失败 */
+    async execute(task, ctx) {
+        const executor = this.actions.get(task.config.action);
+        if (!executor) {
+            return { success: false, error: `未知任务动作: ${task.config.action}` };
+        }
+        return executor(task, ctx);
+    }
+}

package/dist/node/server/services/clipboard-watcher.js

@@ -0,0 +1,112 @@
+/**
+ * 剪贴板监听 — 捕获到指定格式内容后触发任务（方案 §3.3.E: clipboard_watch）
+ *
+ * 语义：任务执行「剪贴板监听」动作 = 武装一个一次性监视器；
+ * 轮询系统剪贴板，文本命中正则后以匹配值为参数触发目标任务并自动解除。
+ */
+import { EventEmitter } from 'node:events';
+import { readClipboardText } from "../utils/clipboard.js";
+export class ClipboardWatchRegistry extends EventEmitter {
+    timer = null;
+    lastValue = '';
+    rules = [];
+    readClipboard;
+    /** 读取中标记：剪贴板读取为异步命令，避免轮询重叠 */
+    busy = false;
+    constructor(readClipboard = async () => readClipboardText()) {
+        super();
+        this.readClipboard = readClipboard;
+    }
+    get armedCount() {
+        return this.rules.length;
+    }
+    /** 武装一条监听规则（重复 pattern+target 会去重） */
+    arm(rule) {
+        try {
+            new RegExp(rule.pattern); // 校验合法性
+        }
+        catch (err) {
+            throw new Error(`无效的正则表达式: ${rule.pattern} (${String(err)})`);
+        }
+        if (!this.rules.some((r) => r.pattern === rule.pattern && r.targetTaskId === rule.targetTaskId)) {
+            this.rules.push(rule);
+        }
+        this.start();
+        this.emit('armed', rule);
+    }
+    disarm(pattern, targetTaskId) {
+        const before = this.rules.length;
+        this.rules =
+            pattern || targetTaskId
+                ? this.rules.filter((r) => !((!pattern || r.pattern === pattern) && (!targetTaskId || r.targetTaskId === targetTaskId)))
+                : [];
+        if (!this.rules.length)
+            this.stop();
+        return before - this.rules.length;
+    }
+    list() {
+        return [...this.rules];
+    }
+    start() {
+        if (this.timer)
+            return;
+        void this.read().then((v) => {
+            this.lastValue = v;
+        });
+        this.timer = setInterval(() => {
+            void this.tick();
+        }, 1500);
+        this.timer.unref?.();
+    }
+    async read() {
+        try {
+            return await this.readClipboard();
+        }
+        catch {
+            return '';
+        }
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+    }
+    shutdown() {
+        this.rules = [];
+        this.stop();
+    }
+    async tick() {
+        if (this.busy)
+            return;
+        this.busy = true;
+        try {
+            await this.doTick();
+        }
+        finally {
+            this.busy = false;
+        }
+    }
+    async doTick() {
+        const value = await this.read();
+        if (!value || value === this.lastValue)
+            return;
+        this.lastValue = value;
+        for (const rule of [...this.rules]) {
+            let matched = null;
+            try {
+                const m = new RegExp(rule.pattern).exec(value);
+                matched = m ? (m[0] ?? null) : null;
+            }
+            catch {
+                continue;
+            }
+            if (matched) {
+                // 先解除再触发，避免目标任务再次武装造成循环
+                this.rules = this.rules.filter((r) => r !== rule);
+                this.emit('match', { rule, value: matched });
+            }
+        }
+        if (!this.rules.length)
+            this.stop();
+    }
+}