@wanghaopeng1148/deskpet 2.0.1 → 2.0.3

package/dist/node/shared/py-task-params.js

@@ -0,0 +1,335 @@
+/**
+ * 解析 Python 脚本中的 TASK_PARAMS 常量 → 任务表单动态参数控件
+ *
+ * 对齐旧版 pet/src/ui/task_panel.py 的 `_parse_task_params`：
+ *   - 只做**字面量解析**（不执行脚本），仅支持 dict / list / str / number / bool / None
+ *   - 找不到 TASK_PARAMS 或解析失败 → 返回 null（表单回退到自由文本参数）
+ *
+ * 脚本内声明示例：
+ *   TASK_PARAMS = [
+ *     {"name": "--env", "label": "环境", "type": "select",
+ *      "options": [{"value": "uat", "label": "UAT"}]},
+ *     {"name": "--services", "label": "服务", "type": "multiselect",
+ *      "options": [{"value": "biz", "label": "biz"}]},
+ *     {"name": "--view", "label": "视图", "type": "text", "placeholder": "如 Y26M11"},
+ *   ]
+ */
+/** 截取 `TASK_PARAMS = <字面量>` 的字面量源码（到配对括号结束） */
+function extractTaskParamsSource(source) {
+    const m = /(^|\n)[ \t]*TASK_PARAMS\s*=\s*/.exec(source);
+    if (!m)
+        return null;
+    const start = m.index + m[0].length;
+    const end = scanBalanced(source, start);
+    return end === null ? null : source.slice(start, end);
+}
+/** 从 start 处的 `[` / `{` 起，返回配对括号的结束位置（不含） */
+function scanBalanced(s, start) {
+    let i = start;
+    while (i < s.length && /\s/.test(s[i]))
+        i++;
+    const open = s[i];
+    if (open !== '[' && open !== '{')
+        return null;
+    const stack = [];
+    let inStr = null;
+    for (; i < s.length; i++) {
+        const ch = s[i];
+        if (inStr) {
+            if (ch === '\\') {
+                i++;
+                continue;
+            }
+            if (ch === inStr)
+                inStr = null;
+            continue;
+        }
+        if (ch === '#') {
+            while (i < s.length && s[i] !== '\n')
+                i++;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            inStr = ch;
+            continue;
+        }
+        if (ch === '[' || ch === '{')
+            stack.push(ch);
+        else if (ch === ']' || ch === '}') {
+            stack.pop();
+            if (stack.length === 0)
+                return i + 1;
+        }
+    }
+    return null;
+}
+/** Python 字面量递归下降解析器（受限子集） */
+class PyLiteralParser {
+    i = 0;
+    src;
+    constructor(src) {
+        this.src = src;
+    }
+    parse() {
+        const v = this.value();
+        this.skipWs();
+        if (this.i < this.src.length) {
+            throw new Error(`存在多余内容: ${this.src.slice(this.i, this.i + 20)}`);
+        }
+        return v;
+    }
+    skipWs() {
+        for (;;) {
+            while (this.i < this.src.length && /\s/.test(this.src[this.i]))
+                this.i++;
+            if (this.src[this.i] === '#') {
+                while (this.i < this.src.length && this.src[this.i] !== '\n')
+                    this.i++;
+                continue;
+            }
+            break;
+        }
+    }
+    value() {
+        this.skipWs();
+        const ch = this.src[this.i];
+        if (ch === '[')
+            return this.list();
+        if (ch === '{')
+            return this.dict();
+        if (ch === '"' || ch === "'")
+            return this.string();
+        if (ch && /[A-Za-z_]/.test(ch)) {
+            const word = this.ident();
+            // 字符串前缀 r'' / b'' / u'' / f''（f-string 不支持）
+            const nxt = this.src[this.i];
+            if (nxt === '"' || nxt === "'") {
+                if (word === 'f' || word === 'F')
+                    throw new Error('不支持 f-string');
+                return this.string();
+            }
+            if (word === 'True')
+                return true;
+            if (word === 'False')
+                return false;
+            if (word === 'None')
+                return null;
+            throw new Error(`不支持的标识符: ${word}`);
+        }
+        return this.number();
+    }
+    list() {
+        const out = [];
+        this.i++;
+        this.skipWs();
+        if (this.src[this.i] === ']') {
+            this.i++;
+            return out;
+        }
+        for (;;) {
+            out.push(this.value());
+            this.skipWs();
+            const ch = this.src[this.i];
+            if (ch === ',') {
+                this.i++;
+                this.skipWs();
+                if (this.src[this.i] === ']') {
+                    this.i++;
+                    break;
+                }
+                continue;
+            }
+            if (ch === ']') {
+                this.i++;
+                break;
+            }
+            throw new Error('列表格式错误');
+        }
+        return out;
+    }
+    dict() {
+        const out = {};
+        this.i++;
+        this.skipWs();
+        if (this.src[this.i] === '}') {
+            this.i++;
+            return out;
+        }
+        for (;;) {
+            this.skipWs();
+            const key = this.value();
+            this.skipWs();
+            if (this.src[this.i] !== ':')
+                throw new Error('字典缺少冒号');
+            this.i++;
+            out[String(key)] = this.value();
+            this.skipWs();
+            const ch = this.src[this.i];
+            if (ch === ',') {
+                this.i++;
+                this.skipWs();
+                if (this.src[this.i] === '}') {
+                    this.i++;
+                    break;
+                }
+                continue;
+            }
+            if (ch === '}') {
+                this.i++;
+                break;
+            }
+            throw new Error('字典格式错误');
+        }
+        return out;
+    }
+    string() {
+        const quote = this.src[this.i];
+        this.i++;
+        let out = '';
+        while (this.i < this.src.length) {
+            const ch = this.src[this.i];
+            if (ch === '\\') {
+                const next = this.src[this.i + 1];
+                this.i += 2;
+                switch (next) {
+                    case 'n':
+                        out += '\n';
+                        break;
+                    case 't':
+                        out += '\t';
+                        break;
+                    case 'r':
+                        out += '\r';
+                        break;
+                    case '\\':
+                        out += '\\';
+                        break;
+                    case "'":
+                        out += "'";
+                        break;
+                    case '"':
+                        out += '"';
+                        break;
+                    case 'u': {
+                        const hex = this.src.slice(this.i, this.i + 4);
+                        if (/^[0-9a-fA-F]{4}$/.test(hex)) {
+                            out += String.fromCharCode(parseInt(hex, 16));
+                            this.i += 4;
+                        }
+                        break;
+                    }
+                    default:
+                        out += next ?? '';
+                }
+                continue;
+            }
+            if (ch === quote) {
+                this.i++;
+                return out;
+            }
+            out += ch;
+            this.i++;
+        }
+        throw new Error('字符串未闭合');
+    }
+    ident() {
+        const m = /^[A-Za-z_][A-Za-z0-9_]*/.exec(this.src.slice(this.i));
+        if (!m)
+            throw new Error('标识符格式错误');
+        this.i += m[0].length;
+        return m[0];
+    }
+    number() {
+        const m = /^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?/.exec(this.src.slice(this.i));
+        if (!m || !m[0])
+            throw new Error(`无法解析的值: ${this.src.slice(this.i, this.i + 12)}`);
+        this.i += m[0].length;
+        return Number(m[0]);
+    }
+}
+/** 解析脚本源码中的 TASK_PARAMS；无该常量或解析失败返回 null */
+export function parseTaskParams(source) {
+    if (!source)
+        return null;
+    try {
+        const literal = extractTaskParamsSource(source);
+        if (!literal)
+            return null;
+        const parsed = new PyLiteralParser(literal).parse();
+        if (!Array.isArray(parsed))
+            return null;
+        const out = [];
+        for (const raw of parsed) {
+            if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+                continue;
+            const r = raw;
+            const name = String(r['name'] ?? '').trim();
+            if (!name)
+                continue;
+            const rawType = String(r['type'] ?? 'text');
+            const type = rawType === 'select' || rawType === 'multiselect' ? rawType : 'text';
+            const options = Array.isArray(r['options'])
+                ? r['options']
+                    .map((o) => {
+                    const oo = (o ?? {});
+                    return {
+                        value: String(oo['value'] ?? ''),
+                        label: oo['label'] != null ? String(oo['label']) : undefined
+                    };
+                })
+                    .filter((o) => o.value !== '')
+                : undefined;
+            out.push({
+                name,
+                label: r['label'] != null ? String(r['label']) : undefined,
+                type,
+                required: r['required'] === true,
+                placeholder: r['placeholder'] != null ? String(r['placeholder']) : undefined,
+                help: r['help'] != null ? String(r['help']) : undefined,
+                options
+            });
+        }
+        return out.length ? out : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** 从已有脚本参数回填动态表单（对齐旧版 _restore_params_from_args） */
+export function restoreParamState(params, args) {
+    const values = {};
+    const consumed = new Set();
+    for (const p of params) {
+        const idx = args.indexOf(p.name);
+        if (idx === -1 || idx + 1 >= args.length)
+            continue;
+        const next = args[idx + 1];
+        if (next.startsWith('--'))
+            continue;
+        consumed.add(idx);
+        consumed.add(idx + 1);
+        values[p.name] =
+            p.type === 'multiselect' ? next.split(',').map((s) => s.trim()).filter(Boolean) : next;
+    }
+    const extra = args.filter((_, i) => !consumed.has(i));
+    return { values, extra };
+}
+/** 由动态表单值生成脚本参数（对齐旧版 _collect_params_as_args） */
+export function buildArgsFromParams(params, values, extra = []) {
+    const args = [];
+    for (const p of params) {
+        const v = values[p.name];
+        if (p.type === 'multiselect') {
+            const arr = Array.isArray(v) ? v : [];
+            if (arr.length)
+                args.push(p.name, arr.join(','));
+        }
+        else {
+            const s = typeof v === 'string' ? v.trim() : '';
+            if (s)
+                args.push(p.name, s);
+        }
+    }
+    args.push(...extra);
+    return args;
+}

package/dist/node/shared/types.js

@@ -0,0 +1,69 @@
+/**
+ * 共享类型定义 — 主进程 / 渲染进程 / 预加载共用
+ */
+/**
+ * 宠物状态（值越大优先级越高，与旧版 Python 一致）
+ * 使用 const 对象 + 联合类型（兼容 Node 原生 TS strip-only 模式）
+ */
+export const PetState = {
+    SLEEP: 0,
+    IDLE: 1,
+    HOVER: 2,
+    BUSY: 3,
+    CLICK: 4
+};
+export const PET_STATE_NAMES = [
+    'sleep',
+    'idle',
+    'hover',
+    'click',
+    'busy'
+];
+export function petStateName(state) {
+    switch (state) {
+        case PetState.SLEEP:
+            return 'sleep';
+        case PetState.IDLE:
+            return 'idle';
+        case PetState.HOVER:
+            return 'hover';
+        case PetState.BUSY:
+            return 'busy';
+        case PetState.CLICK:
+            return 'click';
+        default:
+            return 'idle';
+    }
+}
+/** 点击互动动画类型（轮流触发） */
+export const ClickAnimationType = {
+    JUMP: 'jump',
+    SQUASH: 'squash',
+    SHAKE: 'shake'
+};
+// ── 任务系统 (M2) ─────────────────────────────────────────────
+export const TaskType = {
+    MANUAL: 'manual', // 手动
+    SCHEDULED: 'scheduled', // 定时
+    SCENE: 'scene' // 场景触发
+};
+export const TaskStatus = {
+    IDLE: 'idle',
+    PENDING: 'pending',
+    RUNNING: 'running',
+    COMPLETED: 'completed',
+    FAILED: 'failed',
+    CANCELLED: 'cancelled',
+    DISABLED: 'disabled'
+};
+export const ScheduleType = {
+    ONCE: 'once',
+    CRON: 'cron',
+    DELAY: 'delay',
+    INTERVAL: 'interval'
+};
+export const SceneTrigger = {
+    IDLE: 'idle',
+    STARTUP: 'startup',
+    NETWORK: 'network'
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@wanghaopeng1148/deskpet",
   "productName": "DeskPet",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "DeskPet 2.0 — 本机任务自动化服务 + Web 管理台 (Node + Express + Vue 3 + TypeScript)",
   "type": "module",
   "author": "whp",
@@ -16,6 +16,7 @@
     "bin",
     "server",
     "shared",
+    "dist/node",
     "dist/web",
     "resources",
     "README.md"
@@ -28,8 +29,11 @@
     "dev:watch": "node scripts/dev-all.mjs --watch",
     "dev:server": "node --experimental-strip-types --watch server/main.ts",
     "dev:web": "vite",
-    "build": "vite build",
+    "build": "npm run build:web && npm run build:server",
     "build:web": "vite build",
+    "build:server": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run build:server",
+    "verify:package": "node scripts/verify-package.mjs",
     "start": "node scripts/start.mjs",
     "serve": "node --experimental-strip-types server/main.ts",
     "release": "node scripts/publish.mjs",

package/server/http/http-server.ts

@@ -26,7 +26,7 @@ import { testJenkinsConnection, testSshConnection } from '../services/remote-con
 import type { ClipboardWatchRegistry } from '../services/clipboard-watcher.ts'
 import { resolveAssetRequest } from '../utils/asset-url.ts'
 import { detectPythonInterpreters } from '../utils/python-interpreter.ts'
-import { moduleDir } from '../utils/paths.ts'
+import { getPackageRoot, moduleDir } from '../utils/paths.ts'
 import type { WsHub } from './ws-hub.ts'
 
 export interface HttpServerDeps {
@@ -714,6 +714,9 @@ function clampInt(v: unknown, min: number, max: number): number {
 /** 静态资源根目录：优先 vite 构建产物 dist/web，兼容旧路径 out/renderer */
 function resolveStaticRoot(): string | null {
   const candidates = [
+    // 用包根定位，源码运行与编译产物（dist/node/...）都适用；
+    // moduleDir() 的相对层级只在源码形态下成立，不能单独依赖
+    join(getPackageRoot(), 'dist/web'),
     join(moduleDir(), '../../dist/web'),
     join(moduleDir(), '../renderer'),
     join(process.cwd(), 'dist/web')

package/server/main.ts

@@ -239,12 +239,16 @@ async function main(): Promise<void> {
   scheduler.start({ recover: instanceLock.acquired })
 
   // 开机自启：启动时应用 + 跟随设置变化
+  // removeWhenOff: false —— 启动时的同步只「确保开启时文件存在」，不删除。
+  // 否则一个用默认配置（autoStart=false）起来的实例（例如临时跑一次 npx，
+  // 或换了 DESKPET_HOME）会把主实例写在同一个启动文件夹里的自启文件删掉。
   let lastAutoStart = config.get().system.autoStart
-  void setAutoStart(lastAutoStart)
+  void setAutoStart(lastAutoStart, { removeWhenOff: false })
   config.on('changed', () => {
     const next = config.get().system.autoStart
     if (next !== lastAutoStart) {
       lastAutoStart = next
+      // 用户在设置页显式切换 → 关闭时应当真的移除文件
       void setAutoStart(next)
     }
   })

package/server/utils/auto-start.ts

@@ -22,14 +22,21 @@
  */
 import { existsSync, mkdirSync, unlinkSync, writeFileSync } from 'node:fs'
 import { homedir } from 'node:os'
-import { dirname, join, resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
+import { dirname, join } from 'node:path'
+import { getPackageRoot } from './paths.ts'
 
 const APP_ID = 'DeskPet'
 
-/** 应用根目录（源码运行为项目根，npm 包运行为包根） */
+/**
+ * 应用根目录。
+ *
+ * 用 getPackageRoot() 向上查找 package.json，而不是写死 `../..`：
+ * 源码运行时本模块在 `server/utils/`，编译产物在 `dist/node/server/utils/`，
+ * 距包根的层数不同 —— 写死层级会让**从 npm 安装版开启自启**生成一个指向
+ * 不存在路径的启动脚本（开机静默失败）。
+ */
 function appRoot(): string {
-  return resolve(dirname(fileURLToPath(import.meta.url)), '..', '..')
+  return getPackageRoot()
 }
 
 /** 开机要执行的 node 可执行文件与入口脚本 */
@@ -123,8 +130,22 @@ function linuxDesktopContent(): string {
 
 // ── 对外接口 ────────────────────────────────────────────────
 
+export interface AutoStartOptions {
+  /**
+   * 配置为「关闭」时是否删除自启文件（默认 true）。
+   *
+   * 启动时的同步必须传 false：多个实例可能共用同一个启动文件夹，
+   * 一个以默认配置（autoStart=false）起来的实例不该把别人的自启文件删掉。
+   * 这个坑很隐蔽 —— 临时跑一次 `npx deskpet`（数据目录是全新的默认配置）
+   * 就会把主实例的开机自启悄悄弄没，之后每次开机都得手动启动。
+   * 关闭自启只应由「设置页里显式关掉开关」这个动作来执行。
+   */
+  removeWhenOff?: boolean
+}
+
 /** 开启 / 关闭开机自启，返回是否成功（失败原因会打印到日志） */
-export async function setAutoStart(on: boolean): Promise<boolean> {
+export async function setAutoStart(on: boolean, opts: AutoStartOptions = {}): Promise<boolean> {
+  const removeWhenOff = opts.removeWhenOff ?? true
   try {
     if (process.platform === 'win32') {
       const dir = winStartupDir()
@@ -145,7 +166,7 @@ export async function setAutoStart(on: boolean): Promise<boolean> {
       if (on) {
         writeFileSync(file, winCmdContent(), 'utf-8')
         console.log(`[autostart] 开机自启已开启: ${file}`)
-      } else if (existsSync(file)) {
+      } else if (removeWhenOff && existsSync(file)) {
         unlinkSync(file)
         console.log('[autostart] 开机自启已关闭')
       }
@@ -158,7 +179,7 @@ export async function setAutoStart(on: boolean): Promise<boolean> {
         mkdirSync(dirname(file), { recursive: true })
         writeFileSync(file, macPlistContent(), 'utf-8')
         console.log(`[autostart] 开机自启已开启: ${file}`)
-      } else if (existsSync(file)) {
+      } else if (removeWhenOff && existsSync(file)) {
         unlinkSync(file)
         console.log('[autostart] 开机自启已关闭')
       }
@@ -171,7 +192,7 @@ export async function setAutoStart(on: boolean): Promise<boolean> {
         mkdirSync(dirname(file), { recursive: true })
         writeFileSync(file, linuxDesktopContent(), 'utf-8')
         console.log(`[autostart] 开机自启已开启: ${file}`)
-      } else if (existsSync(file)) {
+      } else if (removeWhenOff && existsSync(file)) {
         unlinkSync(file)
         console.log('[autostart] 开机自启已关闭')
       }

package/server/utils/paths.ts

@@ -23,6 +23,33 @@ export function moduleDir(): string {
 
 const MODULE_DIR = moduleDir()
 
+/**
+ * 包根目录（含 package.json 的那一层）。
+ *
+ * 为什么不写死相对层级：源码运行时本模块在 `server/utils/`，
+ * 而发布产物在 `dist/node/server/utils/` —— 两者距包根的层数不同，
+ * 任何 `../../xxx` 形式的假设都会在编译后失效（曾导致 resources 与 dist/web 定位不到）。
+ * 这里改为从模块目录向上查找 package.json，源码形态与产物形态都能正确定位。
+ */
+function findPackageRoot(): string {
+  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(): string {
+  return PACKAGE_ROOT
+}
+
 /** 数据根目录（配置/数据库/皮肤/快照） */
 export function getDataRoot(): string {
   const env = process.env.DESKPET_HOME
@@ -34,7 +61,7 @@ export function getDataRoot(): string {
 export function getResourcesRoot(): string {
   const env = process.env.DESKPET_RESOURCES
   if (env && env.trim()) return resolve(env.trim())
-  return resolve(MODULE_DIR, '../../resources')
+  return join(PACKAGE_ROOT, 'resources')
 }
 
 /** 用户配置目录 */