tmuxclihook 0.5.0 → 0.5.2

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` 查询最新版；版本相同则不做任何安装（若显式传入 `--prune`，仍会执行一次非生效副本检测与清理）。需要升级时，它按 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 改变习惯。
+升级成功，或版本已是最新且显式传入 `--prune` 时，update 会检查另一套安装（volta packages 镜像或当前 npm 全局 prefix）是否还留有副本。发现副本时：TTY 下询问是否删除（默认不删）；非交互环境只打印警告；`--prune` 跳过询问直接删除。删除前会校验该副本未被任何 hooks 与 `~/.tmux.conf` 引用——任一检查无法确认就保留并提示先重装 hooks。**生效入口永远不删**，清理失败不影响升级结果。也可以手动收敛：卸载不再使用的那份（`npm uninstall -g tmuxclihook` 或 `volta uninstall tmuxclihook`），再从生效入口重新安装 hooks。
 
 ## 功能
 

package/bin/cli.js

@@ -31,6 +31,7 @@ import { setSource, clearSource, getPersistedSource, originLabel } from '../src/
 import { enableEscapeCancel, setSpinnerActive } from '../src/esc.js';
 import { note, padDisplay } from '../src/tui.js';
 import { updatePackage, CURRENT_VERSION } from '../src/update.js';
+import { HELP_TEXT } from '../src/help.js';
 
 const OK = '✓';
 const NO = '✗';
@@ -491,7 +492,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);
@@ -505,16 +506,7 @@ if (arg === 'update') {
 } else if (arg === '--version' || arg === '-v' || arg === 'version') {
   console.log(`tmuxclihook v${CURRENT_VERSION}`);
 } else if (arg === '--help' || arg === '-h' || arg === 'help') {
-  console.log(
-    'tmuxclihook — tmux-ai-status 交互式安装器\n' +
-    '\n' +
-    '用法：\n' +
-    '  tmuxclihook              打开交互式 TUI 安装器\n' +
-    '  tmuxclihook check        hooks 健康明细（可跟 claude|codex|opencode；exit 1 = 有缺失或漂移）\n' +
-    '  tmuxclihook update       检查并更新到 npm 最新版本\n' +
-    '  tmuxclihook version      显示版本（--version / -v 等价）\n' +
-    '  tmuxclihook help         显示本帮助（--help / -h 等价）',
-  );
+  console.log(HELP_TEXT);
 } else {
   main().catch((err) => {
     console.error(err);

package/package.json

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

package/src/help.js

@@ -0,0 +1,31 @@
+// `tmuxclihook help` 的静态文案。独立成模块是为了让测试可以直接 import，
+// 而不必加载 bin/cli.js（入口文件顶层会执行参数分支，未知参数会启动 TUI）。
+const COMMAND_WIDTH = 26;
+
+function line(command, description) {
+  return `  ${command.padEnd(COMMAND_WIDTH)}  ${description}`;
+}
+
+export const HELP_TEXT = [
+  'tmuxclihook — tmux-ai-status 交互式安装器',
+  '',
+  '命令行：',
+  line('tmuxclihook', '打开交互式 TUI 安装器'),
+  line('tmuxclihook check', 'hooks 健康明细（可跟 claude|codex|opencode；exit 1 = 有缺失或漂移）'),
+  line('tmuxclihook update', '按当前安装方式（npm/volta）检查并更新到最新版本'),
+  line('tmuxclihook update --prune', '更新后删除不生效的另一份安装；已是最新时也会执行清理'),
+  line('tmuxclihook version', '显示版本（--version / -v 等价）'),
+  line('tmuxclihook help', '显示本帮助（--help / -h 等价）'),
+  '',
+  'tmux 快捷键（插件加载后生效）：',
+  line('prefix + I', '打开交互式 TUI 安装器'),
+  line('prefix + C-h', '安装 Claude Code hooks'),
+  line('prefix + C-u', '卸载 Claude Code hooks'),
+  line('prefix + M-h', '安装 Codex hooks'),
+  line('prefix + M-u', '卸载 Codex hooks'),
+  line('prefix + C-p', '安装 opencode plugin'),
+  line('prefix + M-p', '卸载 opencode plugin'),
+  line('prefix + r', '重载配置（含本插件初始化）'),
+  '',
+  'prefix 默认是 Ctrl+b；若你在 tmux 配置中改过 prefix，以你的配置为准。',
+].join('\n');

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,31 @@ 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 是生效语义，两者都执行；用户无需改变安装习惯。
+// 清理非生效副本，并在实际删除过副本后复检生效入口。升级成功路径与
+// 「已是最新 + --prune」路径共用，避免两处逻辑漂移。清理失败只记录日志，
+// 不影响 update 的返回值。
+async function reconcileStaleCopies({
+  source, env, run, log, prune, isTTY, confirm,
+  checkHooks, checkTmuxConf, detectStale, verify, expectedVersion,
+}) {
+  try {
+    const removed = await cleanupStale({
+      source, env, run, log, prune, isTTY, confirm, checkHooks, checkTmuxConf, detectStale,
+    });
+    if (removed && verify) {
+      const after = await verify(expectedVersion, env);
+      if (after.status !== 'ok') warnNotEffective(log, after);
+    }
+  } catch (err) {
+    log.error(`Cleanup skipped: ${err}`);
+  }
+}
+
+// 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 +337,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}`);
 
@@ -141,33 +366,73 @@ export async function updatePackage(options = {}) {
 
   if (currentVersion === latestVersion) {
     log.log('Already up to date.');
+
+    // 版本已最新：绝不安装；仅显式 --prune 时收敛非生效副本。
+    // 未传 --prune 时保持历史行为：不探测来源、不清理、直接返回。
+    if (cleanup && prune) {
+      const effectiveSource = typeof detectSource === 'function'
+        ? detectSource(env)
+        : 'unknown';
+      await reconcileStaleCopies({
+        source: effectiveSource, env, run, log, prune, isTTY, confirm,
+        checkHooks, checkTmuxConf, detectStale, verify,
+        expectedVersion: latestVersion,
+      });
+    }
+
     return true;
   }
 
   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') {
+    await reconcileStaleCopies({
+      source, env, run, log, prune, isTTY, confirm,
+      checkHooks, checkTmuxConf, detectStale, verify,
+      expectedVersion: latestVersion,
+    });
   }
 
   return true;