@wanghaopeng1148/deskpet 2.0.0 → 2.0.2

package/dist/node/server/utils/instance-guard.js

@@ -0,0 +1,165 @@
+/**
+ * 单实例保护 —— 判定「是否已有另一个 DeskPet 实例正在运行」。
+ *
+ * 为什么不能只靠端口检测（main.ts 的 listen）：
+ *   Node/libuv 在 Windows 上默认给监听套接字设置 SO_REUSEADDR，而 Windows 的
+ *   语义与 Linux 不同 —— 它允许**多个进程同时绑定同一端口且都 listen 成功**
+ *   （Linux 下会直接 EADDRINUSE）。因此「端口占用了就当已有实例」这个假设
+ *   在 Windows 上基本不成立，多个实例可以并存且互不知晓。
+ *
+ * 为什么这件事很要紧：
+ *   每个实例启动都会执行 TaskScheduler 的残留恢复（recoverInterrupted）——
+ *   它把库里所有 running / pending 的任务都当成「上个进程崩溃留下的」，
+ *   复位状态并把未结束的执行记录收尾为中断。若同时有实例正在跑任务，
+ *   新实例这一下就会把对方正在执行的任务掐掉，用户看到的现象是
+ *   「刚点运行不到 1 秒就报：服务重启，执行被中断」，且任务日志一个字节都没产生。
+ *
+ * 判定方式：心跳文件。运行中的实例定期刷新其内容（pid + 时间戳），
+ * 启动时若发现心跳足够新且对应进程真的还活着，就认定已有实例在跑，
+ * 此时必须跳过破坏性的恢复动作。
+ */
+import { closeSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getDataRoot } from "./paths.js";
+/** 心跳刷新间隔 */
+const HEARTBEAT_MS = 5000;
+/** 心跳新鲜期：超过这个时长没刷新，就认为前一个实例已经退出 */
+const STALE_MS = 20000;
+function heartbeatPath() {
+    return join(getDataRoot(), '.deskpet-alive');
+}
+/** 探测进程是否存活（signal 0 只做存在性检查，不真正投递信号） */
+export function isProcessAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function readHeartbeat() {
+    try {
+        const raw = readFileSync(heartbeatPath(), 'utf-8').trim();
+        const [pidText, atText] = raw.split(':');
+        const pid = Number(pidText);
+        const at = Number(atText);
+        if (!Number.isFinite(pid) || !Number.isFinite(at))
+            return null;
+        return { pid, at };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 是否已有「另一个仍在运行」的实例。
+ * 心跳过旧、或其进程已不存在，都视为没有（前一个实例是崩溃/被强杀退出的）。
+ */
+export function anotherInstanceAlive(now = Date.now()) {
+    const hb = readHeartbeat();
+    if (!hb)
+        return false;
+    if (hb.pid === process.pid)
+        return false;
+    if (now - hb.at > STALE_MS)
+        return false;
+    return isProcessAlive(hb.pid);
+}
+/**
+ * 开始为自己打心跳，返回停止函数。
+ * 定时器 unref，不阻止进程退出。
+ */
+export function startHeartbeat() {
+    const beat = () => {
+        try {
+            mkdirSync(getDataRoot(), { recursive: true });
+            writeFileSync(heartbeatPath(), `${process.pid}:${Date.now()}`, 'utf-8');
+        }
+        catch {
+            /* 心跳写失败不能影响主流程 */
+        }
+    };
+    beat();
+    const timer = setInterval(beat, HEARTBEAT_MS);
+    timer.unref?.();
+    return () => clearInterval(timer);
+}
+// ── 单实例锁（原子） ─────────────────────────────────────────
+function lockPath() {
+    return join(getDataRoot(), '.deskpet.lock');
+}
+function readLockPid() {
+    try {
+        const pid = Number(readFileSync(lockPath(), 'utf-8').trim());
+        return Number.isInteger(pid) && pid > 0 ? pid : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 抢占单实例锁。
+ *
+ * 为什么需要它：心跳方案（above）是「先读、再判、后写」三步，天生有竞态 ——
+ * 两个实例几乎同时启动时，双方都可能读到「没有心跳 / 心跳过期」，于是双双认定
+ * 「我是唯一实例」，双双执行破坏性的 recoverInterrupted()，把对方正在跑的任务掐掉。
+ *
+ * 这里改用文件系统的原子操作 `O_EXCL`：整个「检查是否存在 + 创建」是一步完成的，
+ * 不可能两个进程同时成功。拿不到锁时再看锁属主是否还活着：
+ *   · 还活着 → 让位（本次不执行残留恢复）
+ *   · 已死   → 是上次崩溃留下的陈旧锁，抢占重写
+ */
+export function acquireInstanceLock() {
+    const noop = () => { };
+    try {
+        mkdirSync(getDataRoot(), { recursive: true });
+    }
+    catch {
+        return { acquired: true, release: noop }; // 数据目录不可写时不阻断启动
+    }
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        try {
+            // 'wx' = O_CREAT | O_EXCL：文件已存在则抛 EEXIST，检查与创建不可分割
+            const fd = openSync(lockPath(), 'wx');
+            try {
+                writeFileSync(fd, String(process.pid), 'utf-8');
+            }
+            finally {
+                closeSync(fd);
+            }
+            return {
+                acquired: true,
+                release: () => {
+                    try {
+                        rmSync(lockPath(), { force: true });
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                }
+            };
+        }
+        catch (err) {
+            if (err.code !== 'EEXIST') {
+                // 非「已存在」的异常（权限等）：不因锁机制本身挡住服务启动
+                return { acquired: true, release: noop };
+            }
+            const owner = readLockPid();
+            if (owner && owner !== process.pid && isProcessAlive(owner)) {
+                return { acquired: false, release: noop };
+            }
+            // 陈旧锁（属主进程已不存在，或内容损坏）：删掉后重试一次
+            try {
+                rmSync(lockPath(), { force: true });
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+    // 两轮都没抢到 → 说明确实有并发实例在抢，保守让位
+    return { acquired: false, release: noop };
+}

package/dist/node/server/utils/native-notify.js

@@ -0,0 +1,53 @@
+/**
+ * 系统原生通知 — 取代 Electron Notification 模块
+ *
+ * 采用各平台自带命令，尽力而为：失败不影响任务链路，前端另有 WebSocket 通道兜底。
+ *   macOS  : osascript display notification
+ *   Linux  : notify-send
+ *   Windows: PowerShell WinRT Toast（需 Windows PowerShell 5.1）
+ */
+import { execFile } from 'node:child_process';
+function escapeOsascript(s) {
+    return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+function escapePs(s) {
+    return s.replace(/'/g, "''");
+}
+export function notifyNative(title, body) {
+    const t = title.trim() || 'DeskPet';
+    const b = body.trim();
+    try {
+        if (process.platform === 'darwin') {
+            execFile('osascript', ['-e', `display notification "${escapeOsascript(b)}" with title "${escapeOsascript(t)}"`], { timeout: 5000, windowsHide: true }, () => {
+                /* 尽力而为 */
+            });
+            return;
+        }
+        if (process.platform === 'linux') {
+            execFile('notify-send', [t, b], { timeout: 5000 }, () => {
+                /* ignore */
+            });
+            return;
+        }
+        if (process.platform === 'win32') {
+            const script = [
+                '[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null',
+                "[Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom.XmlDocument, ContentType = WindowsRuntime] | Out-Null",
+                "$xml = New-Object Windows.Data.Xml.Dom.XmlDocument",
+                "$xml.LoadXml('<toast><visual><binding template=\"ToastText02\"><text id=\"1\">" +
+                    escapePs(t) +
+                    '</text><text id="2">' +
+                    escapePs(b) +
+                    '</text></binding></visual></toast>\')',
+                '$toast = New-Object Windows.UI.Notifications.ToastNotification $xml',
+                "[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('DeskPet').Show($toast)"
+            ].join('; ');
+            execFile('powershell', ['-NoProfile', '-NonInteractive', '-Command', script], { timeout: 8000, windowsHide: true }, () => {
+                /* ignore */
+            });
+        }
+    }
+    catch {
+        /* ignore */
+    }
+}

package/dist/node/server/utils/open.js

@@ -0,0 +1,37 @@
+/**
+ * 打开外部资源 — 取代 Electron shell 模块
+ *   openPath   → 文件或文件夹（系统默认程序）
+ *   openUrl    → 浏览器
+ *   openApp    → 应用（macOS: open -a / Windows: start / Linux: 直接执行）
+ */
+import { exec } from 'node:child_process';
+function quote(s) {
+    return s.replace(/"/g, '\\"');
+}
+function run(cmd) {
+    return new Promise((resolvePromise) => {
+        exec(cmd, { timeout: 10000, windowsHide: true }, (err) => {
+            resolvePromise(err ? err.message : null);
+        });
+    });
+}
+/** 用系统默认程序打开文件/文件夹；成功返回 null，失败返回错误信息 */
+export async function openPath(target) {
+    if (process.platform === 'darwin')
+        return run(`open "${quote(target)}"`);
+    if (process.platform === 'win32')
+        return run(`start "" "${target.replace(/"/g, '')}"`);
+    return run(`xdg-open "${quote(target)}"`);
+}
+/** 用默认浏览器打开 URL */
+export async function openUrl(url) {
+    return openPath(url);
+}
+/** 打开应用 */
+export async function openApp(app) {
+    if (process.platform === 'darwin')
+        return run(`open -a "${quote(app)}"`);
+    if (process.platform === 'win32')
+        return run(`start "" "${app.replace(/"/g, '')}"`);
+    return run(`"${quote(app)}"`);
+}

package/dist/node/server/utils/paths.js

@@ -0,0 +1,95 @@
+/**
+ * 路径工具 — 资源/配置目录解析
+ *
+ * 数据目录优先级: 环境变量 DESKPET_HOME > ~/.deskpet
+ * 内置资源目录优先级: 环境变量 DESKPET_RESOURCES > <项目根>/resources
+ */
+import { existsSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { dirname, isAbsolute, join, resolve } from 'path';
+import { fileURLToPath } from 'url';
+/**
+ * 当前模块目录（兼容 CJS 打包产物与 ESM 直跑测试）
+ * CJS: __dirname 直接可用；ESM: import.meta.url 转换
+ */
+export function moduleDir() {
+    try {
+        return __dirname;
+    }
+    catch {
+        return dirname(fileURLToPath(import.meta.url));
+    }
+}
+const MODULE_DIR = moduleDir();
+/**
+ * 包根目录（含 package.json 的那一层）。
+ *
+ * 为什么不写死相对层级：源码运行时本模块在 `server/utils/`，
+ * 而发布产物在 `dist/node/server/utils/` —— 两者距包根的层数不同，
+ * 任何 `../../xxx` 形式的假设都会在编译后失效（曾导致 resources 与 dist/web 定位不到）。
+ * 这里改为从模块目录向上查找 package.json，源码形态与产物形态都能正确定位。
+ */
+function findPackageRoot() {
+    let dir = MODULE_DIR;
+    for (let i = 0; i < 8; i += 1) {
+        if (existsSync(join(dir, 'package.json')))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    // 兜底：沿用源码形态的假设（server/utils → 上两级即包根）
+    return resolve(MODULE_DIR, '../..');
+}
+const PACKAGE_ROOT = findPackageRoot();
+/** 包根目录 */
+export function getPackageRoot() {
+    return PACKAGE_ROOT;
+}
+/** 数据根目录（配置/数据库/皮肤/快照） */
+export function getDataRoot() {
+    const env = process.env.DESKPET_HOME;
+    if (env && env.trim())
+        return resolve(env.trim());
+    return join(homedir(), '.deskpet');
+}
+/** 内置资源根目录（resources/，随项目分发） */
+export function getResourcesRoot() {
+    const env = process.env.DESKPET_RESOURCES;
+    if (env && env.trim())
+        return resolve(env.trim());
+    return join(PACKAGE_ROOT, 'resources');
+}
+/** 用户配置目录 */
+export function getConfigDir() {
+    return join(getDataRoot(), 'config');
+}
+/** 用户导入皮肤目录 */
+export function getUserSkinsDir() {
+    return join(getDataRoot(), 'skins');
+}
+/**
+ * 解析皮肤相关路径。
+ * 候选顺序: 绝对路径 → 用户皮肤目录 → 内置资源目录
+ */
+export function resolveAssetPath(relOrAbs) {
+    const candidates = [];
+    if (isAbsolute(relOrAbs)) {
+        candidates.push(relOrAbs);
+    }
+    else {
+        candidates.push(join(getUserSkinsDir(), relOrAbs));
+        candidates.push(join(getResourcesRoot(), relOrAbs));
+    }
+    for (const c of candidates) {
+        if (existsSync(c))
+            return c;
+    }
+    return candidates[0];
+}
+/** 确保目录存在（递归） */
+export function ensureDir(dir) {
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}

package/dist/node/server/utils/python-interpreter.js

@@ -0,0 +1,129 @@
+/**
+ * Python 解释器解析
+ *
+ * 背景（真实故障）：
+ *   Windows 上常常**没有真正的 `python3`**，PATH 里唯一能匹配到的是 Microsoft Store 的
+ *   「应用执行别名」存根 `%LOCALAPPDATA%\Microsoft\WindowsApps\python3.exe`（实际指向
+ *   AppInstallerPythonRedirector.exe）。该存根被非交互式拉起时不会执行任何脚本，
+ *   **直接以退出码 9009 结束，且 stdout/stderr 全空**，表现为：
+ *      脚本异常退出 (exit_code=9009), stderr:
+ *   非常难排查。因此这里统一做解释器解析：
+ *     1) 若任务指定了解释器 → 按名称（搜索 PATH）或绝对路径解析，解析不到就明确报错；
+ *     2) 未指定 → 按平台候选顺序自动探测（Windows 优先 `python`，因为 `python3` 多为 Store 存根）；
+ *     3) 一律**跳过 Store 别名存根**与无法直接启动的 .cmd/.bat；
+ *     4) 返回可执行文件的绝对路径，交给 spawn 使用。
+ */
+import { existsSync, statSync } from 'node:fs';
+import { basename, isAbsolute, join } from 'node:path';
+const IS_WIN = process.platform === 'win32';
+/** Microsoft Store 应用执行别名目录 */
+const STORE_ALIAS_DIR_RE = /[\\/]WindowsApps[\\/]/i;
+/** 自动探测顺序（Windows 优先 python，因为 python3 常只是 Store 存根） */
+export const INTERPRETER_CANDIDATES = IS_WIN
+    ? ['python', 'python3', 'py']
+    : ['python3', 'python', 'py'];
+/** 是否是 Microsoft Store 的 python 别名存根（假的解释器） */
+export function isStoreAlias(p) {
+    return IS_WIN && STORE_ALIAS_DIR_RE.test(p) && /^python/i.test(basename(p));
+}
+function pathDirs() {
+    return (process.env.PATH ?? '')
+        .split(IS_WIN ? ';' : ':')
+        .map((d) => d.trim().replace(/^"(.*)"$/, '$1'))
+        .filter(Boolean);
+}
+function isUsableFile(p) {
+    try {
+        return existsSync(p) && statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/** 把一个解释器名/路径解析为可执行的绝对路径 */
+function resolveOne(raw) {
+    const name = raw.trim();
+    if (!name)
+        return {};
+    const looksLikePath = isAbsolute(name) || /[\\/]/.test(name);
+    const candidates = [];
+    if (looksLikePath) {
+        candidates.push(name);
+        if (IS_WIN && !/\.(exe|cmd|bat)$/i.test(name))
+            candidates.push(`${name}.exe`);
+    }
+    else if (IS_WIN) {
+        for (const dir of pathDirs())
+            candidates.push(join(dir, `${name}.exe`));
+    }
+    else {
+        for (const dir of pathDirs())
+            candidates.push(join(dir, name));
+    }
+    let storeAlias = false;
+    let scriptShim = false;
+    for (const c of candidates) {
+        if (!isUsableFile(c))
+            continue;
+        if (isStoreAlias(c)) {
+            storeAlias = true;
+            continue;
+        }
+        if (IS_WIN && /\.(cmd|bat)$/i.test(c)) {
+            scriptShim = true;
+            continue;
+        }
+        return { command: c };
+    }
+    return { storeAlias, scriptShim };
+}
+/**
+ * 解析 Python 解释器
+ * - 指定了 `preferred` 却解析不到 → 明确报错（不静默回退，避免「以为用了 A 实际用了 B」）
+ * - 未指定 → 按平台候选顺序自动探测
+ */
+export function resolvePythonInterpreter(preferred) {
+    const pref = (preferred ?? '').trim();
+    if (pref) {
+        const r = resolveOne(pref);
+        if (r.command)
+            return { ok: true, interpreter: { command: r.command, name: pref } };
+        return { ok: false, error: `解释器「${pref}」不可用：${describeFailure(pref, r)}` };
+    }
+    for (const name of INTERPRETER_CANDIDATES) {
+        const r = resolveOne(name);
+        if (r.command)
+            return { ok: true, interpreter: { command: r.command, name } };
+    }
+    return {
+        ok: false,
+        error: `未找到可用的 Python 解释器（已尝试：${INTERPRETER_CANDIDATES.join('、')}）。` +
+            '请在任务「解释器」里填写完整路径，例如 C:\\Program Files\\Python312\\python.exe'
+    };
+}
+function describeFailure(name, r) {
+    if (r.storeAlias) {
+        return (`它只匹配到 Microsoft Store 的应用执行别名存根（${IS_WIN ? 'WindowsApps\\' : ''}${name}.exe），` +
+            '不是真正的 Python，被系统直接拒绝执行（退出码 9009）。请改填真实解释器，例如 python');
+    }
+    if (r.scriptShim) {
+        return `它只找到 .cmd/.bat 脚本（无法被直接启动）。请改填对应的 .exe 路径`;
+    }
+    return '未在 PATH 中找到，请确认已安装或填写完整路径';
+}
+/** 探测本机可用的解释器列表（供前端下拉选择） */
+export function detectPythonInterpreters() {
+    const found = [];
+    const seen = new Set();
+    for (const name of INTERPRETER_CANDIDATES) {
+        const r = resolveOne(name);
+        if (!r.command)
+            continue;
+        const key = r.command.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        found.push({ command: r.command, name });
+    }
+    return found;
+}