tmuxclihook 0.5.0 → 0.5.1

package/README.md

@@ -9,9 +9,12 @@
 npm install -g tmuxclihook
 tmuxclihook
 
-# 检查 npm registry 并将全局安装更新到最新版
+# 按当前安装方式（npm/volta）检查并更新到最新版
 tmuxclihook update
 
+# 升级并直接删除不生效的另一份安装（默认会交互确认）
+tmuxclihook update --prune
+
 # hooks 健康明细（非交互）：每个 CLI 的完整性、判定真源、注册路径、漂移警告
 # 可选参数 claude|codex|opencode 只看一个；exit 1 = 有缺失或漂移
 tmuxclihook check
@@ -34,9 +37,11 @@ npm start
 
 hooks 安装、tmux 集成写入的路径由「source」决定：环境变量 `TMUXCLIHOOK_SOURCE` > 持久化配置 `~/.config/tmuxclihook/config.json`（TUI「source 管理」菜单写入）> 包内自带 scripts/（生产默认）> 仓库根 scripts/（`cd installer && npm start` 时的开发回落）。见下方「source 管理」一节。
 
-`tmuxclihook update` 会显示当前版本，通过 `npm view tmuxclihook version` 查询最新版；版本不同时直接执行 `npm install -g tmuxclihook@latest`，版本相同则不做修改。网络查询或安装失败时命令以非零状态退出。
+`tmuxclihook update` 会显示当前版本，通过 `npm view tmuxclihook version` 查询最新版；版本相同则不做修改。需要升级时，它按 PATH 上第一个可执行的 `tmuxclihook` 判断当前生效的安装方式：入口位于 `$VOLTA_HOME/bin/`（默认 `~/.volta/bin/`）或 volta 的 packages 镜像内时，只执行 `volta install tmuxclihook@latest`；其余入口（npm 全局、nvm/fnm 等 node 工具链目录）只执行 `npm install -g tmuxclihook@latest`。不会同时写入两套安装。网络查询或安装失败时命令以非零状态退出。
+
+安装完成后会按 PATH 自检实际生效版本。若生效入口不是 volta、自检仍未反映新版，且本机可执行 volta，则补执行一次 `volta install tmuxclihook@latest` 作为兜底并复检；仍不一致时打印警告（不影响退出码）。
 
-安装成功后会做一次生效自检：按 PATH 解析实际会被运行的 `tmuxclihook`，读取其真实版本与最新版比对。若本机使用 volta，`npm install -g` 只会更新 node 工具链目录里的副本、不会更新 volta 的 shim 镜像（实测 volta 2.0.2：shim npm 的全局 prefix 即工具链目录），自检发现这种情况时会自动补执行 `volta install tmuxclihook@latest` 使更新生效并复检；volta 缺失或修正失败时打警告并提示手动命令。`npm install` 始终是标准安装方式，无需因 volta 改变习惯。
+升级确认成功后，update 会检查另一套安装（volta packages 镜像或当前 npm 全局 prefix）是否还留有副本。发现副本时：TTY 下询问是否删除（默认不删）；非交互环境只打印警告；`--prune` 跳过询问直接删除。删除前会校验该副本未被任何 hooks 与 `~/.tmux.conf` 引用——任一检查无法确认就保留并提示先重装 hooks。**生效入口永远不删**，清理失败不影响升级结果。也可以手动收敛：卸载不再使用的那份（`npm uninstall -g tmuxclihook` 或 `volta uninstall tmuxclihook`），再从生效入口重新安装 hooks。
 
 ## 功能
 

package/bin/cli.js

@@ -491,7 +491,7 @@ async function runCheckCommand(only) {
 
 const arg = process.argv[2];
 if (arg === 'update') {
-  updatePackage().then((ok) => {
+  updatePackage({ prune: process.argv.includes('--prune') }).then((ok) => {
     if (!ok) process.exitCode = 1;
   }).catch((err) => {
     console.error(err);
@@ -511,7 +511,8 @@ if (arg === 'update') {
     '用法：\n' +
     '  tmuxclihook              打开交互式 TUI 安装器\n' +
     '  tmuxclihook check        hooks 健康明细（可跟 claude|codex|opencode；exit 1 = 有缺失或漂移）\n' +
-    '  tmuxclihook update       检查并更新到 npm 最新版本\n' +
+    '  tmuxclihook update       按当前安装方式（npm/volta）检查并更新到最新版本\n' +
+    '  tmuxclihook update --prune  升级后直接删除不生效的另一份安装（默认交互确认）\n' +
     '  tmuxclihook version      显示版本（--version / -v 等价）\n' +
     '  tmuxclihook help         显示本帮助（--help / -h 等价）',
   );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tmuxclihook",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "交互式 TUI 安装器：环境侦测、AI CLI 侦测、tmux-ai-status hooks 装/卸/修、TPM 软链校验",
   "type": "module",
   "bin": {

package/src/update.js

@@ -1,5 +1,6 @@
-import { readFileSync, accessSync, constants as fsConstants, realpathSync } from 'node:fs';
-import { delimiter, dirname, join } from 'node:path';
+import { readFileSync, accessSync, existsSync, constants as fsConstants, realpathSync } from 'node:fs';
+import { basename, delimiter, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { execa } from 'execa';
 
 const PACKAGE_NAME = 'tmuxclihook';
@@ -9,12 +10,13 @@ export const CURRENT_VERSION = packageJson.version;
 
 // —— 生效版本自检 ————————————————————————————————————————————————
 //
-// `npm install -g` 在版本管理器（volta 等）环境下不会更新其管理的 shim：
-// volta 的 `~/.volta/bin` shim 指向 packages/ 镜像，而 npm -g 只写 node
-// 工具链目录，两者互不感知（实测 0.3.0 → 0.3.2 升级时用户命令仍解析到
-// 旧版）。生效收敛由 repairWithVolta 无条件完成（见下）；本节自检只是
-// 事后确认：按 update 进程的 PATH 解析一份，尽力读取真实版本并与
-// registry latest 比对，无法确认或版本不符时打警告。
+// `npm install -g` 在版本管理器（volta 等）环境下只写 node 工具链目录，
+// 不更新 volta 的 shim 镜像（shim 指向 packages/）。因此升级前先按 PATH
+// 上第一个可执行 tmuxclihook 判断「当前生效入口」属于哪套安装机制，只走
+// 对应那一套（见 detectInstallSource / updatePackage），避免同一版本被写
+// 成两份、hooks 指向其中一份而 PATH 命中另一份造成漂移。
+// 本节自检只是事后确认：按 update 进程的 PATH 解析一份，尽力读取真实版本
+// 并与 registry latest 比对，无法确认或版本不符时打警告。
 // 验证是尽力而为的提示，不改变 update 的返回值（install 本身已成功）。
 
 function findOnPath(name, env) {
@@ -31,6 +33,200 @@ function findOnPath(name, env) {
   return null;
 }
 
+// realpath 失败时退回字面绝对路径，保证包含判断仍可进行（不抛）。
+function realOrResolved(p) {
+  if (!p) return null;
+  try {
+    return realpathSync(p);
+  } catch {
+    return resolve(p);
+  }
+}
+
+// child 是否位于 parent 目录内（含相等）。用 relative 而非 startsWith，
+// 避免 `$VOLTA_HOME/bin-other` 被误判为 `$VOLTA_HOME/bin` 的子路径。
+function isPathInside(child, parent) {
+  const rel = relative(parent, child);
+  return rel === '' || (rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel));
+}
+
+const VOLTA_SHIM_NAMES = new Set(['volta-shim', 'volta-shim.exe']);
+
+// 判断 PATH 上第一个可执行的 tmuxclihook 来自哪套安装机制：
+//   'volta'   — $VOLTA_HOME/bin 下的 shim、或 volta packages 镜像
+//   'npm'     — npm 全局 / nvm / fnm 等 node 工具链目录
+//   'unknown' — PATH 上找不到可执行入口
+// 跟随「当前生效入口」是 update 的核心语义：只升级用户实际会执行的那一份。
+export function detectInstallSource(env = process.env) {
+  try {
+    const entry = findOnPath(PACKAGE_NAME, env);
+    if (!entry) return 'unknown';
+
+    const voltaHome = env.VOLTA_HOME || (env.HOME ? join(env.HOME, '.volta') : null);
+    const realEntry = realOrResolved(entry);
+
+    if (voltaHome) {
+      // macOS 的 /var → /private/var 等：原始路径与 canonical 路径都要比对
+      const homes = [voltaHome];
+      const realHome = realOrResolved(voltaHome);
+      if (realHome && realHome !== voltaHome) homes.push(realHome);
+
+      for (const home of homes) {
+        const binDir = join(home, 'bin');
+        const pkgDir = join(home, 'tools', 'image', 'packages', PACKAGE_NAME);
+        for (const candidate of [entry, realEntry]) {
+          if (!candidate) continue;
+          if (isPathInside(candidate, binDir) || isPathInside(candidate, pkgDir)) return 'volta';
+        }
+      }
+    }
+
+    if (realEntry && VOLTA_SHIM_NAMES.has(basename(realEntry))) return 'volta';
+    return 'npm';
+  } catch {
+    return 'unknown';
+  }
+}
+
+// —— 非生效副本检测与可选收敛 ——————————————————————————————————————
+//
+// update 只升级生效入口，不主动动另一套安装。历史遗留的双份副本会让后续
+// 手动交叉升级「升级到不生效的那份」，因此提供可选收敛：只删同时满足以下
+// 条件的副本——不是生效入口、未被 hooks 引用、未被 ~/.tmux.conf 引用、
+// 位于已知标准位置。TTY 下交互确认（默认 No）；--prune 跳过确认；
+// 非交互环境只警告，绝不静默删除。
+
+const TOOL_IDS = ['claude', 'codex', 'opencode'];
+
+function voltaPackagesRoot(env) {
+  const voltaHome = env.VOLTA_HOME || (env.HOME ? join(env.HOME, '.volta') : null);
+  return voltaHome ? join(voltaHome, 'tools', 'image', 'packages', PACKAGE_NAME) : null;
+}
+
+async function readNpmGlobalPrefix(run) {
+  try {
+    const r = await run('npm', ['prefix', '-g']);
+    return (r.stdout || '').trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+// 返回「非生效 + 位于标准位置」的副本。source 为 unknown 时不做任何
+// 检测——找不到生效入口时删除任何一份都可能让用户彻底没有命令。
+export async function detectStaleInstalls(source, env = process.env, run = execa) {
+  if (source === 'unknown') return [];
+
+  const stale = [];
+  if (source === 'npm') {
+    const voltaRoot = voltaPackagesRoot(env);
+    if (voltaRoot && existsSync(voltaRoot)) stale.push({ kind: 'volta', root: voltaRoot });
+  }
+  if (source === 'volta') {
+    const prefix = await readNpmGlobalPrefix(run);
+    const npmRoot = prefix ? join(prefix, 'lib', 'node_modules', PACKAGE_NAME) : null;
+    if (npmRoot && existsSync(npmRoot)) stale.push({ kind: 'npm', root: npmRoot });
+  }
+  return stale;
+}
+
+// hooks 是否引用该副本。走三个 wrapper 的 check --json（与 TUI 同源），
+// 输出里出现目标路径即视为引用。任何异常都按「有引用」处理，宁可不动。
+async function hooksReference(root, env, run) {
+  const scriptsDir = fileURLToPath(new URL('../scripts/', import.meta.url));
+  for (const tool of TOOL_IDS) {
+    const script = join(scriptsDir, `install-${tool}-hooks.sh`);
+    if (!existsSync(script)) continue;
+    try {
+      const r = await run('bash', [script, 'check', '--json'], { env });
+      if ((r.stdout || '').includes(root)) return tool;
+    } catch (err) {
+      if ((err.stdout || '').includes(root)) return tool;
+      return tool;
+    }
+  }
+  return null;
+}
+
+function tmuxConfReferences(root, env) {
+  if (!env.HOME) return true;
+  try {
+    return readFileSync(join(env.HOME, '.tmux.conf'), 'utf8').includes(root);
+  } catch {
+    return false;
+  }
+}
+
+async function uninstallStale(item, run) {
+  try {
+    if (item.kind === 'volta') {
+      await run('volta', ['uninstall', PACKAGE_NAME], { stdio: 'inherit' });
+    } else {
+      await run('npm', ['uninstall', '-g', PACKAGE_NAME], { stdio: 'inherit' });
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// 交互确认的默认实现：读一行，默认 No。测试通过 options.confirm 注入。
+async function defaultConfirm(question) {
+  const { createInterface } = await import('node:readline/promises');
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question(`${question} [y/N] `);
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+
+// 清理非生效副本。返回是否实际删除过任何副本。
+export async function cleanupStale(options) {
+  const {
+    source, env, run, log, prune, isTTY, confirm, checkHooks, checkTmuxConf,
+  } = options;
+
+  const stale = await options.detectStale(source, env, run);
+  if (stale.length === 0) return false;
+
+  let removed = false;
+  for (const item of stale) {
+    const label = `${item.kind} install at ${item.root}`;
+
+    const hookTool = await checkHooks(item.root, env, run);
+    if (hookTool) {
+      log.error(`Not removing ${label}: still referenced by ${hookTool} hooks. Reinstall hooks from the effective entry first.`);
+      continue;
+    }
+    if (checkTmuxConf(item.root, env)) {
+      log.error(`Not removing ${label}: still referenced by ~/.tmux.conf.`);
+      continue;
+    }
+
+    if (!prune) {
+      if (!isTTY) {
+        log.error(`Another install found: ${label}. Run "tmuxclihook update --prune" in a terminal to remove it.`);
+        continue;
+      }
+      const yes = await confirm(`Remove the non-effective ${label}?`);
+      if (!yes) {
+        log.log(`Keeping ${label}.`);
+        continue;
+      }
+    }
+
+    if (await uninstallStale(item, run)) {
+      log.log(`Removed ${label}.`);
+      removed = true;
+    } else {
+      log.error(`Failed to remove ${label}.`);
+    }
+  }
+  return removed;
+}
+
 // npm 布局下入口是 .../lib/node_modules/<pkg>/bin/cli.js（或其 symlink）：
 // realpath 后向上最多 3 层找 name 匹配的 package.json 读版本。版本管理器
 // shim 是独立二进制，向上找不到包 → 返回 null。
@@ -94,14 +290,11 @@ function warnNotEffective(log, result) {
   log.error(`If you use volta, run: volta install ${PACKAGE_NAME}@latest`);
 }
 
-// volta 生效修正：`npm install -g` 只写 node 工具链目录，不更新 volta 的
-// shim 镜像（实测 volta 2.0.2：shim npm 的全局 prefix 就是工具链目录），
-// 用户的命令经 ~/.volta/bin shim 解析时仍是旧版。因此只要检测到 volta
-// 就无条件补一次 volta install 完成生效（幂等，已是最新时秒回）。不走
-// 「自检失败才修」的条件路径：自检按 update 进程自己的 PATH 找第一份，
-// 可能恰好命中 npm -g 刚写的那份而误判 ok（实测 0.3.3 → 0.3.4：verify
-// 判 ok，修复从未触发，用户命令仍是旧版）。npm install -g 是安装语义，
-// volta install 是生效语义，两者都执行；用户无需改变安装习惯。
+// volta 安装路径：当 PATH 上的生效入口来自 volta（shim 或 packages 镜像）
+// 时，升级只能走 `volta install`——`npm install -g` 只写 node 工具链目录，
+// 不会更新 volta 的 packages 镜像。此函数现在是 volta 分支的唯一升级动作，
+// 不再作为 npm 安装后的无条件补丁（双写会制造两份副本并引发漂移）。
+// volta 不可执行时返回 false，由调用方决定如何报告。
 export async function repairWithVolta(run, log, env = process.env) {
   const voltaHome = env.VOLTA_HOME || join(env.HOME || '', '.volta');
   const voltaBin = findOnPath('volta', env) || join(voltaHome, 'bin', 'volta');
@@ -124,9 +317,21 @@ export async function updatePackage(options = {}) {
   const run = options.run || execa;
   const log = options.log || console;
   const currentVersion = options.currentVersion || CURRENT_VERSION;
+  const env = options.env || process.env;
   // 显式传 null 跳过自检/修正（测试用）；默认真实现
   const verify = options.verify === undefined ? verifyEffectiveVersion : options.verify;
   const repairVolta = options.repairVolta === undefined ? repairWithVolta : options.repairVolta;
+  const detectSource = options.detectSource === undefined ? detectInstallSource : options.detectSource;
+  // 非生效副本收敛：默认开启，TTY 下交互确认；--prune 跳过确认。
+  const cleanup = options.cleanup !== false;
+  const prune = options.prune === true;
+  const isTTY = options.isTTY === undefined
+    ? Boolean(process.stdin.isTTY && process.stdout.isTTY)
+    : options.isTTY;
+  const confirm = options.confirm || defaultConfirm;
+  const detectStale = options.detectStale || detectStaleInstalls;
+  const checkHooks = options.checkHooks || hooksReference;
+  const checkTmuxConf = options.checkTmuxConf || tmuxConfReferences;
 
   log.log(`Current version: v${currentVersion}`);
 
@@ -145,28 +350,61 @@ export async function updatePackage(options = {}) {
   }
 
   log.log(`Updating to v${latestVersion}...`);
-  try {
-    await run('npm', ['install', '-g', `${PACKAGE_NAME}@latest`], { stdio: 'inherit' });
-  } catch {
-    return false;
+
+  // 跟随当前生效入口：PATH 上第一个 tmuxclihook 属于哪套机制，就只升级那套。
+  // volta 入口走 volta install（npm -g 写不到 packages 镜像）；其余入口走 npm -g。
+  // 不再双写——那会留下两份同版本副本，配置指向一份而命令执行另一份即产生漂移。
+  const source = typeof detectSource === 'function' ? detectSource(env) : 'unknown';
+
+  if (source === 'volta') {
+    if (repairVolta) {
+      const ok = await repairVolta(run, log, env);
+      if (!ok) {
+        log.error('Failed to update via volta. Please check your volta installation.');
+        return false;
+      }
+    }
+  } else {
+    try {
+      await run('npm', ['install', '-g', `${PACKAGE_NAME}@latest`], { stdio: 'inherit' });
+    } catch {
+      return false;
+    }
   }
 
   log.log(`Done. Updated to v${latestVersion}`);
 
-  // 生效收敛：有 volta 就无条件跑（幂等；无 volta 时静默跳过，纯 npm 场景
-  // npm -g 本身已生效）。任何命令行执行 update 都能升级生效的关键。
-  if (repairVolta) {
-    await repairVolta(run, log);
+  if (!verify) return true;
+
+  // 事后确认（尽力而为）：正常情况下生效入口应已是新版。
+  let result = await verify(latestVersion, env);
+
+  // 兜底：非 volta 来源、自检未过、且本机确有 volta 时补一次并复检。
+  // 仅在异常场景触发（例如 npm 全局 bin 不在 PATH），保持「不双写」语义。
+  if (result.status !== 'ok' && source !== 'volta' && repairVolta) {
+    const repaired = await repairVolta(run, log, env);
+    if (repaired) result = await verify(latestVersion, env);
   }
 
-  if (verify) {
-    // 事后确认（尽力而为）：两处落点都应已是新版，命中哪份都该 ok；
-    // 不 ok（如 PATH 上另有第三份旧安装）只警告，不影响返回值。
-    const result = await verify(latestVersion);
-    if (result.status === 'ok') {
-      log.log(`Verified: tmuxclihook on your PATH now resolves to v${latestVersion}.`);
-    } else {
-      warnNotEffective(log, result);
+  if (result.status === 'ok') {
+    log.log(`Verified: tmuxclihook on your PATH now resolves to v${latestVersion}.`);
+  } else {
+    warnNotEffective(log, result);
+  }
+
+  // 升级已确认成功后再收敛历史副本；清理失败不影响升级结果，也不改变退出码。
+  if (cleanup && result.status === 'ok') {
+    try {
+      const removed = await cleanupStale({
+        source, env, run, log, prune, isTTY, confirm, checkHooks, checkTmuxConf, detectStale,
+      });
+      // 删过东西就再确认一次生效入口，避免误删导致命令不可用。
+      if (removed && verify) {
+        const after = await verify(latestVersion, env);
+        if (after.status !== 'ok') warnNotEffective(log, after);
+      }
+    } catch (err) {
+      log.error(`Cleanup skipped: ${err}`);
     }
   }