@wanghaopeng1148/deskpet 2.0.1 → 2.0.2

package/dist/node/server/main.js

@@ -0,0 +1,291 @@
+/**
+ * DeskPet 服务入口 — 纯 Node 常驻进程（无 Electron）
+ *
+ * 职责: 任务系统（SQLite + 动作插件 + 调度器）、微信 Bot、扫码枪、
+ *       配置快照、管理台 HTTP/WebSocket 服务。前端用浏览器访问即可。
+ *
+ * 启动: npm start（内部 node --experimental-strip-types server/main.ts）
+ */
+import "./suppress-warnings.js";
+import { join } from 'node:path';
+import { dashboardUrl } from "./utils/dashboard-url.js";
+import { openDatabase } from "./db/database.js";
+import { migrateLegacyTasksFile } from "./db/migrate-legacy.js";
+import { TaskRepository } from "./db/task-repository.js";
+import { registerBuiltinActions } from "./plugins/index.js";
+import { ActionRegistry } from "./plugins/registry.js";
+import { createApp } from "./http/http-server.js";
+import { WsHub } from "./http/ws-hub.js";
+import { ClipboardWatchRegistry } from "./services/clipboard-watcher.js";
+import { ConfigStore } from "./services/config-store.js";
+import { IdleMonitor, NetworkMonitor } from "./services/idle-monitor.js";
+import { Notifier } from "./services/notifier.js";
+import { QuickActionsStore } from "./services/quick-actions-store.js";
+import { ScannerReader } from "./services/scanner-reader.js";
+import { ScriptRunner } from "./services/script-runner.js";
+import { SnapshotService } from "./services/snapshot-service.js";
+import { TaskScheduler } from "./services/task-scheduler.js";
+import { WechatBot } from "./services/wechat-bot.js";
+import { WechatCommandRouter } from "./services/wechat-commands.js";
+import { setAutoStart } from "./utils/auto-start.js";
+import { acquireInstanceLock, startHeartbeat } from "./utils/instance-guard.js";
+import { getDataRoot, getConfigDir } from "./utils/paths.js";
+async function main() {
+    // ── 基础服务 ──────────────────────────────────────────
+    const config = new ConfigStore();
+    // ── 任务系统（SQLite + 动作插件 + 调度器） ─────────────
+    const db = openDatabase();
+    const repo = new TaskRepository(db);
+    // 启动时清理历史：每个任务只保留最近 N 条执行记录（默认 10）
+    try {
+        const pruned = repo.pruneExecutionsToLimit();
+        if (pruned > 0)
+            console.log(`[deskpet] 已清理 ${pruned} 条过期执行记录`);
+    }
+    catch (err) {
+        console.warn(`[deskpet] 清理执行记录失败: ${String(err)}`);
+    }
+    const scriptRunner = new ScriptRunner();
+    const notifier = new Notifier();
+    const registry = new ActionRegistry();
+    registerBuiltinActions(registry);
+    // ── 微信 Bot ──────────────────────────────────────────
+    const wechatCredsPath = join(getConfigDir(), 'wechat.json');
+    const clipboardWatch = new ClipboardWatchRegistry();
+    let wsHubSafe = null;
+    const scheduler = new TaskScheduler(repo, registry, {
+        scriptRunner,
+        notifier,
+        config,
+        trackRunningScript: (taskId, handle) => scheduler.trackRunningScript(taskId, handle),
+        requestRun: (taskId, source) => scheduler.requestRun(taskId, (source ?? 'manual')),
+        armClipboardWatch: (rule) => {
+            clipboardWatch.arm(rule);
+        },
+        log: () => {
+            /* 日志经执行记录落库；此处可扩展文件日志 */
+        }
+    });
+    const wechatBot = new WechatBot(wechatCredsPath, () => config.get().wechat);
+    const commandRouter = new WechatCommandRouter({
+        scheduler,
+        reminder: (text) => notifier.showReminder({ text })
+    });
+    wechatBot.setCommandHandler((text) => commandRouter.handle(text));
+    notifier.setWechatSender((text) => {
+        void wechatBot.sendText(text);
+    });
+    wechatBot.on('message', ({ text }) => repo.insertWechatMessage('in', text));
+    wechatBot.on('status', (info) => wsHubSafe?.broadcast('wechat-status', info));
+    wechatBot.on('disconnected', (reason) => {
+        console.warn(`[wechat] ${reason}`);
+        notifier.notify('微信连接断开', reason);
+    });
+    // 若已保存过凭据，启动时自动恢复会话（无需重新扫码）
+    if (wechatBot.connected) {
+        wechatBot.resume();
+    }
+    // 剪贴板监听：命中后以匹配值触发目标任务
+    clipboardWatch.on('match', ({ rule, value }) => {
+        console.log(`[clipboard-watch] 命中 /${rule.pattern}/: ${value}`);
+        if (rule.passValueAsArg) {
+            scheduler.runTaskWithArgs(rule.targetTaskId, [value]);
+        }
+        else {
+            scheduler.requestRun(rule.targetTaskId, 'trigger');
+        }
+    });
+    // 扫码枪
+    const scanner = new ScannerReader(() => config.get().scanner);
+    scanner.on('scan', (value) => {
+        console.log(`[scanner] 扫码内容: ${value}`);
+        wsHubSafe?.broadcast('scanner-scan', { value });
+        const sc = config.get().scanner;
+        const now = new Date().toLocaleString('zh-CN', { hour12: false });
+        if (sc.notifyWechat && wechatBot.connected) {
+            void wechatBot.sendText(`📱 扫码内容\n值：${value}\n时间：${now}`);
+        }
+        if (sc.notifyDesktop) {
+            notifier.notify('扫码枪', value);
+        }
+    });
+    scanner.on('status', (level, msg) => {
+        console.log(`[scanner:${level}] ${msg}`);
+        wsHubSafe?.broadcast('scanner-status', { level, message: msg });
+    });
+    // 快捷指令存储
+    const quickActionsStore = new QuickActionsStore(join(getConfigDir(), 'quick-actions.json'));
+    // 配置快照：配置变更自动快照，保留 20 份
+    const snapshotSource = {
+        getSettings: () => config.get(),
+        listTasks: () => scheduler.listTasks().map((t) => ({ id: t.id, config: t.config })),
+        getQuickActions: () => quickActionsStore.load(),
+        apply: ({ settings: s, tasks, quickActions }) => {
+            config.replaceAll(s);
+            repo.replaceAll(tasks ?? []);
+            if (quickActions)
+                quickActionsStore.save(quickActions);
+        }
+    };
+    // 旧版 tasks.json 迁移（仅当任务表为空）
+    const legacyPath = join(getConfigDir(), 'tasks.json');
+    const migrated = migrateLegacyTasksFile(legacyPath, repo);
+    if (migrated.imported > 0) {
+        console.log(`[deskpet] 已从旧版导入 ${migrated.imported} 个任务`);
+    }
+    scheduler.load();
+    // 注意：scheduler.start() 刻意推迟到 listen() 成功之后，见下方调用点的注释
+    // 自动快照：任务/设置/皮肤变更去抖 3 秒
+    let snapshotTimer = null;
+    const snapshots = new SnapshotService(db, snapshotSource);
+    const scheduleAutoSnapshot = () => {
+        if (snapshotTimer)
+            clearTimeout(snapshotTimer);
+        snapshotTimer = setTimeout(() => {
+            try {
+                snapshots.snapshot('auto');
+            }
+            catch {
+                /* ignore */
+            }
+        }, 3000);
+        snapshotTimer.unref?.();
+    };
+    // ── 管理台 WebUI 服务（Express + WebSocket） ───────────
+    const wsHub = new WsHub();
+    wsHubSafe = wsHub;
+    notifier.setSink(wsHub);
+    const expressApp = createApp({
+        scheduler,
+        repo,
+        config,
+        notifier,
+        registry,
+        wsHub,
+        wechat: wechatBot,
+        scanner,
+        snapshots,
+        quickActions: quickActionsStore,
+        clipboardWatch
+    });
+    // 监听地址允许用环境变量临时覆盖。
+    // 为什么需要：dev-all.mjs 会读 DESKPET_PORT 去等端口，而后端原先只认 settings.json，
+    // 两边取值来源不一致 —— 一旦设了环境变量，就成了「后端其实起来了，启动脚本却一直等不到」。
+    // 顺带也让同机并行跑第二个实例（调试用）成为可能。
+    const envPort = Number(process.env.DESKPET_PORT);
+    const serverHost = process.env.DESKPET_HOST?.trim() || config.get('server.host');
+    const serverPort = Number.isInteger(envPort) && envPort > 0 ? envPort : config.get('server.port');
+    const httpServer = await listen(expressApp, serverPort, serverHost);
+    wsHub.attach(httpServer);
+    const dashUrl = dashboardUrl(serverHost, serverPort);
+    console.log(`[deskpet] 管理台: ${dashUrl}`);
+    console.log(`[deskpet] 数据目录: ${getDataRoot()}`);
+    // ── 事件接线 ──────────────────────────────────────────
+    scheduler.on('status', (evt) => wsHub.broadcast('task-status', evt));
+    scheduler.on('execution', (info) => wsHub.broadcast('execution', info));
+    scheduler.on('busy', (on) => wsHub.broadcast('busy', on));
+    scheduler.on('queue', (state) => wsHub.broadcast('queue-changed', state));
+    // 运行中脚本的实时 stdout/stderr（管理台可边跑边看）
+    scheduler.on('output', (ev) => wsHub.broadcast('task-output', ev));
+    scheduler.on('changed', () => {
+        wsHub.broadcast('tasks-changed', { ts: Date.now() });
+        scheduleAutoSnapshot();
+    });
+    config.on('changed', scheduleAutoSnapshot);
+    // ── 启动调度器（必须晚于 listen 成功）─────────────────────
+    // start() 内部会调用 recoverInterrupted()：把库里残留在 running / pending 的任务
+    // 复位，并给未结束的执行记录收尾。这一步是「有罪推定」——它假定
+    // 「库里凡是 running 的任务，都是上个进程挂掉时留下的」。
+    //
+    // 但本进程完全可能只是因为 3210 端口被占用而没抢到实例（重复启动、--watch 抖动），
+    // 而真正在跑任务的其实是另一个进程。此时若提前执行 recoverInterrupted()，
+    // 就会把对方正在执行的任务误判成「服务重启，执行被中断」——
+    // 用户看到的现象是「刚点运行不到 1 秒就报中断」，且任务日志一个字节都没产生。
+    //
+    // 因此必须等 listen() 成功之后再启动调度器。
+    //
+    // 但光靠端口还不够：Windows 上 libuv 默认给监听套接字设 SO_REUSEADDR，
+    // 允许多个进程同时绑定同一端口且都 listen 成功，EADDRINUSE 基本不会触发。
+    // 所以这里再用心跳文件判一次「是否已有实例在跑」，有的话只跳过恢复动作、
+    // 不中断对方（见 utils/instance-guard.ts）。
+    // 单实例判定改用**原子锁**（O_EXCL 一步完成「检查 + 创建」），
+    // 取代原先心跳那种「读 → 判 → 写」三步：后者在两个实例几乎同时启动时，
+    // 双方都可能读到「没有心跳 / 心跳已过期」，于是双双认定「我是唯一实例」，
+    // 双双执行 recoverInterrupted()，把对方正在跑的任务掐成「服务重启，执行被中断」。
+    const instanceLock = acquireInstanceLock();
+    if (!instanceLock.acquired) {
+        console.warn('[deskpet] 检测到已有 DeskPet 实例在运行：本次跳过「残留任务恢复」，' +
+            '不会中断对方正在执行的任务');
+    }
+    startHeartbeat();
+    scheduler.start({ recover: instanceLock.acquired });
+    // 开机自启：启动时应用 + 跟随设置变化
+    let lastAutoStart = config.get().system.autoStart;
+    void setAutoStart(lastAutoStart);
+    config.on('changed', () => {
+        const next = config.get().system.autoStart;
+        if (next !== lastAutoStart) {
+            lastAutoStart = next;
+            void setAutoStart(next);
+        }
+    });
+    // 扫码枪：启用则随应用自动连接 + 跟随"自动开启"开关变化
+    if (config.get().scanner.enabled) {
+        void scanner.start();
+    }
+    let lastScannerEnabled = config.get().scanner.enabled;
+    config.on('changed', () => {
+        const next = config.get().scanner.enabled;
+        if (next !== lastScannerEnabled) {
+            lastScannerEnabled = next;
+            if (next)
+                void scanner.start();
+            else
+                scanner.stop();
+        }
+    });
+    // ── 场景触发：闲置 / 联网 ─────────────────────────────
+    const idleMonitor = new IdleMonitor((minutes) => scheduler.notifyIdle(minutes));
+    idleMonitor.start();
+    const networkMonitor = new NetworkMonitor(() => scheduler.notifyNetwork());
+    networkMonitor.start();
+    // ── 优雅退出 ─────────────────────────────────────────
+    const shutdown = () => {
+        // 用 shutdown() 而非 stop()：前者会把运行中/排队中的任务收尾落库，
+        // 否则退出时留下的 running 状态会被下次启动误判成「服务重启中断」
+        scheduler.shutdown();
+        idleMonitor.stop();
+        networkMonitor.stop();
+        wsHub.close();
+        httpServer.close();
+        // killAll 现在会真正终止子进程树（旧实现只清状态，Windows 上会留下孤儿脚本）
+        scriptRunner.killAll();
+        wechatBot.shutdown();
+        scanner.shutdown();
+        clipboardWatch.shutdown();
+        instanceLock.release();
+        console.log('[deskpet] 已退出');
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    console.log('[deskpet] 服务就绪');
+}
+/** 监听端口；端口被占用时给出提示并退出（取代单实例锁） */
+function listen(app, port, host) {
+    return new Promise((resolve, reject) => {
+        const server = app.listen(port, host, () => resolve(server));
+        server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                reject(new Error(`端口 ${port} 已被占用，DeskPet 可能已在运行（访问 ${dashboardUrl(host, port)}）`));
+            }
+            else {
+                reject(err);
+            }
+        });
+    });
+}
+main().catch((err) => {
+    console.error('[deskpet] 启动失败:', err);
+    process.exit(1);
+});

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

@@ -0,0 +1,67 @@
+/**
+ * 系统内置动作 — 锁屏 / 打开回收站 / 刷新桌面 / 清剪贴板
+ * 无 Electron 依赖，全部走系统命令；未适配的平台返回失败
+ */
+import { exec } from 'node:child_process';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { clearClipboard } from "../../utils/clipboard.js";
+import { openPath } from "../../utils/open.js";
+function runCmd(cmd) {
+    return new Promise((resolve) => {
+        exec(cmd, { timeout: 10000 }, (err) => {
+            resolve(err ? { ok: false, error: err.message } : { ok: true });
+        });
+    });
+}
+/** 锁屏（macOS: Ctrl+Cmd+Q；Windows: rundll32 锁定工作站） */
+export const lockScreenAction = async (_task, ctx) => {
+    const cmd = process.platform === 'darwin'
+        ? 'osascript -e \'tell application "System Events" to keystroke "q" using {control down, command down}\''
+        : process.platform === 'win32'
+            ? 'rundll32.exe user32.dll,LockWorkStation'
+            : '';
+    if (!cmd)
+        return { success: false, error: `暂不支持的平台: ${process.platform}` };
+    const r = await runCmd(cmd);
+    if (r.ok) {
+        ctx.log('已锁定屏幕');
+        return { success: true };
+    }
+    return { success: false, error: r.error };
+};
+/** 打开回收站 */
+export const openTrashAction = async (_task, ctx) => {
+    const target = process.platform === 'darwin'
+        ? join(homedir(), '.Trash')
+        : process.platform === 'win32'
+            ? 'shell:RecycleBinFolder'
+            : 'trash:///';
+    const err = await openPath(target);
+    if (err)
+        return { success: false, error: err };
+    ctx.log('已打开回收站');
+    return { success: true };
+};
+/** 刷新桌面（macOS: 重启 Finder；Windows: 重启资源管理器） */
+export const refreshDesktopAction = async (_task, ctx) => {
+    const cmd = process.platform === 'darwin'
+        ? 'killall Finder'
+        : process.platform === 'win32'
+            ? 'taskkill /F /IM explorer.exe & start explorer.exe'
+            : '';
+    if (!cmd)
+        return { success: false, error: `暂不支持的平台: ${process.platform}` };
+    const r = await runCmd(cmd);
+    if (r.ok) {
+        ctx.log('已刷新桌面');
+        return { success: true };
+    }
+    return { success: false, error: r.error };
+};
+/** 清空剪贴板 */
+export const clearClipboardAction = async (_task, ctx) => {
+    await clearClipboard();
+    ctx.log('已清空剪贴板');
+    return { success: true };
+};

package/dist/node/server/plugins/actions/clipboard-watch.js

@@ -0,0 +1,27 @@
+/** 注册表由 main 注入到 ActionContext.requestClipboardWatch */
+export const clipboardWatchAction = async (task, ctx) => {
+    const p = task.config.actionParams ?? {};
+    const pattern = String(p['pattern'] ?? '').trim();
+    const targetTaskId = String(p['targetTaskId'] ?? '').trim();
+    if (!pattern || !targetTaskId) {
+        return {
+            success: false,
+            error: '需要参数 pattern（正则）与 targetTaskId（命中后执行的任务）'
+        };
+    }
+    const arm = ctx.armClipboardWatch;
+    if (!arm) {
+        return { success: false, error: '剪贴板监视器未接入' };
+    }
+    try {
+        arm({ pattern, targetTaskId, passValueAsArg: p['passValueAsArg'] !== false });
+    }
+    catch (err) {
+        return { success: false, error: String(err) };
+    }
+    ctx.log(`已武装剪贴板监听: /${pattern}/ → ${targetTaskId}`);
+    return {
+        success: true,
+        stdout: `正在监听剪贴板 /${pattern}/，命中后执行任务 ${targetTaskId}`
+    };
+};

package/dist/node/server/plugins/actions/http-request.js

@@ -0,0 +1,41 @@
+export const httpRequestAction = async (task, ctx) => {
+    const p = task.config.actionParams;
+    const url = p.url;
+    if (!url)
+        return { success: false, error: '未指定 url' };
+    const method = String(p.method ?? 'GET').toUpperCase();
+    const headers = p.headers ?? {};
+    const body = p.body;
+    const timeoutMs = typeof p.timeoutMs === 'number' ? p.timeoutMs : 15000;
+    const successCodes = p.successCodes ?? [];
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const resp = await fetch(url, {
+            method,
+            headers: { 'User-Agent': 'DeskPet/2.0', ...headers },
+            body: body === undefined || body === null
+                ? undefined
+                : typeof body === 'string'
+                    ? body
+                    : JSON.stringify(body),
+            signal: controller.signal
+        });
+        const ok = successCodes.length > 0
+            ? successCodes.includes(resp.status)
+            : resp.status >= 200 && resp.status < 300;
+        const text = (await resp.text()).slice(0, 2000);
+        ctx.log(`HTTP ${method} ${url} → ${resp.status}`);
+        return {
+            success: ok,
+            stdout: text,
+            error: ok ? undefined : `HTTP ${resp.status}`
+        };
+    }
+    catch (err) {
+        return { success: false, error: `请求失败: ${String(err)}` };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+};

package/dist/node/server/plugins/actions/jenkins-build.js

@@ -0,0 +1,183 @@
+const DEFAULT_TIMEOUT_MS = 600_000;
+const POLL_INTERVAL_MS = 3_000;
+function normalizeBase(raw) {
+    return String(raw ?? '').trim().replace(/\/+$/, '');
+}
+function basicAuth(user, pass) {
+    return 'Basic ' + Buffer.from(`${user}:${pass}`, 'utf-8').toString('base64');
+}
+/** "folder/my job" → "job/folder/job/my%20job" */
+function jobPath(job) {
+    const segs = String(job ?? '')
+        .split('/')
+        .map((s) => encodeURIComponent(s.trim()))
+        .filter(Boolean);
+    return segs.map((s) => `job/${s}`).join('/');
+}
+/** 构建参数：JSON 对象 / 每行 key=value / 空 */
+function parseParams(raw) {
+    if (!raw)
+        return {};
+    if (typeof raw === 'object' && !Array.isArray(raw)) {
+        const out = {};
+        for (const [k, v] of Object.entries(raw)) {
+            out[k] = typeof v === 'object' ? JSON.stringify(v) : String(v);
+        }
+        return out;
+    }
+    const text = String(raw).trim();
+    if (!text)
+        return {};
+    if (text.startsWith('{')) {
+        const obj = JSON.parse(text);
+        const out = {};
+        for (const [k, v] of Object.entries(obj)) {
+            out[k] = typeof v === 'object' ? JSON.stringify(v) : String(v);
+        }
+        return out;
+    }
+    const out = {};
+    for (const line of text.split('\n')) {
+        const t = line.trim();
+        if (!t)
+            continue;
+        const i = t.indexOf('=');
+        if (i <= 0)
+            throw new Error(`构建参数每行应为 key=value，收到：${t}`);
+        out[t.slice(0, i).trim()] = t.slice(i + 1).trim();
+    }
+    return out;
+}
+/** 获取 CSRF crumb；未启用 CSRF 时返回空 */
+async function fetchCrumb(base, headers) {
+    try {
+        const r = await fetch(`${base}/crumbIssuer/api/json`, { headers });
+        if (!r.ok)
+            return {};
+        const j = (await r.json());
+        if (j.crumbRequestField && j.crumb)
+            return { [j.crumbRequestField]: j.crumb };
+        return {};
+    }
+    catch {
+        return {};
+    }
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+/** 轮询直到返回非 null 或超时（返回 null 表示超时） */
+async function pollUntil(fn, timeoutMs) {
+    const start = Date.now();
+    for (;;) {
+        const v = await fn();
+        if (v !== null && v !== undefined)
+            return v;
+        if (Date.now() - start >= timeoutMs)
+            return null;
+        await sleep(POLL_INTERVAL_MS);
+    }
+}
+export const jenkinsBuildAction = async (task, ctx) => {
+    const p = task.config.actionParams ?? {};
+    const job = String(p['jobName'] ?? '').trim();
+    if (!job)
+        return { success: false, error: '未填写 Jenkins Job 名称' };
+    const j = (ctx.config.get().jenkins ?? {});
+    const base = normalizeBase(j.url ?? '');
+    if (!base) {
+        return { success: false, error: '未配置 Jenkins 地址，请先到「系统设置 → Jenkins」填写 URL 与账号' };
+    }
+    let params;
+    try {
+        params = parseParams(p['params']);
+    }
+    catch (err) {
+        return { success: false, error: `构建参数解析失败: ${err.message}` };
+    }
+    const parsedTimeout = Number(p['timeoutMs']);
+    const timeoutMs = Number.isFinite(parsedTimeout) && parsedTimeout > 0 ? parsedTimeout : DEFAULT_TIMEOUT_MS;
+    const headers = { Authorization: basicAuth(j.username ?? '', j.password ?? '') };
+    Object.assign(headers, await fetchCrumb(base, headers));
+    const hasParams = Object.keys(params).length > 0;
+    const endpoint = hasParams ? 'buildWithParameters' : 'build';
+    const qs = hasParams ? `?${new URLSearchParams(params).toString()}` : '';
+    const triggerUrl = `${base}/${jobPath(job)}/${endpoint}${qs}`;
+    ctx.log(`触发 Jenkins 构建：${job}`);
+    let res;
+    try {
+        res = await fetch(triggerUrl, { method: 'POST', headers });
+    }
+    catch (err) {
+        return { success: false, error: `请求 Jenkins 失败: ${err.message}（请检查地址与网络）` };
+    }
+    if (res.status === 401 || res.status === 403) {
+        return {
+            success: false,
+            error: `Jenkins 认证失败（HTTP ${res.status}），请检查用户名与密码/API Token`
+        };
+    }
+    if (!res.ok && res.status !== 201) {
+        const detail = (await res.text().catch(() => '')).slice(0, 200);
+        return { success: false, error: `触发构建失败：HTTP ${res.status} ${detail}` };
+    }
+    const location = res.headers.get('location') ?? '';
+    if (!location) {
+        return { success: false, error: 'Jenkins 未返回队列地址（响应缺少 Location 头）' };
+    }
+    // 1) 等排队任务落到具体构建号
+    const queueUrl = location.endsWith('/') ? `${location}api/json` : `${location}/api/json`;
+    const buildNumber = await pollUntil(async () => {
+        try {
+            const r = await fetch(queueUrl, { headers });
+            if (!r.ok)
+                return null;
+            const q = (await r.json());
+            return q.executable?.number ?? null;
+        }
+        catch {
+            return null;
+        }
+    }, Math.min(timeoutMs, 120_000));
+    if (buildNumber == null) {
+        return { success: false, error: '等待 Jenkins 开始构建超时（任务可能一直在排队）' };
+    }
+    // 2) 等构建结束拿到结果
+    const buildApi = `${base}/${jobPath(job)}/${buildNumber}/api/json`;
+    const consoleUrl = `${base}/${jobPath(job)}/${buildNumber}/console`;
+    const result = await pollUntil(async () => {
+        try {
+            const r = await fetch(buildApi, { headers });
+            if (!r.ok)
+                return null;
+            const b = (await r.json());
+            if (b.building)
+                return null;
+            return b.result ?? null;
+        }
+        catch {
+            return null;
+        }
+    }, timeoutMs);
+    if (result == null) {
+        return {
+            success: false,
+            error: `等待构建结果超时（>${Math.round(timeoutMs / 1000)}s）`,
+            stdout: `Job: ${job}\n构建号: #${buildNumber}\n控制台: ${consoleUrl}`
+        };
+    }
+    const ok = result === 'SUCCESS';
+    const summary = [
+        `Job: ${job}`,
+        `构建号: #${buildNumber}`,
+        `结果: ${result}`,
+        `控制台: ${consoleUrl}`
+    ].join('\n');
+    ctx.log(`构建 #${buildNumber} 结果 ${result}`);
+    return {
+        success: ok,
+        exitCode: ok ? 0 : 1,
+        stdout: summary,
+        error: ok ? undefined : `Jenkins 构建结果：${result}（#${buildNumber}）`
+    };
+};

package/dist/node/server/plugins/actions/open-app.js

@@ -0,0 +1,41 @@
+/**
+ * open_app 动作 — 打开本地程序 / 文件 / 文件夹 / URL
+ * action_params:
+ *   - url: 打开 URL（系统默认浏览器）
+ *   - target: 文件/文件夹路径（系统默认程序）
+ *   - app: 应用名或可执行文件路径
+ */
+import { openApp, openPath, openUrl } from "../../utils/open.js";
+export const openAppAction = async (task, ctx) => {
+    const p = task.config.actionParams;
+    const url = p.url;
+    const target = p.target;
+    const app = p.app;
+    try {
+        if (url) {
+            const err = await openUrl(String(url));
+            if (err)
+                return { success: false, error: `打开失败: ${err}` };
+            ctx.log(`已打开 URL: ${url}`);
+            return { success: true };
+        }
+        if (target) {
+            const err = await openPath(String(target));
+            if (err)
+                return { success: false, error: `打开失败: ${err}` };
+            ctx.log(`已打开: ${target}`);
+            return { success: true };
+        }
+        if (app) {
+            const err = await openApp(String(app));
+            if (err)
+                return { success: false, error: `打开失败: ${err}` };
+            ctx.log(`已打开应用: ${app}`);
+            return { success: true };
+        }
+        return { success: false, error: '未指定 url/target/app 任一参数' };
+    }
+    catch (err) {
+        return { success: false, error: `打开失败: ${String(err)}` };
+    }
+};