@wanghaopeng1148/deskpet 2.0.0 → 2.0.2

package/dist/node/server/services/script-runner.js

@@ -0,0 +1,228 @@
+/**
+ * 脚本运行器 — Python 脚本执行封装（child_process.spawn）
+ * 对齐旧版 script_runner.py + process_manager.py 语义
+ * 支持启动后手动中止（任务停止功能）
+ */
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+/** stdout/stderr 截断上限（方案文档: 保留最后 10KB） */
+export const OUTPUT_LIMIT = 10 * 1024;
+/**
+ * 终止整个进程树。
+ *
+ * 为什么不能只 `child.kill()`：脚本自己还会派生进程（ssh、kubectl 之类），
+ * 只杀直接子进程会留下残余；Windows 上更彻底 —— 父进程被强杀时子进程根本不会跟着死。
+ *
+ * 两步走的原因：`taskkill` 能按 PPID 回收整棵树，但它是**外部命令**，
+ * 在受管控的机器上可能被策略禁用，所以后面必须再补一次原生 `process.kill()` 兜底 ——
+ * 否则一旦 taskkill 不可用，就变成「以为杀了其实没杀」。
+ */
+export function killProcessTree(pid) {
+    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 孤儿进程。
+     */
+    active = new Map();
+    /** 当前运行中的脚本数 */
+    get runningCount() {
+        return this.active.size;
+    }
+    /**
+     * 启动脚本执行（可中止）
+     */
+    start(config) {
+        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 = null;
+        let timedOut = false;
+        let killed = false;
+        let settled = false;
+        let timer = null;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            this.active.delete(key);
+            resolve(result);
+        };
+        let resolve;
+        const result = new Promise((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) => {
+            const text = chunk.toString();
+            stdout = appendLimited(stdout, text, OUTPUT_LIMIT);
+            try {
+                config.onOutput?.('stdout', text);
+            }
+            catch {
+                /* 回调异常不影响执行 */
+            }
+        });
+        child.stderr?.on('data', (chunk) => {
+            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) {
+        return this.start(config).result;
+    }
+    /**
+     * 中止所有运行中脚本（应用退出时）。
+     *
+     * 必须**真的**终止进程树。旧实现只清空了集合，注释里那句
+     * 「子进程随主进程退出」在 Windows 上并不成立 —— 父进程退出后 python 会继续跑，
+     * 于是每次重启都留下一批孤儿脚本（对部署类脚本尤其危险：用户以为失败了，
+     * 脚本其实还在改远端状态）。
+     */
+    killAll() {
+        for (const child of this.active.values()) {
+            if (child?.pid)
+                killProcessTree(child.pid);
+        }
+        this.active.clear();
+    }
+}
+function appendLimited(current, addition, limit) {
+    const next = current + addition;
+    if (next.length <= limit)
+        return next;
+    return next.slice(-limit);
+}
+function clampInt(v, min, max, fallback) {
+    if (!Number.isFinite(v))
+        return fallback;
+    return Math.max(min, Math.min(max, Math.round(v)));
+}

package/dist/node/server/services/snapshot-service.js

@@ -0,0 +1,135 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+const AUTO_KEEP = 20;
+const PACK_MAGIC = 'DESKPET-PACK';
+export class SnapshotService {
+    db;
+    source;
+    constructor(db, source) {
+        this.db = db;
+        this.source = source;
+    }
+    /** 创建快照；auto=true 时只保留最近 20 份自动快照 */
+    snapshot(reason = 'manual') {
+        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;
+    }
+    pruneAuto(keep) {
+        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) {
+        const rows = this.db
+            .prepare('SELECT id, created_at, reason, data FROM snapshots ORDER BY id DESC LIMIT ?')
+            .all(limit);
+        return rows.map((r) => ({
+            id: Number(r.id),
+            createdAt: r.created_at,
+            reason: r.reason ?? 'manual',
+            taskCount: safeTaskCount(r.data)
+        }));
+    }
+    get(id) {
+        const row = this.db.prepare('SELECT * FROM snapshots WHERE id = ?').get(id);
+        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)
+        };
+    }
+    remove(id) {
+        const r = this.db.prepare('DELETE FROM snapshots WHERE id = ?').run(id);
+        return Number(r.changes) > 0;
+    }
+    /** 恢复快照 */
+    restore(id) {
+        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) {
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        const pack = {
+            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() {
+        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) {
+        let pack;
+        try {
+            pack = JSON.parse(jsonText);
+        }
+        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 };
+    }
+}
+function safeTaskCount(dataJson) {
+    try {
+        const d = JSON.parse(dataJson);
+        return Array.isArray(d.tasks) ? d.tasks.length : 0;
+    }
+    catch {
+        return 0;
+    }
+}