ygc-dsh-plugin-autoupdate 1.0.0 → 1.1.1

package/lib/restart.js

@@ -35,6 +35,7 @@ import os from 'node:os';
 import { spawn, execFileSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { rootSameExePid } from './pidtree.js';
+import { resolveNodeInterpreter } from './runtime-locator.js';
 
 const HELPER = fileURLToPath(new URL('./restart-helper.js', import.meta.url));
 const STATE_DIR = path.join(os.homedir(), '.dsh', 'storages', 'plugin-autoupdate');
@@ -76,6 +77,12 @@ export const LAUNCH_ENV = [
   'PATH',
   'DSH_HOME',
   'DSH_PROFILE',
+  'DSH_PROFILE_DIR',
+  'DSH_INSTALL_DIR',
+  // 下面两个决定新宿主去哪个目录找运行时载荷。WMI 不继承调用方环境，
+  // 漏传的话新宿主还得自己再解析一遍 —— 布局再变就可能找不到。
+  'DSH_RUNTIME_ROOT',
+  'DSH_PRIMARY_RUNTIME',
   'DSH_DESKTOP_NODE_EXECUTABLE',
   'TEMP',
   'TMP',
@@ -113,28 +120,24 @@ const isFile = (p) => {
  *
  * @returns {{exe: string, kind: string, needsRunAsNode: boolean}}
  */
-export function helperExecutable() {
-  const self = process.execPath;
-  // 跑在真 node 里（CLI、测试、开发）—— 直接就用它
-  if (!process.versions.electron) return { exe: self, kind: 'node-self', needsRunAsNode: false };
-  if (typeof self !== 'string' || !self) return { exe: self, kind: 'unknown', needsRunAsNode: true };
-
-  const installDir = path.dirname(self);
-  const candidates = [
-    path.join(installDir, 'resources', 'runtime', 'primary-runtime', 'dependencies', 'node', 'bin', 'node.exe'),
-    path.join(installDir, 'resources', 'runtime', 'primary-runtime', 'dependencies', 'node', 'node.exe'),
-    path.join(installDir, 'runtime', 'primary-runtime', 'dependencies', 'node', 'bin', 'node.exe'),
-  ];
-  for (const candidate of candidates) {
-    if (isFile(candidate)) return { exe: candidate, kind: 'bundled-node', needsRunAsNode: false };
-  }
-
-  const hinted = process.env.DSH_DESKTOP_NODE_EXECUTABLE;
-  if (typeof hinted === 'string' && /node(\.exe)?$/i.test(hinted) && isFile(hinted)) {
-    return { exe: hinted, kind: 'env-node', needsRunAsNode: false };
-  }
-
-  return { exe: self, kind: 'electron-as-node', needsRunAsNode: true };
+export function helperExecutable(options = {}) {
+  // 解释器选择交给 runtime-locator：认载荷标记（runtime.json），不认目录长相。
+  // 1.0.0 及以前把 resources/runtime/primary-runtime 写死在这里；桌面版把载荷搬到
+  // $DSH_HOME/dsh-runtimes/ 后三条候选全 miss，每次都退化成 electron-as-node：
+  // 助手顶着宿主 exe 的名字跑，任何按映像名的清场都能顺手打死它。
+  const picked = resolveNodeInterpreter({
+    desktop: options.desktop,
+    env: options.env,
+    execPath: options.execPath,
+    runtime: options.runtime,
+  });
+  return {
+    exe: picked.exe,
+    kind: picked.kind,
+    needsRunAsNode: picked.needsRunAsNode,
+    runtimeRoot: picked.runtime && picked.runtime.found ? picked.runtime.root : undefined,
+    runtimeSource: picked.runtime ? picked.runtime.source : 'none',
+  };
 }
 
 export function appendRestartLog(message) {

package/lib/runtime-locator.js

@@ -0,0 +1,326 @@
+/**
+ * runtime-locator.js -- 定位 DSH 的运行时载荷（node / pnpm / python）。
+ *
+ * == 为什么要有它 ==
+ * 桌面版升级后，运行时载荷搬了家：
+ *
+ *   旧：<install>/resources/runtime/primary-runtime/
+ *   新：$DSH_HOME/dsh-runtimes/dsh-primary-runtime/
+ *
+ * 关键细节：resources/runtime/ 这个目录**还在，只是空的**。按「目录存在」判断
+ * 会一路走到 ENOENT，而不是干净地落到下一个候选。
+ *
+ * == 判据不是路径，是载荷自己的契约 ==
+ * 宿主把载荷定义成「带 runtime.json 与 dependencies/ 的目录」（见 app.asar 里
+ * dsh-tool-workspace-dependencies 的配置说明：source/root 两个字段都以它为准）。
+ * 所以这里只认两件事：
+ *
+ *   1. 目录里有 runtime.json          -- 强证据，宿主自己也只认这个；
+ *   2. 目录里有 dependencies/node/... -- 弱证据，兜底。
+ *
+ * 目录叫 primary-runtime 还是 secondary-runtime、挂在 resources 下还是
+ * dsh-runtimes 下，都不重要。下次再搬家，只要契约还在，这个文件不用改。
+ *
+ * == 解析顺序（先问宿主，再猜路径）==
+ *   env:DSH_RUNTIME_ROOT > env:DSH_PRIMARY_RUNTIME
+ *   > $DSH_HOME/dsh-runtimes/<name>（含 glob 扫描，认标记不认名字）
+ *   > $DSH_HOME/runtime/<name>
+ *   > <install>/resources/runtime/<name>   （旧布局，保留）
+ *   > <install>/runtime/<name>
+ *   > 进程参数里出现的载荷路径
+ * 全都不中 -> 明确降级，并把 tried 列表交回去，绝不静默。
+ *
+ * 零依赖，import 无副作用，可在 Electron 主进程、Host、纯 node、测试里跑。
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+export const LOCATOR_VERSION = '1.0.0';
+
+/** node 可执行文件在载荷内的相对位置，按平台通用性排序。 */
+const NODE_TAILS = [
+  ['dependencies', 'node', 'bin', 'node.exe'],
+  ['dependencies', 'node', 'bin', 'node'],
+  ['dependencies', 'node', 'node.exe'],
+  ['dependencies', 'node', 'node'],
+];
+
+/** pnpm 入口在载荷内的相对位置。 */
+const PNPM_TAILS = [
+  ['dependencies', 'pnpm', 'bin', 'pnpm.mjs'],
+  ['dependencies', 'pnpm', 'bin', 'pnpm.cjs'],
+  ['dependencies', 'pnpm', 'dist', 'pnpm.mjs'],
+];
+
+/** python 可执行文件在载荷内的相对位置。 */
+const PYTHON_TAILS = [
+  ['dependencies', 'python', 'python.exe'],
+  ['dependencies', 'python', 'bin', 'python3'],
+  ['dependencies', 'python', 'bin', 'python'],
+];
+
+function statOf(target) {
+  try {
+    return fs.statSync(target);
+  } catch {
+    return undefined;
+  }
+}
+
+function isFile(target) {
+  const info = statOf(target);
+  return Boolean(info && info.isFile() && info.size > 0);
+}
+
+function isDir(target) {
+  const info = statOf(target);
+  return Boolean(info && info.isDirectory());
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return undefined;
+  }
+}
+
+function listDirs(dir) {
+  try {
+    return fs
+      .readdirSync(dir, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => path.join(dir, entry.name))
+      .sort();
+  } catch {
+    return [];
+  }
+}
+
+function firstExisting(root, tails) {
+  for (const tail of tails) {
+    const candidate = path.join(root, ...tail);
+    if (isFile(candidate)) return candidate;
+  }
+  return undefined;
+}
+
+/** DSH 主目录：优先 DSH_HOME，其次 ~/.dsh。 */
+export function dshHome(env = process.env) {
+  const fromEnv = typeof env.DSH_HOME === 'string' ? env.DSH_HOME.trim() : '';
+  return fromEnv ? path.resolve(fromEnv) : path.join(os.homedir(), '.dsh');
+}
+
+/**
+ * 从若干种子路径反推安装根。
+ *
+ * 判据：某一层祖先里存在 resources/app.asar（文件）、resources/app（目录）
+ * 或 resources/runtime（目录，旧布局就算空了也算）。
+ */
+export function installRootsFrom(seeds) {
+  const roots = [];
+  for (const seed of seeds) {
+    if (typeof seed !== 'string' || !seed) continue;
+    let current = path.resolve(seed);
+    if (!isDir(current)) current = path.dirname(current);
+    for (let depth = 0; depth < 8; depth += 1) {
+      const hit =
+        isFile(path.join(current, 'resources', 'app.asar')) ||
+        isDir(path.join(current, 'resources', 'app')) ||
+        isDir(path.join(current, 'resources', 'runtime'));
+      if (hit) {
+        if (!roots.includes(current)) roots.push(current);
+        break;
+      }
+      const parent = path.dirname(current);
+      if (parent === current) break;
+      current = parent;
+    }
+  }
+  return roots;
+}
+
+/** 从一条进程参数里抽出可能的载荷根（.../dsh-runtimes/<name> 或 .../runtime/<name>）。 */
+function rootFromArg(arg) {
+  if (typeof arg !== 'string') return undefined;
+  const flat = arg.replace(/\\/g, '/');
+  const match = /^(.*\/(?:dsh-runtimes|runtime)\/[^/]+)(\/|$)/.exec(flat);
+  return match ? match[1].replace(/\//g, path.sep) : undefined;
+}
+
+/**
+ * 候选载荷根，按可信度排序，附带来源标签。
+ *
+ * @param {{env?: object, home?: string, argv?: string[], execPath?: string}} options
+ * @returns {{root: string, source: string}[]}
+ */
+export function candidateRoots(options = {}) {
+  const env = options.env ?? process.env;
+  const home = options.home ?? dshHome(env);
+  const argv = options.argv ?? process.argv;
+  const execPath = options.execPath ?? process.execPath;
+
+  const out = [];
+  const push = (root, source) => {
+    if (typeof root !== 'string' || !root) return;
+    const resolved = path.resolve(root);
+    if (out.some((item) => item.root === resolved)) return;
+    out.push({ root: resolved, source });
+  };
+
+  // 1) 显式覆盖：宿主自己就是这么告诉插件的
+  push(env.DSH_RUNTIME_ROOT, 'env:DSH_RUNTIME_ROOT');
+  push(env.DSH_PRIMARY_RUNTIME, 'env:DSH_PRIMARY_RUNTIME');
+
+  // 2) 当前官方布局：$DSH_HOME/dsh-runtimes/<name>
+  push(path.join(home, 'dsh-runtimes', 'dsh-primary-runtime'), 'home:dsh-runtimes/dsh-primary-runtime');
+  for (const dir of listDirs(path.join(home, 'dsh-runtimes'))) push(dir, 'home:dsh-runtimes/*');
+
+  // 3) 更早的家目录布局（保险）
+  push(path.join(home, 'runtime', 'primary-runtime'), 'home:runtime/primary-runtime');
+  for (const dir of listDirs(path.join(home, 'runtime'))) push(dir, 'home:runtime/*');
+
+  // 4) 安装目录内：resources/runtime（旧）与 runtime（更旧）
+  //
+  // 容器目录本身也要进候选。新版桌面把 resources/runtime 留成一个**空目录**，
+  // 只列子目录的话它根本不会出现在 tried 里，排障时看不到「这里是空的」，
+  // 只剩下一个找不到的结论。
+  const installSeeds = [execPath, env.DSH_INSTALL_DIR, env.DSH_APP_ROOT, env.DSH_INSTALL_ROOT].concat(argv);
+  for (const install of installRootsFrom(installSeeds)) {
+    for (const container of [
+      path.join(install, 'resources', 'runtime'),
+      path.join(install, 'runtime'),
+    ]) {
+      push(path.join(container, 'primary-runtime'), 'install:' + path.basename(path.dirname(container)) + '/' + path.basename(container) + '/primary-runtime');
+      push(container, 'install:' + path.basename(path.dirname(container)) + '/' + path.basename(container));
+      for (const dir of listDirs(container)) push(dir, 'install:' + path.basename(path.dirname(container)) + '/' + path.basename(container) + '/*');
+    }
+  }
+
+  // 5) 进程参数里现成的载荷路径（宿主有时直接把 root 传进来）
+  for (const arg of argv) push(rootFromArg(arg), 'argv');
+
+  return out;
+}
+
+/** 这个目录是不是一个运行时载荷。 */
+export function looksLikeRuntimeRoot(root) {
+  if (!root || !isDir(root)) return false;
+  if (isFile(path.join(root, 'runtime.json'))) return true;
+  return Boolean(firstExisting(root, NODE_TAILS));
+}
+
+function inspectRuntimeRoot(root) {
+  if (!looksLikeRuntimeRoot(root)) return undefined;
+  const runtimeJsonPath = path.join(root, 'runtime.json');
+  return {
+    root,
+    runtimeJsonPath: isFile(runtimeJsonPath) ? runtimeJsonPath : undefined,
+    runtimeJson: isFile(runtimeJsonPath) ? readJson(runtimeJsonPath) : undefined,
+    node: firstExisting(root, NODE_TAILS),
+    pnpm: firstExisting(root, PNPM_TAILS),
+    python: firstExisting(root, PYTHON_TAILS),
+  };
+}
+
+function missReason(root) {
+  if (!isDir(root)) return 'missing';
+  if (isDir(root) && listDirs(root).length === 0 && !isFile(path.join(root, 'runtime.json'))) return 'empty-dir';
+  return 'no-runtime.json / no node';
+}
+
+/**
+ * 按顺序试候选，返回第一个像样的载荷。
+ *
+ * @returns {{found: boolean, root?: string, source: string, node?: string,
+ *            pnpm?: string, python?: string, runtimeJson?: object,
+ *            runtimeJsonPath?: string, tried: object[]}}
+ */
+export function resolveRuntime(options = {}) {
+  const tried = [];
+  for (const item of candidateRoots(options)) {
+    const hit = inspectRuntimeRoot(item.root);
+    if (hit) {
+      tried.push({ root: item.root, source: item.source, ok: true, reason: 'runtime.json' });
+      return Object.assign({ found: true, source: item.source }, hit, { tried });
+    }
+    tried.push({ root: item.root, source: item.source, ok: false, reason: missReason(item.root) });
+  }
+  return { found: false, source: 'none', tried };
+}
+
+/**
+ * 挑跑子进程用的 node 解释器。
+ *
+ * 桌面版会注入 DSH_NODE_EXECUTABLE / DSH_DESKTOP_NODE_EXECUTABLE，本机实测
+ * 它们指向 **应用 exe**（DeepSeek Harness.exe），不是 node.exe。直接拿来当
+ * node 跑会启动第二个宿主。所以这里必须验明正身：basename 必须是 node(.exe)。
+ *
+ * @param {{desktop?: boolean, runtime?: object}} options
+ *        desktop -- 是否按桌面宿主处理；默认看 process.versions.electron。
+ *                   测试里显式传 true 才能在纯 node 下走真实分支。
+ */
+export function resolveNodeInterpreter(options = {}) {
+  const env = options.env ?? process.env;
+  const self = options.execPath ?? process.execPath;
+  const desktop = options.desktop !== undefined ? Boolean(options.desktop) : Boolean(process.versions && process.versions.electron);
+  const runtime = options.runtime ?? resolveRuntime(options);
+
+  if (!desktop) return { exe: self, kind: 'node-self', needsRunAsNode: false, runtime };
+  if (runtime.node) return { exe: runtime.node, kind: 'runtime-node', needsRunAsNode: false, runtime };
+
+  for (const key of ['DSH_DESKTOP_NODE_EXECUTABLE', 'DSH_NODE_EXECUTABLE']) {
+    const value = env[key];
+    if (typeof value === 'string' && /^node(\.exe)?$/i.test(path.basename(value)) && isFile(value)) {
+      return { exe: value, kind: 'env:' + key, needsRunAsNode: false, runtime };
+    }
+  }
+
+  // 退路：用宿主 exe 顶着 ELECTRON_RUN_AS_NODE 跑。
+  // 能跑，但助手的映像名和宿主一样，任何按映像名的清场都会顺手打死它。
+  return { exe: self, kind: 'electron-as-node', needsRunAsNode: true, runtime };
+}
+
+/** 找桌面宿主自带的 pnpm 入口。先看进程参数（沿用旧逻辑），再看载荷。 */
+export function resolvePnpm(options = {}) {
+  const argv = options.argv ?? process.argv;
+  for (const value of argv) {
+    if (typeof value !== 'string') continue;
+    if (!/pnpm[\\/](bin[\\/])?pnpm\.mjs$/i.test(value.replace(/\\/g, '/'))) continue;
+    if (!path.isAbsolute(value) || !isFile(value)) continue;
+    const binIndex = argv.findIndex((item) => typeof item === 'string' && /[\\/]runtime[\\/]bin$/i.test(item.replace(/\\/g, '/')));
+    return { pnpm: value, bin: binIndex >= 0 ? argv[binIndex] : undefined, source: 'argv' };
+  }
+
+  const runtime = options.runtime ?? resolveRuntime(options);
+  if (runtime.pnpm) {
+    return {
+      pnpm: runtime.pnpm,
+      bin: runtime.node ? path.dirname(runtime.node) : undefined,
+      source: 'runtime:' + runtime.source,
+    };
+  }
+  return undefined;
+}
+
+/** 一行摘要，写日志/状态工具用。 */
+export function describeRuntime(runtime) {
+  if (!runtime || !runtime.found) {
+    const lines = ['runtime: NOT FOUND'];
+    for (const item of (runtime && runtime.tried) || []) {
+      lines.push('  - ' + item.source + ' -> ' + item.root + ' (' + item.reason + ')');
+    }
+    return lines.join('\n');
+  }
+  const json = runtime.runtimeJson || {};
+  return [
+    'runtime: ' + runtime.root,
+    '  source=' + runtime.source + ' locator=' + LOCATOR_VERSION,
+    '  desktopVersion=' + (json.desktopVersion || '?') + ' node=' + (json.node || '?') + ' pnpm=' + (json.pnpm || '?'),
+    '  node=' + (runtime.node || '-'),
+    '  pnpm=' + (runtime.pnpm || '-'),
+    '  python=' + (runtime.python || '-'),
+  ].join('\n');
+}

package/lib/updater.js

@@ -13,6 +13,7 @@ import path from 'node:path';
 import os from 'node:os';
 import { spawn } from 'node:child_process';
 import { profileDir } from './core.js';
+import { resolveNodeInterpreter, resolvePnpm } from './runtime-locator.js';
 
 const BACKUP_ROOT = path.join(os.homedir(), '.dsh', 'storages', 'plugin-autoupdate', 'backups');
 const BACKUP_KEEP = 20;
@@ -56,6 +57,7 @@ function pruneBackups() {
 
 /** 桌面宿主自带 pnpm 的定位：从 process.argv 里找 `.../pnpm/bin/pnpm.mjs`。 */
 export function locateDesktopPnpm(argv = process.argv) {
+  // 旧路优先：宿主把 pnpm 绝对路径塞进 argv 时最准（连 PATH 该加什么都带上了）。
   for (let i = 0; i < argv.length; i += 1) {
     const value = argv[i];
     if (typeof value !== 'string') continue;
@@ -66,7 +68,10 @@ export function locateDesktopPnpm(argv = process.argv) {
     );
     return { pnpm: value, bin: binIndex >= 0 ? argv[binIndex] : undefined };
   }
-  return undefined;
+
+  // argv 里没有就按载荷找。新布局把 pnpm 放在 $DSH_HOME/dsh-runtimes 下，
+  // 既不进 PATH 也不一定出现在 argv 里；旧实现在这里直接返回 undefined。
+  return resolvePnpm({ argv });
 }
 
 /**
@@ -182,7 +187,12 @@ async function pnpmInstall(spec, log, registry) {
   if (!found) {
     return { ok: false, via: 'none', message: '当前宿主既没有 pluginManager 也定位不到 pnpm，无法自动更新。' };
   }
-  const env = { ...process.env, ELECTRON_RUN_AS_NODE: '1', NO_COLOR: '1' };
+  // 解释器同样换成载荷里的真 node.exe：用 process.execPath（= 应用 exe）顶着
+  // ELECTRON_RUN_AS_NODE 也能跑，但那等于再起一个宿主进程去干 pnpm 的活。
+  const runner = resolveNodeInterpreter({ desktop: true });
+  const env = { ...process.env, NO_COLOR: '1' };
+  if (runner.needsRunAsNode) env.ELECTRON_RUN_AS_NODE = '1';
+  else delete env.ELECTRON_RUN_AS_NODE;
   if (found.bin) {
     const key = Object.keys(env).find((k) => k.toUpperCase() === 'PATH');
     env[key || 'PATH'] = `${found.bin}${path.delimiter}${env[key || 'PATH'] || ''}`;
@@ -190,7 +200,7 @@ async function pnpmInstall(spec, log, registry) {
   const args = ['--expose-internals', found.pnpm, 'add', '--config.minimumReleaseAge=0', spec];
   // 装到哪个源就跟查询用哪个源：查 npmmirror、装 npmjs 会装不到刚发布的版本
   if (registry) args.push(`--registry=${registry}`);
-  const result = await run(process.execPath, args, { cwd: profileDir(), env });
+  const result = await run(runner.exe, args, { cwd: profileDir(), env });
   if (result.code === 0) {
     log?.(`pnpm 安装完成：${spec}`);
     return { ok: true, via: 'pnpm', message: result.output };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ygc-dsh-plugin-autoupdate",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "type": "module",
   "description": "DSH 插件自动更新器：定时检查已装插件的新版本并按策略升级、装完按需重启、可回滚。只管「已装插件的新版本」，插件清单共享已移交 ygc-dsh-sync。",
   "icon": "icon.svg",
@@ -34,7 +34,8 @@
     "lib/uninstall.js",
     "lib/updater.js",
     "locale/*.json",
-    "lib/pidtree.js"
+    "lib/pidtree.js",
+    "lib/runtime-locator.js"
   ],
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
@@ -52,4 +53,4 @@
       ]
     }
   }
-}
+}