@wanghaopeng1148/deskpet 2.0.0

package/server/services/script-runner.ts

@@ -0,0 +1,263 @@
+/**
+ * 脚本运行器 — Python 脚本执行封装（child_process.spawn）
+ * 对齐旧版 script_runner.py + process_manager.py 语义
+ * 支持启动后手动中止（任务停止功能）
+ */
+import { spawn } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import type { ScriptResult } from '../../shared/types.ts'
+
+export interface ScriptConfig {
+  scriptPath: string
+  /** Python 解释器路径，默认 python3 */
+  interpreter?: string | null
+  /** 传给解释器本身的前置参数（如 cmd 包装），会排在脚本路径之前 */
+  interpreterArgs?: string[] | null
+  args?: string[]
+  /** 超时秒数 10~1800，默认 120 */
+  timeout?: number
+  workDir?: string | null
+  env?: Record<string, string> | null
+  /** 实时输出回调：每收到一段 stdout/stderr 立即触发（供管理台流式查看） */
+  onOutput?: ((stream: 'stdout' | 'stderr', text: string) => void) | null
+}
+
+/** stdout/stderr 截断上限（方案文档: 保留最后 10KB） */
+export const OUTPUT_LIMIT = 10 * 1024
+
+export interface RunningScript {
+  /** 等待执行结果 */
+  result: Promise<ScriptResult>
+  /** 强制终止（连同其派生的子进程） */
+  kill: () => void
+  /** 是否已结束 */
+  settled: () => boolean
+  /**
+   * 子进程 pid（启动失败 / 脚本文件不存在时为 null）。
+   * 调用方会把它落库，供服务重启后判断「脚本是否还在后台跑」。
+   */
+  pid: number | null
+}
+
+/**
+ * 终止整个进程树。
+ *
+ * 为什么不能只 `child.kill()`：脚本自己还会派生进程（ssh、kubectl 之类），
+ * 只杀直接子进程会留下残余；Windows 上更彻底 —— 父进程被强杀时子进程根本不会跟着死。
+ *
+ * 两步走的原因：`taskkill` 能按 PPID 回收整棵树，但它是**外部命令**，
+ * 在受管控的机器上可能被策略禁用，所以后面必须再补一次原生 `process.kill()` 兜底 ——
+ * 否则一旦 taskkill 不可用，就变成「以为杀了其实没杀」。
+ */
+export function killProcessTree(pid: number): void {
+  if (process.platform === 'win32') {
+    try {
+      spawn('taskkill', ['/pid', String(pid), '/T', '/F'], {
+        windowsHide: true,
+        stdio: 'ignore'
+      })
+    } catch {
+      /* taskkill 不可用时靠下面的原生调用兜底 */
+    }
+  }
+  try {
+    // 原生强制终止：不依赖任何外部命令，保证主进程一定被干掉
+    process.kill(pid, 'SIGKILL')
+  } catch {
+    /* 进程可能已经退出，忽略 */
+  }
+}
+
+export class ScriptRunner {
+  /**
+   * 运行中的脚本：key → 子进程。
+   *
+   * 用 Map 而不是 Set 保存**进程引用**，是为了让 killAll() 能真正终止它们 ——
+   * 旧实现只 clear() 了集合，注释里「子进程随主进程退出」在 Windows 上并不成立，
+   * 于是每次重启都会留下一批继续在后台跑的 python 孤儿进程。
+   */
+  private active = new Map<string, ReturnType<typeof spawn> | null>()
+
+  /** 当前运行中的脚本数 */
+  get runningCount(): number {
+    return this.active.size
+  }
+
+  /**
+   * 启动脚本执行（可中止）
+   */
+  start(config: ScriptConfig): RunningScript {
+    const interpreter = config.interpreter ?? (process.platform === 'win32' ? 'python' : 'python3')
+    const args = [...(config.interpreterArgs ?? []), config.scriptPath, ...(config.args ?? [])]
+    const timeoutS = clampInt(config.timeout ?? 120, 10, 1800, 120)
+    const startedAt = Date.now()
+
+    const key = `${interpreter}|${config.scriptPath}|${startedAt}`
+    // 先占位：spawn 之前也保证 runningCount / killAll 能看到这次执行，
+    // 真正拿到子进程引用后再补上（见下方 spawn 成功处）。
+    this.active.set(key, null)
+
+    let child: ReturnType<typeof spawn> | null = null
+    let timedOut = false
+    let killed = false
+    let settled = false
+    let timer: ReturnType<typeof setTimeout> | null = null
+
+    const finish = (result: ScriptResult): void => {
+      if (settled) return
+      settled = true
+      if (timer) clearTimeout(timer)
+      this.active.delete(key)
+      resolve(result)
+    }
+
+    let resolve!: (r: ScriptResult) => void
+    const result = new Promise<ScriptResult>((res) => {
+      resolve = res
+    })
+
+    // 脚本文件不存在则直接失败
+    if (!existsSync(config.scriptPath)) {
+      finish({
+        success: false,
+        exitCode: null,
+        stdout: '',
+        stderr: '',
+        elapsedMs: 0,
+        timedOut: false,
+        errorMessage: `脚本文件不存在: ${config.scriptPath}`
+      })
+      return { result, kill: () => {}, settled: () => settled, pid: null }
+    }
+
+    let stdout = ''
+    let stderr = ''
+
+    try {
+      child = spawn(interpreter, args, {
+        cwd: config.workDir ?? undefined,
+        env: config.env ? { ...process.env, ...config.env } : process.env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true
+      })
+    } catch (err) {
+      finish({
+        success: false,
+        exitCode: null,
+        stdout: '',
+        stderr: '',
+        elapsedMs: Date.now() - startedAt,
+        timedOut: false,
+        errorMessage: `启动失败: ${String(err)}`
+      })
+      return { result, kill: () => {}, settled: () => settled, pid: null }
+    }
+
+    // spawn 成功：补上进程引用，这样 killAll() / kill() 才能真的终止它
+    this.active.set(key, child)
+
+    timer = setTimeout(() => {
+      timedOut = true
+      // 超时同样要杀整棵树，否则脚本派生的 ssh / kubectl 会留成孤儿
+      if (child?.pid) killProcessTree(child.pid)
+    }, timeoutS * 1000)
+
+    child.stdout?.on('data', (chunk: Buffer) => {
+      const text = chunk.toString()
+      stdout = appendLimited(stdout, text, OUTPUT_LIMIT)
+      try {
+        config.onOutput?.('stdout', text)
+      } catch {
+        /* 回调异常不影响执行 */
+      }
+    })
+    child.stderr?.on('data', (chunk: Buffer) => {
+      const text = chunk.toString()
+      stderr = appendLimited(stderr, text, OUTPUT_LIMIT)
+      try {
+        config.onOutput?.('stderr', text)
+      } catch {
+        /* 回调异常不影响执行 */
+      }
+    })
+    child.on('error', (err) => {
+      finish({
+        success: false,
+        exitCode: null,
+        stdout,
+        stderr,
+        elapsedMs: Date.now() - startedAt,
+        timedOut,
+        errorMessage: `进程错误: ${err.message}`
+      })
+    })
+    child.on('close', (code, signal) => {
+      const elapsedMs = Date.now() - startedAt
+      let errorMessage = ''
+      if (timedOut) {
+        errorMessage = `脚本执行超时 (>${timeoutS}s)`
+      } else if (killed) {
+        errorMessage = '脚本已被手动终止'
+      } else if (code !== 0) {
+        errorMessage = `脚本异常退出 (exit_code=${code ?? signal ?? '?'}), stderr: ${stderr.slice(0, 200)}`
+        // Windows 特有：解释器/命令不存在（含落到了 Microsoft Store 的 python 别名存根）
+        if (code === 9009) {
+          errorMessage +=
+            ' —— 解释器不可用：系统未找到该命令。请到任务「解释器」填写可用的解释器（如 python）或完整路径'
+        } else if (code === -4058) {
+          errorMessage += ' —— 解释器路径不存在，请检查任务「解释器」配置'
+        }
+      }
+      finish({
+        success: !timedOut && !killed && code === 0,
+        exitCode: code,
+        stdout,
+        stderr,
+        elapsedMs,
+        timedOut,
+        errorMessage
+      })
+    })
+
+    return {
+      result,
+      pid: child?.pid ?? null,
+      kill: () => {
+        killed = true
+        if (child?.pid) killProcessTree(child.pid)
+      },
+      settled: () => settled
+    }
+  }
+
+  /** 便捷执行（一次，无重试） */
+  execute(config: ScriptConfig): Promise<ScriptResult> {
+    return this.start(config).result
+  }
+
+  /**
+   * 中止所有运行中脚本（应用退出时）。
+   *
+   * 必须**真的**终止进程树。旧实现只清空了集合，注释里那句
+   * 「子进程随主进程退出」在 Windows 上并不成立 —— 父进程退出后 python 会继续跑，
+   * 于是每次重启都留下一批孤儿脚本（对部署类脚本尤其危险：用户以为失败了，
+   * 脚本其实还在改远端状态）。
+   */
+  killAll(): void {
+    for (const child of this.active.values()) {
+      if (child?.pid) killProcessTree(child.pid)
+    }
+    this.active.clear()
+  }
+}
+
+function appendLimited(current: string, addition: string, limit: number): string {
+  const next = current + addition
+  if (next.length <= limit) return next
+  return next.slice(-limit)
+}
+
+function clampInt(v: number, min: number, max: number, fallback: number): number {
+  if (!Number.isFinite(v)) return fallback
+  return Math.max(min, Math.min(max, Math.round(v)))
+}

package/server/services/snapshot-service.ts

@@ -0,0 +1,196 @@
+/**
+ * 配置快照与备份 — 方案 §3.3.G
+ *
+ *  - 每次配置变更自动快照（保留 20 份，手动快照不占额度）
+ *  - 一键导出 .deskpet 配置包（设置 + 任务 + 快捷指令）
+ *  - 一键导入恢复 / 跨设备迁移
+ */
+import { DatabaseSync } from 'node:sqlite'
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import type { Settings, TaskConfig } from '../../shared/types.ts'
+
+const AUTO_KEEP = 20
+const PACK_MAGIC = 'DESKPET-PACK'
+
+export interface SnapshotMeta {
+  id: number
+  createdAt: string
+  reason: string
+  /** 概要: 任务数等 */
+  taskCount: number
+}
+
+/** .deskpet 配置包结构（JSON） */
+export interface DeskpetPack {
+  magic: typeof PACK_MAGIC
+  version: number
+  exportedAt: string
+  settings: Settings
+  tasks: Array<{ id: string; config: TaskConfig }>
+  quickActions: unknown
+}
+
+interface SnapshotRow {
+  id: number
+  created_at: string
+  reason: string | null
+  data: string
+}
+
+export interface SnapshotSource {
+  getSettings(): Settings
+  listTasks(): Array<{ id: string; config: TaskConfig }>
+  getQuickActions(): unknown
+  /** 恢复回调：按快照内容应用（settings/tasks/quickActions） */
+  apply(data: { settings: Settings; tasks: Array<{ id: string; config: TaskConfig }>; quickActions: unknown }): void
+}
+
+export class SnapshotService {
+  private db: DatabaseSync
+  private source: SnapshotSource
+
+  constructor(db: DatabaseSync, source: SnapshotSource) {
+    this.db = db
+    this.source = source
+  }
+
+  /** 创建快照；auto=true 时只保留最近 20 份自动快照 */
+  snapshot(reason: 'manual' | 'auto' = 'manual'): number {
+    const data = JSON.stringify({
+      settings: this.source.getSettings(),
+      tasks: this.source.listTasks(),
+      quickActions: this.source.getQuickActions()
+    })
+    const result = this.db
+      .prepare('INSERT INTO snapshots (created_at, reason, data) VALUES (?, ?, ?)')
+      .run(new Date().toISOString(), reason, data)
+    const id = Number(result.lastInsertRowid)
+
+    if (reason === 'auto') {
+      this.pruneAuto(AUTO_KEEP)
+    }
+    return id
+  }
+
+  private pruneAuto(keep: number): void {
+    this.db
+      .prepare(
+        `DELETE FROM snapshots WHERE reason = 'auto' AND id NOT IN (
+           SELECT id FROM snapshots WHERE reason = 'auto' ORDER BY id DESC LIMIT ?
+         )`
+      )
+      .run(keep)
+  }
+
+  list(limit = 50): SnapshotMeta[] {
+    const rows = this.db
+      .prepare('SELECT id, created_at, reason, data FROM snapshots ORDER BY id DESC LIMIT ?')
+      .all(limit) as unknown as SnapshotRow[]
+    return rows.map((r) => ({
+      id: Number(r.id),
+      createdAt: r.created_at,
+      reason: r.reason ?? 'manual',
+      taskCount: safeTaskCount(r.data)
+    }))
+  }
+
+  get(id: number): { meta: SnapshotMeta; data: PackData } | null {
+    const row = this.db.prepare('SELECT * FROM snapshots WHERE id = ?').get(id) as
+      | SnapshotRow
+      | undefined
+    if (!row) return null
+    return {
+      meta: {
+        id: Number(row.id),
+        createdAt: row.created_at,
+        reason: row.reason ?? 'manual',
+        taskCount: safeTaskCount(row.data)
+      },
+      data: JSON.parse(row.data) as PackData
+    }
+  }
+
+  remove(id: number): boolean {
+    const r = this.db.prepare('DELETE FROM snapshots WHERE id = ?').run(id)
+    return Number(r.changes) > 0
+  }
+
+  /** 恢复快照 */
+  restore(id: number): boolean {
+    const snap = this.get(id)
+    if (!snap) return false
+    // 恢复前先做一份当前状态的手动快照兜底
+    this.snapshot('manual')
+    this.source.apply({
+      settings: snap.data.settings,
+      tasks: snap.data.tasks ?? [],
+      quickActions: snap.data.quickActions ?? null
+    })
+    return true
+  }
+
+  /** 导出 .deskpet 配置包到指定目录，返回文件路径 */
+  exportPack(dir: string): string {
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
+    const pack: DeskpetPack = {
+      magic: PACK_MAGIC,
+      version: 1,
+      exportedAt: new Date().toISOString(),
+      settings: this.source.getSettings(),
+      tasks: this.source.listTasks(),
+      quickActions: this.source.getQuickActions()
+    }
+    const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19)
+    const filePath = join(dir, `deskpet-backup-${ts}.deskpet`)
+    writeFileSync(filePath, JSON.stringify(pack, null, 2), 'utf-8')
+    return filePath
+  }
+
+  /** 导出为内存对象（HTTP 下载用） */
+  exportPackData(): DeskpetPack {
+    return {
+      magic: PACK_MAGIC,
+      version: 1,
+      exportedAt: new Date().toISOString(),
+      settings: this.source.getSettings(),
+      tasks: this.source.listTasks(),
+      quickActions: this.source.getQuickActions()
+    }
+  }
+
+  /** 导入配置包（JSON 字符串），成功返回任务数量 */
+  importPack(jsonText: string): { ok: boolean; message: string; taskCount?: number } {
+    let pack: DeskpetPack
+    try {
+      pack = JSON.parse(jsonText) as DeskpetPack
+    } catch (err) {
+      return { ok: false, message: `解析失败: ${String(err)}` }
+    }
+    if (pack.magic !== PACK_MAGIC) {
+      return { ok: false, message: '不是有效的 .deskpet 配置包' }
+    }
+    this.snapshot('manual') // 导入前兜底
+    this.source.apply({
+      settings: pack.settings,
+      tasks: pack.tasks ?? [],
+      quickActions: pack.quickActions ?? null
+    })
+    return { ok: true, message: '导入完成', taskCount: (pack.tasks ?? []).length }
+  }
+}
+
+interface PackData {
+  settings: Settings
+  tasks?: Array<{ id: string; config: TaskConfig }>
+  quickActions?: unknown
+}
+
+function safeTaskCount(dataJson: string): number {
+  try {
+    const d = JSON.parse(dataJson) as { tasks?: unknown[] }
+    return Array.isArray(d.tasks) ? d.tasks.length : 0
+  } catch {
+    return 0
+  }
+}