@wanghaopeng1148/deskpet 2.0.0

package/server/services/idle-monitor.ts

@@ -0,0 +1,146 @@
+/**
+ * 场景触发监听 — 取代 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: string, args: string[], timeout = 5000): Promise<string> {
+  return new Promise((resolvePromise) => {
+    execFile(
+      cmd,
+      args,
+      { timeout, windowsHide: true, maxBuffer: 1024 * 1024 },
+      (err, stdout) => resolvePromise(err ? '' : String(stdout ?? ''))
+    )
+  })
+}
+
+/** 获取系统闲置秒数（失败返回 0，表示"未闲置"） */
+export async function getSystemIdleSeconds(): Promise<number> {
+  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 {
+  private timer: ReturnType<typeof setInterval> | null = null
+  private lastMinutes = -1
+  private busy = false
+
+  private onIdleChange: (idleMinutes: number) => void
+  private intervalMs: number
+
+  constructor(onIdleChange: (idleMinutes: number) => void, intervalMs = 30000) {
+    this.onIdleChange = onIdleChange
+    this.intervalMs = intervalMs
+  }
+
+  start(): void {
+    if (this.timer) return
+    this.timer = setInterval(() => {
+      void this.tick()
+    }, this.intervalMs)
+    this.timer.unref?.()
+  }
+
+  private async tick(): Promise<void> {
+    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(): void {
+    if (this.timer) clearInterval(this.timer)
+    this.timer = null
+  }
+}
+
+/** 网络恢复检测 — 周期性 DNS 探测，从失败恢复为成功时回调一次 */
+export class NetworkMonitor {
+  private timer: ReturnType<typeof setInterval> | null = null
+  private lastOnline = true
+
+  private onOnline: () => void
+  private intervalMs: number
+  private host: string
+
+  constructor(onOnline: () => void, intervalMs = 60000, host = 'www.baidu.com') {
+    this.onOnline = onOnline
+    this.intervalMs = intervalMs
+    this.host = host
+  }
+
+  start(): void {
+    if (this.timer) return
+    this.timer = setInterval(() => {
+      void this.tick()
+    }, this.intervalMs)
+    this.timer.unref?.()
+  }
+
+  private async tick(): Promise<void> {
+    let online = false
+    try {
+      await dnsLookup(this.host)
+      online = true
+    } catch {
+      online = false
+    }
+    if (online && !this.lastOnline) this.onOnline()
+    this.lastOnline = online
+  }
+
+  stop(): void {
+    if (this.timer) clearInterval(this.timer)
+    this.timer = null
+  }
+}

package/server/services/notifier.ts

@@ -0,0 +1,54 @@
+/**
+ * 通知中心 — 系统原生通知 + WebSocket 推送 + 微信 三通道统一收口
+ *
+ * 无 Electron 依赖：桌面通道由系统命令发出（utils/native-notify），
+ * WebUI 通道经 WebSocket 广播，前端可用 Notification API 或页面内提示呈现。
+ */
+import type { Reminder } from '../../shared/types.ts'
+import { notifyNative } from '../utils/native-notify.ts'
+
+/** 广播出口（WsHub 满足该接口） */
+export interface NotificationSink {
+  broadcast(type: string, payload: unknown): void
+}
+
+export class Notifier {
+  private sink: NotificationSink | null = null
+  private wechatSender: ((text: string) => void) | null = null
+
+  constructor(sink?: NotificationSink) {
+    this.sink = sink ?? null
+  }
+
+  /** 绑定广播出口（WsHub 就绪后注入） */
+  setSink(sink: NotificationSink): void {
+    this.sink = sink
+  }
+
+  /** 注入微信发送通道 */
+  setWechatSender(sender: (text: string) => void): void {
+    this.wechatSender = sender
+  }
+
+  /** 系统原生通知 + 广播到 WebUI */
+  notify(title: string, body: string): void {
+    notifyNative(title, body)
+    this.sink?.broadcast('notification', { title, body, ts: Date.now() })
+  }
+
+  /** 任务提醒：广播到 WebUI（原气泡/全屏窗口已移除），并尝试系统通知 */
+  showReminder(reminder: Reminder): void {
+    const payload = { ...reminder, ts: Date.now() }
+    this.sink?.broadcast('reminder', payload)
+    notifyNative('任务提醒', reminder.text)
+  }
+
+  /** 微信通道（未连接时静默丢弃） */
+  sendWechat(text: string): void {
+    try {
+      this.wechatSender?.(text)
+    } catch (err) {
+      console.error('[notify] 微信推送失败:', err)
+    }
+  }
+}

package/server/services/quick-actions-store.ts

@@ -0,0 +1,54 @@
+/**
+ * 快捷指令存储 — 花瓣菜单按钮配置（userData/config/quick-actions.json）
+ */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import type { QuickAction } from '../../shared/types.ts'
+
+const DEFAULT_ACTIONS: QuickAction[] = [
+  { id: 'qa-dashboard', label: '管理台', icon: '🖥' },
+  { id: 'qa-hide', label: '隐藏', icon: '🙈' }
+]
+
+export class QuickActionsStore {
+  private cache: QuickAction[] | null = null
+  private filePath: string
+
+  constructor(filePath: string) {
+    this.filePath = filePath
+  }
+
+  load(): QuickAction[] {
+    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')) as { actions?: QuickAction[] }
+      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: QuickAction[]): void {
+    this.cache = actions
+    try {
+      writeFileSync(this.filePath, JSON.stringify({ actions }, null, 2), 'utf-8')
+    } catch (err) {
+      console.error('[quick-actions] 保存失败:', err)
+    }
+  }
+}

package/server/services/remote-connector.ts

@@ -0,0 +1,75 @@
+/**
+ * 远程连接自检 — 供「系统设置」验证 Linux 服务器 / Jenkins 凭据是否可用
+ * 只做连通性探测，不执行任何命令
+ */
+import { Client } from 'ssh2'
+import type { JenkinsConfig, LinuxServer } from '../../shared/types.ts'
+
+export interface TestResult {
+  ok: boolean
+  message: string
+}
+
+const CONNECT_TIMEOUT_MS = 10_000
+
+/** 测试 SSH 能否连通并认证通过 */
+export function testSshConnection(server: Partial<LinuxServer>): Promise<TestResult> {
+  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: TestResult): void => {
+      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: Error) => {
+        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: Partial<JenkinsConfig>): Promise<TestResult> {
+  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()) as { nodeName?: string }
+    return { ok: true, message: j.nodeName ? `连接成功：${j.nodeName}` : '连接成功' }
+  } catch (err) {
+    return { ok: false, message: `连接失败：${(err as Error).message}` }
+  }
+}

package/server/services/scanner-reader.ts

@@ -0,0 +1,257 @@
+/**
+ * 扫码枪读取 — 串口模式条码扫描器（对齐旧版 scanner_reader.py）
+ *
+ * 通信特性（参考 Honeywell 1450g）:
+ *  - 串口 9600 baud
+ *  - 数据帧一次性吐出，通常 STX(\x02) 开头 ETX(\x03) 结尾
+ *  - 首块到达后短暂等待拼帧，再剥离控制字符取纯值
+ *
+ * serialport 为原生模块：不可用时服务降级，不影响主程序。
+ * 注意：本项目为 ESM（"type": "module"），必须用动态 import() 加载，
+ * 不能用 require()（ESM 上下文 require 未定义）。
+ */
+import { EventEmitter } from 'node:events'
+import type { ScannerSettings } from '../../shared/types.ts'
+
+/** 剥离条码帧控制字符（STX/ETX/CR/LF），提取纯条码值 */
+export function stripBarcode(raw: Buffer | string): string {
+  const text = (typeof raw === 'string' ? raw : raw.toString('ascii')).replace(
+    /[\x02\x03\r\n]/g,
+    ''
+  )
+  return text.trim()
+}
+
+export interface SerialPortLike {
+  on(event: 'data', cb: (chunk: Buffer) => void): void
+  on(event: 'close', cb: () => void): void
+  on(event: 'error', cb: (err: Error) => void): void
+  write(data: Buffer): void
+  close(): void
+}
+
+interface SerialPortCtor {
+  new (options: { path: string; baudRate: number; autoOpen?: boolean }): SerialPortLike & {
+    open(cb?: (err?: Error) => void): void
+    set(options: { rts?: boolean; dtr?: boolean }): void
+  }
+}
+
+type SerialModule = {
+  SerialPort: SerialPortCtor
+  list: () => Promise<Array<{ path: string }>>
+}
+
+/** 动态加载 serialport（ESM 下用 import()，原生模块缺失时返回 null 并降级） */
+async function loadSerialModule(): Promise<SerialModule | null> {
+  try {
+    const mod = (await import('serialport')) as unknown as {
+      SerialPort?: SerialPortCtor
+      default?: { SerialPort?: SerialPortCtor }
+    }
+    const SerialPort = mod.SerialPort ?? mod.default?.SerialPort
+    if (!SerialPort) return null
+    // serialport v13: list 是 SerialPort 的静态方法，而非顶层导出
+    const list = (SerialPort as unknown as { list?: () => Promise<Array<{ path: string }>> }).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 interface ScannerDiagnostics {
+  running: boolean
+  connected: boolean
+  lastError: string | null
+  lastStatus: { level: string; message: string; at: number } | null
+}
+
+export class ScannerReader extends EventEmitter {
+  private port: SerialPortLike | null = null
+  private running = false
+  private connecting = false
+  private connected = false
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null
+  private lastError: string | null = null
+  private lastStatus: { level: string; message: string; at: number } | null = null
+  private getConfig: () => ScannerSettings
+
+  constructor(getConfig: () => ScannerSettings) {
+    super()
+    this.getConfig = getConfig
+  }
+
+  get isRunning(): boolean {
+    return this.running
+  }
+
+  get isConnected(): boolean {
+    return this.connected
+  }
+
+  /** 返回最近一次状态/错误，供前端诊断展示 */
+  getDiagnostics(): ScannerDiagnostics {
+    return {
+      running: this.running,
+      connected: this.connected,
+      lastError: this.lastError,
+      lastStatus: this.lastStatus
+    }
+  }
+
+  /** 枚举系统可用串口 */
+  static async listPorts(): Promise<string[]> {
+    const mod = await loadSerialModule()
+    if (!mod) return []
+    try {
+      const ports = await mod.list()
+      return ports.map((p) => p.path)
+    } catch {
+      return []
+    }
+  }
+
+  /**
+   * 启动并连接扫码枪。
+   * @returns null 表示连接成功；否则返回具体错误文案（供前端直接展示）。
+   */
+  start(): Promise<string | null> {
+    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()
+  }
+
+  private async connect(): Promise<string | null> {
+    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<string | null>((resolve) => {
+      let settled = false
+      const finish = (err: string | null) => {
+        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 as unknown as { set(o: { rts: boolean; dtr: boolean }): void }).set({
+              rts: true,
+              dtr: true
+            })
+          } catch {
+            /* 部分 USB 转串口不支持 */
+          }
+          this.port = port
+          this.report('info', `扫码枪已连接: ${cfg.port} @ ${cfg.baud}`)
+
+          let frame = Buffer.alloc(0)
+          let settleTimer: ReturnType<typeof setTimeout> | null = null
+          port.on('data', (chunk: Buffer) => {
+            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: Error) => {
+            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()
+      }
+    })
+  }
+
+  private scheduleReconnect(): void {
+    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(): void {
+    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(): void {
+    this.stop()
+  }
+
+  /** 记录最近状态并向外广播 */
+  private report(level: string, message: string): void {
+    this.lastStatus = { level, message, at: Date.now() }
+    this.emit('status', level, message)
+  }
+}