@wanghaopeng1148/deskpet 2.0.0 → 2.0.2

package/dist/node/server/services/config-store.js

@@ -0,0 +1,141 @@
+/**
+ * 配置存储 — 轻量 JSON 持久化（对应旧版 ConfigStore + electron-store 职责）
+ * 文件: userData/config/settings.json
+ */
+import { EventEmitter } from 'events';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { ensureDir, getConfigDir } from "../utils/paths.js";
+export const DEFAULT_SETTINGS = {
+    system: {
+        autoStart: false,
+        powerMode: 'balanced',
+        idleSleepMinutes: 3
+    },
+    audio: {
+        enabled: true,
+        volume: 70
+    },
+    server: {
+        host: '127.0.0.1',
+        port: 3210
+    },
+    wechat: {
+        notifyOnTaskComplete: true,
+        notifyOnTaskFailed: true,
+        notifyOnStartup: false,
+        autoConnect: true,
+        allowRemoteCommand: true
+    },
+    tasks: {
+        breakerThreshold: 3
+    },
+    scanner: {
+        enabled: false,
+        port: '',
+        baud: 9600,
+        notifyWechat: true,
+        notifyDesktop: true
+    },
+    servers: [],
+    jenkins: {
+        url: '',
+        username: '',
+        password: ''
+    }
+};
+function deepMerge(base, patch) {
+    if (patch === null || typeof patch !== 'object' || Array.isArray(patch)) {
+        return (patch === undefined ? base : patch);
+    }
+    const out = { ...base };
+    for (const [k, v] of Object.entries(patch)) {
+        const baseV = base[k];
+        out[k] = typeof v === 'object' && v !== null && !Array.isArray(v) && baseV
+            ? deepMerge(baseV, v)
+            : v;
+    }
+    return out;
+}
+export class ConfigStore extends EventEmitter {
+    settings;
+    filePath;
+    constructor(filePath) {
+        super();
+        this.filePath = filePath ?? join(getConfigDir(), 'settings.json');
+        this.settings = this.load();
+    }
+    load() {
+        try {
+            if (existsSync(this.filePath)) {
+                const raw = JSON.parse(readFileSync(this.filePath, 'utf-8'));
+                return deepMerge(structuredClone(DEFAULT_SETTINGS), raw);
+            }
+        }
+        catch (err) {
+            console.error('[config] 读取配置失败，使用默认值:', err);
+        }
+        // 首次初始化：写入默认配置
+        const defaults = structuredClone(DEFAULT_SETTINGS);
+        try {
+            ensureDir(getConfigDir());
+            writeFileSync(this.filePath, JSON.stringify(defaults, null, 2), 'utf-8');
+        }
+        catch (err) {
+            console.error('[config] 初始化配置写入失败:', err);
+        }
+        return defaults;
+    }
+    get(key) {
+        if (key) {
+            const keys = key.split('.');
+            let cur = this.settings;
+            for (const k of keys) {
+                if (cur && typeof cur === 'object' && k in cur) {
+                    cur = cur[k];
+                }
+                else {
+                    return undefined;
+                }
+            }
+            return structuredClone(cur);
+        }
+        return structuredClone(this.settings);
+    }
+    set(key, value) {
+        const keys = key.split('.');
+        let cur = this.settings;
+        for (let i = 0; i < keys.length - 1; i++) {
+            const k = keys[i];
+            if (!cur[k] || typeof cur[k] !== 'object')
+                cur[k] = {};
+            cur = cur[k];
+        }
+        cur[keys[keys.length - 1]] = value;
+        this.save();
+        this.emit('changed');
+    }
+    update(patch) {
+        this.settings = deepMerge(this.settings, patch);
+        this.save();
+        this.emit('changed');
+    }
+    /** 整体替换设置（快照恢复 / 配置包导入用） */
+    replaceAll(settings) {
+        this.settings = deepMerge(structuredClone(DEFAULT_SETTINGS), settings);
+        this.save();
+        this.emit('changed');
+    }
+    save() {
+        try {
+            ensureDir(getConfigDir());
+            writeFileSync(this.filePath, JSON.stringify(this.settings, null, 2), 'utf-8');
+        }
+        catch (err) {
+            console.error('[config] 保存配置失败:', err);
+        }
+    }
+}
+export function deepMergeConfig(base, patch) {
+    return deepMerge(base, patch);
+}

package/dist/node/server/services/idle-monitor.js

@@ -0,0 +1,131 @@
+/**
+ * 场景触发监听 — 取代 Electron powerMonitor
+ *   IdleMonitor    : 系统闲置时长（Windows GetLastInputInfo / macOS HIDIdleTime / Linux xprintidle）
+ *   NetworkMonitor : 网络恢复（DNS 探测，取代 powerMonitor 'online' 事件）
+ *
+ * 均为尽力而为：平台不支持或命令失败时静默，不触发场景任务。
+ */
+import { execFile } from 'node:child_process';
+import { lookup } from 'node:dns';
+import { promisify } from 'node:util';
+const dnsLookup = promisify(lookup);
+function execText(cmd, args, timeout = 5000) {
+    return new Promise((resolvePromise) => {
+        execFile(cmd, args, { timeout, windowsHide: true, maxBuffer: 1024 * 1024 }, (err, stdout) => resolvePromise(err ? '' : String(stdout ?? '')));
+    });
+}
+/** 获取系统闲置秒数（失败返回 0，表示"未闲置"） */
+export async function getSystemIdleSeconds() {
+    try {
+        if (process.platform === 'darwin') {
+            const out = await execText('ioreg', ['-c', 'IOHIDSystem']);
+            const m = /"HIDIdleTime"\s*=\s*(\d+)/.exec(out);
+            if (m?.[1])
+                return Math.floor(Number(m[1]) / 1_000_000_000);
+            return 0;
+        }
+        if (process.platform === 'win32') {
+            const script = [
+                'Add-Type -Namespace Win32 -Name IdleTime -MemberDefinition \'',
+                '[DllImport("user32.dll")] public static extern bool GetLastInputInfo(ref LASTINPUTINFO plii);',
+                '[StructLayout(LayoutKind.Sequential)] public struct LASTINPUTINFO { public uint cbSize; public uint dwTime; }',
+                'public static uint GetIdleMs() { LASTINPUTINFO lii = new LASTINPUTINFO(); lii.cbSize = (uint)System.Runtime.InteropServices.Marshal.SizeOf(lii); GetLastInputInfo(ref lii); return (uint)System.Environment.TickCount - lii.dwTime; }\'',
+                '[Win32.IdleTime]::GetIdleMs()'
+            ].join(' ');
+            const out = await execText('powershell', ['-NoProfile', '-NonInteractive', '-Command', script], 15000);
+            const ms = Number(out.trim().split(/\s+/).pop());
+            return Number.isFinite(ms) ? Math.floor(ms / 1000) : 0;
+        }
+        if (process.platform === 'linux') {
+            const out = await execText('xprintidle', []);
+            const ms = Number(out.trim());
+            return Number.isFinite(ms) ? Math.floor(ms / 1000) : 0;
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return 0;
+}
+export class IdleMonitor {
+    timer = null;
+    lastMinutes = -1;
+    busy = false;
+    onIdleChange;
+    intervalMs;
+    constructor(onIdleChange, intervalMs = 30000) {
+        this.onIdleChange = onIdleChange;
+        this.intervalMs = intervalMs;
+    }
+    start() {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => {
+            void this.tick();
+        }, this.intervalMs);
+        this.timer.unref?.();
+    }
+    async tick() {
+        if (this.busy)
+            return;
+        this.busy = true;
+        try {
+            const seconds = await getSystemIdleSeconds();
+            const minutes = Math.floor(seconds / 60);
+            if (minutes !== this.lastMinutes) {
+                this.lastMinutes = minutes;
+                this.onIdleChange(minutes);
+            }
+        }
+        catch {
+            /* 平台不可用时静默 */
+        }
+        finally {
+            this.busy = false;
+        }
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+    }
+}
+/** 网络恢复检测 — 周期性 DNS 探测，从失败恢复为成功时回调一次 */
+export class NetworkMonitor {
+    timer = null;
+    lastOnline = true;
+    onOnline;
+    intervalMs;
+    host;
+    constructor(onOnline, intervalMs = 60000, host = 'www.baidu.com') {
+        this.onOnline = onOnline;
+        this.intervalMs = intervalMs;
+        this.host = host;
+    }
+    start() {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => {
+            void this.tick();
+        }, this.intervalMs);
+        this.timer.unref?.();
+    }
+    async tick() {
+        let online = false;
+        try {
+            await dnsLookup(this.host);
+            online = true;
+        }
+        catch {
+            online = false;
+        }
+        if (online && !this.lastOnline)
+            this.onOnline();
+        this.lastOnline = online;
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+    }
+}

package/dist/node/server/services/notifier.js

@@ -0,0 +1,36 @@
+import { notifyNative } from "../utils/native-notify.js";
+export class Notifier {
+    sink = null;
+    wechatSender = null;
+    constructor(sink) {
+        this.sink = sink ?? null;
+    }
+    /** 绑定广播出口（WsHub 就绪后注入） */
+    setSink(sink) {
+        this.sink = sink;
+    }
+    /** 注入微信发送通道 */
+    setWechatSender(sender) {
+        this.wechatSender = sender;
+    }
+    /** 系统原生通知 + 广播到 WebUI */
+    notify(title, body) {
+        notifyNative(title, body);
+        this.sink?.broadcast('notification', { title, body, ts: Date.now() });
+    }
+    /** 任务提醒：广播到 WebUI（原气泡/全屏窗口已移除），并尝试系统通知 */
+    showReminder(reminder) {
+        const payload = { ...reminder, ts: Date.now() };
+        this.sink?.broadcast('reminder', payload);
+        notifyNative('任务提醒', reminder.text);
+    }
+    /** 微信通道（未连接时静默丢弃） */
+    sendWechat(text) {
+        try {
+            this.wechatSender?.(text);
+        }
+        catch (err) {
+            console.error('[notify] 微信推送失败:', err);
+        }
+    }
+}

package/dist/node/server/services/quick-actions-store.js

@@ -0,0 +1,52 @@
+/**
+ * 快捷指令存储 — 花瓣菜单按钮配置（userData/config/quick-actions.json）
+ */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+const DEFAULT_ACTIONS = [
+    { id: 'qa-dashboard', label: '管理台', icon: '🖥' },
+    { id: 'qa-hide', label: '隐藏', icon: '🙈' }
+];
+export class QuickActionsStore {
+    cache = null;
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    load() {
+        if (this.cache)
+            return this.cache;
+        try {
+            if (!existsSync(this.filePath)) {
+                this.cache = [...DEFAULT_ACTIONS];
+                this.save(this.cache);
+                return this.cache;
+            }
+            const raw = JSON.parse(readFileSync(this.filePath, 'utf-8'));
+            const actions = Array.isArray(raw.actions) ? raw.actions : [...DEFAULT_ACTIONS];
+            // 迁移：补齐缺失的内置动作（追加到末尾，用户可在设置中调整顺序）
+            let dirty = false;
+            for (const def of DEFAULT_ACTIONS) {
+                if (!actions.some((a) => a.id === def.id)) {
+                    actions.push({ ...def });
+                    dirty = true;
+                }
+            }
+            this.cache = actions;
+            if (dirty)
+                this.save(this.cache);
+        }
+        catch {
+            this.cache = [...DEFAULT_ACTIONS];
+        }
+        return this.cache;
+    }
+    save(actions) {
+        this.cache = actions;
+        try {
+            writeFileSync(this.filePath, JSON.stringify({ actions }, null, 2), 'utf-8');
+        }
+        catch (err) {
+            console.error('[quick-actions] 保存失败:', err);
+        }
+    }
+}

package/dist/node/server/services/remote-connector.js

@@ -0,0 +1,67 @@
+/**
+ * 远程连接自检 — 供「系统设置」验证 Linux 服务器 / Jenkins 凭据是否可用
+ * 只做连通性探测，不执行任何命令
+ */
+import { Client } from 'ssh2';
+const CONNECT_TIMEOUT_MS = 10_000;
+/** 测试 SSH 能否连通并认证通过 */
+export function testSshConnection(server) {
+    const host = String(server.host ?? '').trim();
+    const username = String(server.username ?? '').trim();
+    if (!host || !username) {
+        return Promise.resolve({ ok: false, message: '请先填写 IP 与用户名' });
+    }
+    return new Promise((resolve) => {
+        const conn = new Client();
+        let done = false;
+        const finish = (r) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            try {
+                conn.end();
+            }
+            catch {
+                /* 已断开时忽略 */
+            }
+            resolve(r);
+        };
+        const timer = setTimeout(() => finish({ ok: false, message: '连接超时（10 秒）' }), CONNECT_TIMEOUT_MS);
+        conn
+            .on('ready', () => {
+            finish({ ok: true, message: `连接成功：${username}@${host}:${server.port || 22}` });
+        })
+            .on('error', (err) => {
+            finish({ ok: false, message: `连接失败：${err.message}` });
+        })
+            .connect({
+            host,
+            port: Number(server.port) || 22,
+            username,
+            password: String(server.password ?? ''),
+            readyTimeout: CONNECT_TIMEOUT_MS
+        });
+    });
+}
+/** 测试 Jenkins 地址与账号（读取 /api/json） */
+export async function testJenkinsConnection(cfg) {
+    const base = String(cfg.url ?? '').trim().replace(/\/+$/, '');
+    if (!base)
+        return { ok: false, message: '请先填写 Jenkins URL' };
+    const auth = 'Basic ' + Buffer.from(`${cfg.username ?? ''}:${cfg.password ?? ''}`, 'utf-8').toString('base64');
+    try {
+        const res = await fetch(`${base}/api/json`, { headers: { Authorization: auth } });
+        if (res.status === 401 || res.status === 403) {
+            return { ok: false, message: `认证失败（HTTP ${res.status}）：请检查用户名与密码/API Token` };
+        }
+        if (!res.ok) {
+            return { ok: false, message: `连接失败：HTTP ${res.status}` };
+        }
+        const j = (await res.json());
+        return { ok: true, message: j.nodeName ? `连接成功：${j.nodeName}` : '连接成功' };
+    }
+    catch (err) {
+        return { ok: false, message: `连接失败：${err.message}` };
+    }
+}

package/dist/node/server/services/scanner-reader.js

@@ -0,0 +1,217 @@
+/**
+ * 扫码枪读取 — 串口模式条码扫描器（对齐旧版 scanner_reader.py）
+ *
+ * 通信特性（参考 Honeywell 1450g）:
+ *  - 串口 9600 baud
+ *  - 数据帧一次性吐出，通常 STX(\x02) 开头 ETX(\x03) 结尾
+ *  - 首块到达后短暂等待拼帧，再剥离控制字符取纯值
+ *
+ * serialport 为原生模块：不可用时服务降级，不影响主程序。
+ * 注意：本项目为 ESM（"type": "module"），必须用动态 import() 加载，
+ * 不能用 require()（ESM 上下文 require 未定义）。
+ */
+import { EventEmitter } from 'node:events';
+/** 剥离条码帧控制字符（STX/ETX/CR/LF），提取纯条码值 */
+export function stripBarcode(raw) {
+    const text = (typeof raw === 'string' ? raw : raw.toString('ascii')).replace(/[\x02\x03\r\n]/g, '');
+    return text.trim();
+}
+/** 动态加载 serialport（ESM 下用 import()，原生模块缺失时返回 null 并降级） */
+async function loadSerialModule() {
+    try {
+        const mod = (await import('serialport'));
+        const SerialPort = mod.SerialPort ?? mod.default?.SerialPort;
+        if (!SerialPort)
+            return null;
+        // serialport v13: list 是 SerialPort 的静态方法，而非顶层导出
+        const list = SerialPort.list;
+        if (!list)
+            return null;
+        return { SerialPort, list };
+    }
+    catch {
+        return null;
+    }
+}
+const FRAME_SETTLE_MS = 50; // 首块到达后等待拼帧
+const RECONNECT_INTERVAL_MS = 3000;
+const OPEN_TIMEOUT_MS = 4000; // 开串口最长等待，避免前端一直转圈
+export class ScannerReader extends EventEmitter {
+    port = null;
+    running = false;
+    connecting = false;
+    connected = false;
+    reconnectTimer = null;
+    lastError = null;
+    lastStatus = null;
+    getConfig;
+    constructor(getConfig) {
+        super();
+        this.getConfig = getConfig;
+    }
+    get isRunning() {
+        return this.running;
+    }
+    get isConnected() {
+        return this.connected;
+    }
+    /** 返回最近一次状态/错误，供前端诊断展示 */
+    getDiagnostics() {
+        return {
+            running: this.running,
+            connected: this.connected,
+            lastError: this.lastError,
+            lastStatus: this.lastStatus
+        };
+    }
+    /** 枚举系统可用串口 */
+    static async listPorts() {
+        const mod = await loadSerialModule();
+        if (!mod)
+            return [];
+        try {
+            const ports = await mod.list();
+            return ports.map((p) => p.path);
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * 启动并连接扫码枪。
+     * @returns null 表示连接成功；否则返回具体错误文案（供前端直接展示）。
+     */
+    start() {
+        if (this.running) {
+            return Promise.resolve(this.connected ? null : this.lastError ?? '扫码枪正在连接…');
+        }
+        const cfg = this.getConfig();
+        if (!cfg.port) {
+            this.lastError = '未配置扫码枪串口（请在设置中填写串口号，如 COM9）';
+            this.report('warning', this.lastError);
+            return Promise.resolve(this.lastError);
+        }
+        this.running = true;
+        return this.connect();
+    }
+    async connect() {
+        if (this.connecting || !this.running)
+            return this.lastError;
+        const cfg = this.getConfig();
+        this.connecting = true;
+        const mod = await loadSerialModule();
+        if (!mod) {
+            this.connecting = false;
+            this.lastError = 'serialport 模块不可用（原生依赖未安装或加载失败）';
+            this.report('error', this.lastError);
+            return this.lastError;
+        }
+        return new Promise((resolve) => {
+            let settled = false;
+            const finish = (err) => {
+                if (settled)
+                    return;
+                settled = true;
+                this.connecting = false;
+                resolve(err);
+            };
+            const timeout = setTimeout(() => finish(this.lastError ?? '串口打开超时（设备未响应、未插好或波特率不匹配）'), OPEN_TIMEOUT_MS);
+            try {
+                const port = new mod.SerialPort({ path: cfg.port, baudRate: cfg.baud, autoOpen: false });
+                port.open((err) => {
+                    clearTimeout(timeout);
+                    if (err) {
+                        this.lastError = `打开串口 ${cfg.port} 失败: ${err.message}`;
+                        this.report('error', this.lastError);
+                        this.connected = false;
+                        finish(this.lastError);
+                        this.scheduleReconnect();
+                        return;
+                    }
+                    this.connected = true;
+                    this.lastError = null;
+                    try {
+                        ;
+                        port.set({
+                            rts: true,
+                            dtr: true
+                        });
+                    }
+                    catch {
+                        /* 部分 USB 转串口不支持 */
+                    }
+                    this.port = port;
+                    this.report('info', `扫码枪已连接: ${cfg.port} @ ${cfg.baud}`);
+                    let frame = Buffer.alloc(0);
+                    let settleTimer = null;
+                    port.on('data', (chunk) => {
+                        frame = Buffer.concat([frame, chunk]);
+                        // 拼帧：首块到达后再等一小段时间收尾
+                        if (settleTimer)
+                            clearTimeout(settleTimer);
+                        settleTimer = setTimeout(() => {
+                            const value = stripBarcode(frame);
+                            frame = Buffer.alloc(0);
+                            if (value)
+                                this.emit('scan', value);
+                        }, FRAME_SETTLE_MS);
+                    });
+                    port.on('close', () => {
+                        this.port = null;
+                        this.connected = false;
+                        if (this.running) {
+                            this.report('warning', '扫码枪串口断开，自动重连中…');
+                            this.scheduleReconnect();
+                        }
+                    });
+                    port.on('error', (e) => {
+                        this.report('error', `串口异常: ${e.message}`);
+                    });
+                    finish(null);
+                });
+            }
+            catch (err) {
+                clearTimeout(timeout);
+                this.lastError = `串口初始化失败: ${String(err)}`;
+                this.report('error', this.lastError);
+                finish(this.lastError);
+                this.scheduleReconnect();
+            }
+        });
+    }
+    scheduleReconnect() {
+        if (!this.running || this.reconnectTimer)
+            return;
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            if (this.running && !this.connected) {
+                void this.connect();
+            }
+        }, RECONNECT_INTERVAL_MS);
+        this.reconnectTimer.unref?.();
+    }
+    stop() {
+        this.running = false;
+        this.connected = false;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        try {
+            this.port?.close();
+        }
+        catch {
+            /* ignore */
+        }
+        this.port = null;
+        this.report('info', '扫码枪已停止');
+    }
+    shutdown() {
+        this.stop();
+    }
+    /** 记录最近状态并向外广播 */
+    report(level, message) {
+        this.lastStatus = { level, message, at: Date.now() };
+        this.emit('status', level, message);
+    }
+}