@wanghaopeng1148/deskpet 2.0.0

package/server/plugins/actions/ssh-command.ts

@@ -0,0 +1,148 @@
+/**
+ * ssh_command — 在「系统设置 → Linux 服务器」选中的服务器上远程执行 Shell 命令
+ *
+ * 参数（task.actionParams）:
+ *   serverId   设置里 Linux 服务器的 id
+ *   command    要执行的 Shell 命令（支持多行，会整体交给远端 shell）
+ *   timeoutMs  超时毫秒数（可选，默认 120s）
+ */
+import { Client } from 'ssh2'
+import type { LinuxServer } from '../../../shared/types.ts'
+import type { ActionExecutor } from '../registry.ts'
+
+const DEFAULT_TIMEOUT_MS = 120_000
+
+interface SshOutcome {
+  code: number | null
+  stdout: string
+  stderr: string
+  error?: string
+}
+
+/** 通过 SSH 在远端执行一条命令，返回退出码与输出 */
+function execRemote(
+  server: LinuxServer,
+  command: string,
+  timeoutMs: number,
+  onOutput?: (stream: 'stdout' | 'stderr', text: string) => void
+): Promise<SshOutcome> {
+  return new Promise((resolve) => {
+    let stdout = ''
+    let stderr = ''
+    let done = false
+
+    const conn = new Client()
+
+    const finish = (r: SshOutcome): void => {
+      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: number) => {
+              finish({ code, stdout, stderr })
+            })
+            .on('data', (chunk: Buffer) => {
+              const text = chunk.toString()
+              stdout += text
+              try {
+                onOutput?.('stdout', text)
+              } catch {
+                /* 回调异常不影响执行 */
+              }
+            })
+          stream.stderr.on('data', (chunk: Buffer) => {
+            const text = chunk.toString()
+            stderr += text
+            try {
+              onOutput?.('stderr', text)
+            } catch {
+              /* 回调异常不影响执行 */
+            }
+          })
+        })
+      })
+      .on('error', (err: Error) => {
+        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: ActionExecutor = 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 ?? []) as LinuxServer[]
+  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/server/plugins/actions/task-chain.ts

@@ -0,0 +1,30 @@
+/**
+ * 任务链动作 — 触发其他任务执行（方案 §3.3.E: task_chain）
+ */
+import type { ActionResult } from '../../../shared/types.ts'
+import type { ActionExecutor } from '../registry.ts'
+
+export const taskChainAction: ActionExecutor = async (task, ctx): Promise<ActionResult> => {
+  const raw = task.config.actionParams?.['taskIds']
+  let ids: string[] = []
+  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: string[] = []
+  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/server/plugins/actions/volume-control.ts

@@ -0,0 +1,35 @@
+/**
+ * 音量控制动作 — macOS osascript（调节音量/静音切换）
+ */
+import { execFile } from 'node:child_process'
+import type { ActionResult, TaskRecord } from '../../../shared/types.ts'
+import type { ActionExecutor } from '../registry.ts'
+
+function runOsa(script: string): Promise<ActionResult> {
+  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: ActionExecutor = async (task: TaskRecord): Promise<ActionResult> => {
+  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/server/plugins/index.ts

@@ -0,0 +1,37 @@
+/**
+ * 注册全部内置动作
+ */
+import { clearClipboardAction, lockScreenAction, openTrashAction, refreshDesktopAction } from './actions/builtin.ts'
+import { clipboardWatchAction } from './actions/clipboard-watch.ts'
+import { httpRequestAction } from './actions/http-request.ts'
+import { jenkinsBuildAction } from './actions/jenkins-build.ts'
+import { openAppAction } from './actions/open-app.ts'
+import { pythonScriptAction } from './actions/python-script.ts'
+import { screenshotAction } from './actions/screenshot.ts'
+import { sendKeystrokeAction } from './actions/send-keystroke.ts'
+import { showReminderAction } from './actions/show-reminder.ts'
+import { sshCommandAction } from './actions/ssh-command.ts'
+import { taskChainAction } from './actions/task-chain.ts'
+import { volumeControlAction } from './actions/volume-control.ts'
+import type { ActionRegistry } from './registry.ts'
+
+/** 全部内置动作注册 */
+export function registerBuiltinActions(registry: ActionRegistry): void {
+  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/server/plugins/registry.ts

@@ -0,0 +1,72 @@
+/**
+ * 动作插件注册表 — 任务动作可插拔
+ * 参考 dsh "万物皆插件"：新动作 = 注册一个 executor，不改核心代码
+ */
+import type { ActionResult, Reminder, TaskRecord } from '../../shared/types.ts'
+import type { ConfigStore } from '../services/config-store.ts'
+import type { ScriptRunner } from '../services/script-runner.ts'
+
+/** 动作可用的通知能力（结构化接口，便于测试替身） */
+export interface SchedulerNotifier {
+  /** 系统原生通知 */
+  notify(title: string, body: string): void
+  /** 任务提醒（气泡/全屏闪烁） */
+  showReminder(reminder: Reminder): void
+  /** 微信推送（M4 接入） */
+  sendWechat(text: string): void
+}
+
+/** 动作执行上下文 */
+export interface ActionContext {
+  scriptRunner: ScriptRunner
+  notifier: SchedulerNotifier
+  config: ConfigStore
+  /** 注册运行中脚本句柄（供任务停止功能终止） */
+  trackRunningScript?: (taskId: string, handle: { kill: () => void } | null) => void
+  /** 触发其他任务（task_chain 动作） */
+  requestRun?: (taskId: string, source?: string) => boolean
+  /** 武装剪贴板监听（clipboard_watch 动作） */
+  armClipboardWatch?: (rule: { pattern: string; targetTaskId: string; passValueAsArg?: boolean }) => void
+  /** 逐行日志（写入执行记录） */
+  log: (msg: string) => void
+  /** 实时输出（流式推送到管理台，不必等脚本结束） */
+  onOutput?: (stream: 'stdout' | 'stderr', text: string) => void
+  /**
+   * 子进程启动后回传 pid（由调度器落库到执行记录）。
+   *
+   * 用途：服务被强杀 / 重启后，子进程仍可能活着（Windows 上父进程退出不会带走它），
+   * 启动恢复时靠这个 pid 判断脚本是不是还在后台跑，而不是一律判成「执行被中断」。
+   */
+  onChildPid?: (pid: number) => void
+}
+
+export type ActionExecutor = (task: TaskRecord, ctx: ActionContext) => Promise<ActionResult>
+
+export class ActionRegistry {
+  private actions = new Map<string, ActionExecutor>()
+
+  register(name: string, executor: ActionExecutor): void {
+    this.actions.set(name, executor)
+  }
+
+  get(name: string): ActionExecutor | null {
+    return this.actions.get(name) ?? null
+  }
+
+  has(name: string): boolean {
+    return this.actions.has(name)
+  }
+
+  list(): string[] {
+    return [...this.actions.keys()]
+  }
+
+  /** 执行动作；未注册的动作返回失败 */
+  async execute(task: TaskRecord, ctx: ActionContext): Promise<ActionResult> {
+    const executor = this.actions.get(task.config.action)
+    if (!executor) {
+      return { success: false, error: `未知任务动作: ${task.config.action}` }
+    }
+    return executor(task, ctx)
+  }
+}

package/server/services/clipboard-watcher.ts

@@ -0,0 +1,126 @@
+/**
+ * 剪贴板监听 — 捕获到指定格式内容后触发任务（方案 §3.3.E: clipboard_watch）
+ *
+ * 语义：任务执行「剪贴板监听」动作 = 武装一个一次性监视器；
+ * 轮询系统剪贴板，文本命中正则后以匹配值为参数触发目标任务并自动解除。
+ */
+import { EventEmitter } from 'node:events'
+import { readClipboardText } from '../utils/clipboard.ts'
+
+export interface ClipboardWatchRule {
+  /** 匹配模式（正则字符串），如快递单号 SF\\d{13,} */
+  pattern: string
+  /** 命中后触发的任务 id */
+  targetTaskId: string
+  /** 以匹配值作为脚本参数传给目标任务（仅 python_script 生效） */
+  passValueAsArg?: boolean
+}
+
+export class ClipboardWatchRegistry extends EventEmitter {
+  private timer: ReturnType<typeof setInterval> | null = null
+  private lastValue = ''
+  private rules: ClipboardWatchRule[] = []
+  private readClipboard: () => string | Promise<string>
+  /** 读取中标记：剪贴板读取为异步命令，避免轮询重叠 */
+  private busy = false
+
+  constructor(readClipboard: () => string | Promise<string> = async () => readClipboardText()) {
+    super()
+    this.readClipboard = readClipboard
+  }
+
+  get armedCount(): number {
+    return this.rules.length
+  }
+
+  /** 武装一条监听规则（重复 pattern+target 会去重） */
+  arm(rule: ClipboardWatchRule): void {
+    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?: string, targetTaskId?: string): number {
+    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(): ClipboardWatchRule[] {
+    return [...this.rules]
+  }
+
+  private start(): void {
+    if (this.timer) return
+    void this.read().then((v) => {
+      this.lastValue = v
+    })
+    this.timer = setInterval(() => {
+      void this.tick()
+    }, 1500)
+    this.timer.unref?.()
+  }
+
+  private async read(): Promise<string> {
+    try {
+      return await this.readClipboard()
+    } catch {
+      return ''
+    }
+  }
+
+  stop(): void {
+    if (this.timer) clearInterval(this.timer)
+    this.timer = null
+  }
+
+  shutdown(): void {
+    this.rules = []
+    this.stop()
+  }
+
+  private async tick(): Promise<void> {
+    if (this.busy) return
+    this.busy = true
+    try {
+      await this.doTick()
+    } finally {
+      this.busy = false
+    }
+  }
+
+  private async doTick(): Promise<void> {
+    const value = await this.read()
+    if (!value || value === this.lastValue) return
+    this.lastValue = value
+
+    for (const rule of [...this.rules]) {
+      let matched: string | null = 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()
+  }
+}

package/server/services/config-store.ts

@@ -0,0 +1,152 @@
+/**
+ * 配置存储 — 轻量 JSON 持久化（对应旧版 ConfigStore + electron-store 职责）
+ * 文件: userData/config/settings.json
+ */
+import { EventEmitter } from 'events'
+import { existsSync, readFileSync, writeFileSync } from 'fs'
+import { join } from 'path'
+import type { Settings } from '../../shared/types.ts'
+import { ensureDir, getConfigDir } from '../utils/paths.ts'
+
+export const DEFAULT_SETTINGS: 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<T>(base: T, patch: unknown): T {
+  if (patch === null || typeof patch !== 'object' || Array.isArray(patch)) {
+    return (patch === undefined ? base : (patch as T))
+  }
+  const out: Record<string, unknown> = { ...(base as Record<string, unknown>) }
+  for (const [k, v] of Object.entries(patch as Record<string, unknown>)) {
+    const baseV = (base as Record<string, unknown>)[k]
+    out[k] = typeof v === 'object' && v !== null && !Array.isArray(v) && baseV
+      ? deepMerge(baseV, v)
+      : v
+  }
+  return out as T
+}
+
+export class ConfigStore extends EventEmitter {
+  private settings: Settings
+  private filePath: string
+
+  constructor(filePath?: string) {
+    super()
+    this.filePath = filePath ?? join(getConfigDir(), 'settings.json')
+    this.settings = this.load()
+  }
+
+  private load(): Settings {
+    try {
+      if (existsSync(this.filePath)) {
+        const raw = JSON.parse(readFileSync(this.filePath, 'utf-8')) as Partial<Settings>
+        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(): Settings
+  /** 获取设置项（支持点路径，如 "window.x"） */
+  get(key: string): unknown
+  get(key?: string): unknown {
+    if (key) {
+      const keys = key.split('.')
+      let cur: unknown = this.settings
+      for (const k of keys) {
+        if (cur && typeof cur === 'object' && k in (cur as Record<string, unknown>)) {
+          cur = (cur as Record<string, unknown>)[k]
+        } else {
+          return undefined
+        }
+      }
+      return structuredClone(cur)
+    }
+    return structuredClone(this.settings)
+  }
+
+  set(key: string, value: unknown): void {
+    const keys = key.split('.')
+    let cur: Record<string, unknown> = this.settings as unknown as Record<string, unknown>
+    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] as Record<string, unknown>
+    }
+    cur[keys[keys.length - 1]] = value
+    this.save()
+    this.emit('changed')
+  }
+
+  update(patch: Partial<Settings>): void {
+    this.settings = deepMerge(this.settings, patch)
+    this.save()
+    this.emit('changed')
+  }
+
+  /** 整体替换设置（快照恢复 / 配置包导入用） */
+  replaceAll(settings: Settings): void {
+    this.settings = deepMerge(structuredClone(DEFAULT_SETTINGS), settings)
+    this.save()
+    this.emit('changed')
+  }
+
+  save(): void {
+    try {
+      ensureDir(getConfigDir())
+      writeFileSync(this.filePath, JSON.stringify(this.settings, null, 2), 'utf-8')
+    } catch (err) {
+      console.error('[config] 保存配置失败:', err)
+    }
+  }
+}
+
+export function deepMergeConfig<T>(base: T, patch: unknown): T {
+  return deepMerge(base, patch)
+}