tt-help-cli-ycl 1.4.115 → 1.4.117

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tt-help-cli-ycl",
-  "version": "1.4.115",
+  "version": "1.4.117",
   "description": "TikTok user & video data scraper - extract ttSeller, verified, locationCreated from HTML source",
   "type": "module",
   "bin": {

package/scripts/test-clash-discover.mjs

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+/**
+ * clash 控制端自动发现 — 验证脚本
+ * 用法: node scripts/test-clash-discover.mjs
+ */
+import {
+  parseFlatYaml,
+  parseController,
+  verifyController,
+  discover,
+  invalidateDiscoverCache,
+  listListeningPorts,
+  getSystemProxyPorts,
+} from "../src/clash/discover.js";
+import { configure, getBaseConfig, resetConfig } from "../src/clash/api.js";
+import { readFileSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+let failed = 0;
+function check(name, cond, extra = "") {
+  console.log(`${cond ? "✓" : "✗"} ${name}${extra ? ` — ${extra}` : ""}`);
+  if (!cond) failed++;
+}
+
+// ── 单元 ──
+const yaml = parseFlatYaml(
+  `external-controller: 127.0.0.1:19835\nsecret: "abc123"\nmode: rule\nproxies:\n  - a\n`,
+);
+check(
+  "parseFlatYaml 顶层字段",
+  yaml["external-controller"] === "127.0.0.1:19835" && yaml.secret === "abc123",
+);
+check("parseFlatYaml 跳过嵌套/列表", !("proxies" in yaml));
+check("parseController 标准格式", parseController("127.0.0.1:9097") === 9097);
+check("parseController 空值", parseController("") === null);
+check("listListeningPorts 枚举非空", listListeningPorts().length > 0);
+
+// ── 集成: 按当前环境自适应验证 ──
+const listening = listListeningPorts();
+const clvUp = listening.includes(9097);
+// 69cloud 控制端口会漂移（19835 → 19216 …），从配置文件动态读取
+const n69CfgPath = join(
+  homedir(),
+  "Library/Application Support/69cloud",
+  "config",
+  "config.yaml",
+);
+let n69Port = null;
+if (existsSync(n69CfgPath)) {
+  n69Port = parseController(
+    parseFlatYaml(readFileSync(n69CfgPath, "utf-8"))["external-controller"],
+  );
+}
+const n69Up = n69Port !== null && listening.includes(n69Port);
+
+if (clvUp) {
+  check(
+    "verifyController 9097 + abcdefg",
+    await verifyController(9097, "abcdefg"),
+  );
+} else {
+  console.log("○ 跳过 9097 验证（Clash Verge 未运行）");
+}
+if (n69Up) {
+  check(
+    "verifyController 69cloud + 错误secret 应失败",
+    !(await verifyController(n69Port, "wrong-secret")),
+  );
+} else {
+  console.log("○ 跳过 69cloud 验证（69cloud 未运行）");
+}
+
+const sysPorts = getSystemProxyPorts();
+console.log(`  系统代理端口: [${sysPorts.join(", ") || "无"}]`);
+
+// ── 集成: 自动发现 ──
+invalidateDiscoverCache();
+const d1 = await discover();
+if (clvUp || n69Up) {
+  check(
+    "discover 自动模式（有客户端在线）",
+    !d1.fallback && listening.includes(d1.port),
+    `选定 ${d1.clientName} @${d1.port} 来源=${d1.source} proxy=${d1.proxyUrl}`,
+  );
+  console.log(`    -> ${JSON.stringify(d1)}`);
+
+  // 显式覆盖（用自动发现选定的控制端做正向验证）
+  invalidateDiscoverCache();
+  const d2 = await discover({ apiPort: d1.port, secret: d1.secret });
+  check(
+    "discover 显式覆盖",
+    d2.port === d1.port && d2.source === "手动指定",
+    `@${d2.port} 来源=${d2.source}`,
+  );
+} else {
+  check(
+    "discover 无客户端 → 回退默认值",
+    d1.fallback === true &&
+      d1.port === 9097 &&
+      d1.source === "未发现可用控制端",
+    `选定 ${d1.clientName} @${d1.port} 来源=${d1.source}`,
+  );
+}
+
+// 显式覆盖错误端口 → 必须抛错（任何环境都验证）
+invalidateDiscoverCache();
+let threw = false;
+try {
+  await discover({ apiPort: 12345, secret: "x" });
+} catch (e) {
+  threw = true;
+  console.log(`    预期报错: ${e.message}`);
+}
+check("discover 错误端口必须报错", threw);
+
+// ── api.configure 注入 ──
+resetConfig();
+configure({ port: 19835, secret: "demo" });
+const bc = getBaseConfig();
+check("api.configure 注入", bc.port === 19835 && bc.secret === "demo");
+resetConfig();
+check("api.resetConfig 还原", getBaseConfig().port === 9097);
+
+console.log(failed ? `\n✗ ${failed} 项失败` : "\n✓ 全部通过");
+process.exit(failed ? 1 : 0);

package/scripts/test-clash-multichannel.mjs

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+/**
+ * clash 多控制端多通道 — 验证脚本
+ * 用法: node scripts/test-clash-multichannel.mjs
+ */
+import { discoverAll, getSystemProxyPorts } from "../src/clash/discover.js";
+import * as ipc from "../src/clash/ipc.js";
+
+let failed = 0;
+function check(name, cond, extra = "") {
+  console.log(`${cond ? "✓" : "✗"} ${name}${extra ? ` — ${extra}` : ""}`);
+  if (!cond) failed++;
+}
+
+// ── 1. discoverAll：多控制端发现 ──
+const all = await discoverAll();
+console.log(`  发现 ${all.length} 个控制端:`);
+for (const c of all) {
+  console.log(
+    `    - [${c.proxyPort}] ${c.clientName} @${c.port}（${c.source}${c.fallback ? "，回退默认值" : ""}）`,
+  );
+}
+check("discoverAll 返回数组", Array.isArray(all) && all.length > 0);
+check(
+  "每个控制端含 proxyPort/proxyUrl",
+  all.every((c) => c.proxyPort > 0 && c.proxyUrl?.startsWith("http://")),
+);
+const sysPorts = getSystemProxyPorts();
+if (sysPorts.length && all.length > 1) {
+  check(
+    "system-proxy 命中者排第一（主控制端）",
+    sysPorts.includes(all[0].proxyPort),
+    `主控制端 proxyPort=${all[0].proxyPort}, 系统代理=[${sysPorts.join(",")}]`,
+  );
+} else {
+  console.log(
+    `○ 跳过主控制端排序断言（系统代理=[${sysPorts.join(",")}] 或单控制端）`,
+  );
+}
+
+// ── 2. IPC 多通道读写 ──
+const TEST_PORT = 7890;
+ipc.writeCommand(
+  { action: "failover", reason: "multichannel-test", proxyPort: TEST_PORT },
+  TEST_PORT,
+);
+const readBack = ipc.readCommand(TEST_PORT);
+check(
+  "按端口写读命令通道",
+  Array.isArray(readBack) &&
+    readBack[0]?.action === "failover" &&
+    readBack[0]?.proxyPort === TEST_PORT,
+);
+
+ipc.writeHealth({ node: "test", healthy: true }, TEST_PORT);
+const hBack = ipc.readHealth(TEST_PORT);
+check(
+  "按端口写读健康通道",
+  !!hBack && hBack.node === "test" && hBack.healthy === true,
+);
+
+// 默认通道与端口通道互不影响
+const legacyCmd = ipc.readCommand(0);
+check(
+  "默认通道独立（未被端口通道污染）",
+  !legacyCmd || legacyCmd[0]?.action !== "failover" || !legacyCmd[0]?.proxyPort,
+);
+
+const channels = ipc.listCommandChannels();
+check(
+  "listCommandChannels 含测试通道",
+  channels.includes(TEST_PORT),
+  `channels=[${channels.join(",")}]`,
+);
+
+ipc.clearCommand(TEST_PORT);
+check("clearCommand 清空端口通道", ipc.readCommand(TEST_PORT) === null);
+
+// ── 3. 路由逻辑（用 daemon 实例验证，不启动守护） ──
+import { ClashDaemon } from "../src/clash/daemon.js";
+const d = new ClashDaemon({ dryRun: true });
+d._controllers = all;
+d._primary = all[0];
+const routed = d._routeController({
+  action: "failover",
+  proxyPort: all[0].proxyPort,
+});
+check(
+  "命令按 proxyPort 路由到对应控制端",
+  !!routed && routed.proxyPort === all[0].proxyPort,
+);
+const routedMiss = d._routeController({ action: "failover", proxyPort: 59999 });
+check("未知端口回退主控制端", !!routedMiss && routedMiss === d._primary);
+
+// 多控制端时：第二个控制端也能被路由命中
+if (all.length > 1) {
+  const routed2 = d._routeController({
+    action: "switchNode",
+    node: "x",
+    proxyPort: all[1].proxyPort,
+  });
+  check(
+    "第二个控制端按端口路由命中",
+    !!routed2 && routed2.proxyPort === all[1].proxyPort,
+    `${routed2?.clientName} @${routed2?.port}`,
+  );
+} else {
+  console.log("○ 单控制端，跳过第二控制端路由断言");
+}
+
+// 清理测试产生的健康文件
+try {
+  const { rmSync } = await import("fs");
+  const { tmpdir } = await import("os");
+  const { join } = await import("path");
+  rmSync(join(tmpdir(), `clash-health-${TEST_PORT}.json`), { force: true });
+} catch {}
+
+console.log(failed ? `\n✗ ${failed} 项失败` : "\n✓ 全部通过");
+process.exit(failed ? 1 : 0);

package/src/clash/api.js

@@ -3,11 +3,37 @@
  *
  * API 参考: https://wiki.metacubex.one/en/api
  * 认证方式: Authorization: Bearer ${secret}
- * 依赖 Clash Verge GUI 运行时绑定的 TCP 127.0.0.1:9097
+ * 端口/secret 默认指向 Clash Verge (127.0.0.1:9097)，
+ * 可通过 configure() 注入自动发现结果（见 discover.js），保留默认值向后兼容。
  */
 
-const BASE_URL = "http://127.0.0.1:9097";
-const SECRET = "abcdefg";
+let BASE_URL = "http://127.0.0.1:9097";
+let SECRET = "abcdefg";
+
+/**
+ * 注入控制端配置（自动发现结果 / 手动覆盖）
+ * @param {{port?:number, secret?:string}} [opts] 只更新传入的字段
+ */
+export function configure({ port, secret } = {}) {
+  if (port) BASE_URL = `http://127.0.0.1:${port}`;
+  if (typeof secret === "string") SECRET = secret;
+}
+
+/** 读取当前生效的端口/secret（供 checker/日志使用） */
+export function getBaseConfig() {
+  const m = BASE_URL.match(/:(\d+)$/);
+  return {
+    baseUrl: BASE_URL,
+    port: m ? parseInt(m[1], 10) : 9097,
+    secret: SECRET,
+  };
+}
+
+/** 重置为默认值（Clash Verge 9097） */
+export function resetConfig() {
+  BASE_URL = "http://127.0.0.1:9097";
+  SECRET = "abcdefg";
+}
 
 function headers() {
   return {

package/src/clash/benchmark/lib/clash-api.js

@@ -1,234 +1,5 @@
 /**
- * Clash Verge (mihomo) RESTful API 客户端
- *
- * API 参考: https://wiki.metacubex.one/en/api
- * 认证方式: Authorization: Bearer ${secret}
- * 依赖 Clash Verge GUI 运行时绑定的 TCP 127.0.0.1:9097
+ * benchmark 子模块 API 客户端 — 与主模块 api.js 统一来源（决策 3A）
+ * 端口/secret 由主模块 api.js 的 configure() 注入，避免双份硬编码
  */
-
-const BASE_URL = "http://127.0.0.1:9097";
-const SECRET = "abcdefg";
-
-function headers() {
-  return {
-    Authorization: `Bearer ${SECRET}`,
-    "Content-Type": "application/json",
-  };
-}
-
-async function request(path, options = {}) {
-  const url = `${BASE_URL}${path}`;
-  const res = await fetch(url, {
-    ...options,
-    headers: { ...headers(), ...options.headers },
-  });
-  if (!res.ok) {
-    const body = await res.text().catch(() => "");
-    throw new Error(`HTTP ${res.status} ${res.statusText}: ${body}`);
-  }
-  if (res.status === 204) return null;
-  const text = await res.text();
-  return text ? JSON.parse(text) : null;
-}
-
-// ===== 代理相关 =====
-
-/** 获取所有代理（含代理组和节点） */
-export async function getProxies() {
-  return request("/proxies");
-}
-
-/** 获取单个代理/组详情 */
-export async function getProxy(name) {
-  return request(`/proxies/${encodeURIComponent(name)}`);
-}
-
-/** 切换代理组的选中节点 */
-export async function switchProxy(groupName, nodeName) {
-  return request(`/proxies/${encodeURIComponent(groupName)}`, {
-    method: "PUT",
-    body: JSON.stringify({ name: nodeName }),
-  });
-}
-
-/**
- * 获取所有代理组（Selector/URLTest/Fallback/LoadBalance 类型）
- * 返回: [{ name, type, now, all }]
- */
-export async function getGroups() {
-  const data = await getProxies();
-  const proxies = data.proxies || {};
-  const groups = [];
-  const groupTypes = new Set([
-    "Selector",
-    "URLTest",
-    "Fallback",
-    "LoadBalance",
-  ]);
-
-  for (const [name, info] of Object.entries(proxies)) {
-    if (groupTypes.has(info.type)) {
-      groups.push({
-        name,
-        type: info.type,
-        now: info.now || "",
-        all: info.all || [],
-      });
-    }
-  }
-  return groups;
-}
-
-/**
- * 获取所有独立节点（非代理组）
- * 返回: [{ name, type, alive, delay }]
- */
-export async function getNodes() {
-  const data = await getProxies();
-  const proxies = data.proxies || {};
-  const nodes = [];
-  const groupTypes = new Set([
-    "Selector",
-    "URLTest",
-    "Fallback",
-    "LoadBalance",
-  ]);
-
-  for (const [name, info] of Object.entries(proxies)) {
-    if (!groupTypes.has(info.type)) {
-      nodes.push({
-        name,
-        type: info.type,
-        alive: info.alive ?? false,
-        delay:
-          info.history?.length > 0
-            ? info.history[info.history.length - 1].delay
-            : null,
-        udp: info.udp ?? false,
-      });
-    }
-  }
-  return nodes;
-}
-
-// ===== 配置相关 =====
-
-/** 获取当前运行配置 */
-export async function getConfigs() {
-  return request("/configs");
-}
-
-/** 更新运行配置（部分更新） */
-export async function patchConfigs(patch) {
-  return request("/configs", {
-    method: "PATCH",
-    body: JSON.stringify(patch),
-  });
-}
-
-/** 强制重载配置 */
-export async function reloadConfigs() {
-  return request("/configs?force=true", { method: "PUT" });
-}
-
-// ===== 系统 =====
-
-/** 获取内核版本 */
-export async function getVersion() {
-  return request("/version");
-}
-
-/** 获取内存使用 */
-export async function getMemory() {
-  return request("/memory");
-}
-
-// ===== 连接 =====
-
-/** 获取当前活跃连接 */
-export async function getConnections() {
-  return request("/connections");
-}
-
-/** 关闭指定连接 */
-export async function closeConnection(id) {
-  return request(`/connections/${id}`, { method: "DELETE" });
-}
-
-/** 关闭所有连接 */
-export async function closeAllConnections() {
-  return request("/connections", { method: "DELETE" });
-}
-
-// ===== 规则 =====
-
-/** 获取规则列表 */
-export async function getRules() {
-  return request("/rules");
-}
-
-// ===== 代理提供者 =====
-
-/** 获取代理提供者列表 */
-export async function getProxyProviders() {
-  return request("/providers/proxies");
-}
-
-/** 更新代理提供者 */
-export async function updateProxyProvider(name) {
-  return request(`/providers/proxies/${encodeURIComponent(name)}`, {
-    method: "PUT",
-  });
-}
-
-/** 代理提供者健康检查 */
-export async function healthCheckProvider(name) {
-  return request(`/providers/proxies/${encodeURIComponent(name)}/healthcheck`);
-}
-
-// ===== 便捷函数 =====
-
-/**
- * 获取指定组当前选中节点
- */
-export async function getCurrentNode(groupName) {
-  const proxy = await getProxy(groupName);
-  return proxy.now || null;
-}
-
-/**
- * 列出指定组的所有可选节点
- */
-export async function listGroupNodes(groupName) {
-  const proxy = await getProxy(groupName);
-  return proxy.all || [];
-}
-
-/**
- * 获取所有存活节点（按延迟排序）
- */
-export async function getAliveNodes() {
-  const nodes = await getNodes();
-  return nodes
-    .filter((n) => n.alive && n.delay !== null && n.delay > 0)
-    .sort((a, b) => (a.delay ?? Infinity) - (b.delay ?? Infinity));
-}
-
-/**
- * 切换到延迟最低的存活节点
- */
-export async function switchToFastest(groupName) {
-  const alive = await getAliveNodes();
-  if (alive.length === 0) {
-    throw new Error("没有存活的节点");
-  }
-  // 需要确认目标节点在该组的 all 列表中
-  const groupNodes = await listGroupNodes(groupName);
-  for (const node of alive) {
-    if (groupNodes.includes(node.name)) {
-      await switchProxy(groupName, node.name);
-      return node;
-    }
-  }
-  throw new Error("存活节点都不在目标组中");
-}
+export * from "../../api.js";

package/src/clash/checker.js

@@ -22,6 +22,8 @@ import * as api from "./api.js";
 
 const IS_WIN = process.platform === "win32";
 const HEALTHY_FILE = join(tmpdir(), "clash-healthy-nodes.json");
+// 多控制端场景下按代理端口分文件（0/默认 = 单客户端旧文件）；由 applyDiscovered 切换
+let _healthyFile = HEALTHY_FILE;
 
 export const CONFIG = {
   testUrl: "https://www.tiktok.com/explore",
@@ -36,22 +38,27 @@ export const CONFIG = {
 const CURL_UA =
   "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36";
 
+// 支持的 mihomo 系客户端进程名（FR-8 存活判定扩展）
+const CLASH_PROCESS_NAMES = ["verge-mihomo", "69cloud-core"];
+
+// 国家匹配：emoji 国旗可选（Clash Verge 节点名带国旗，69cloud 节点名纯中文/英文不带），
+// 拉丁代码用词边界防误匹配（如 \bUS\b 不匹配 PLUS）
 const COUNTRY_PATTERNS = {
-  US: /[🇺🇸]\s*(美国|US|USA|United\s*States)/i,
-  GB: /[🇬🇧]\s*(英国|UK|GB|United\s*Kingdom)/i,
-  DE: /[🇩🇪]\s*(德国|DE|Germany)/i,
-  FR: /[🇫🇷]\s*(法国|FR|France)/i,
-  JP: /[🇯🇵]\s*(日本|JP|Japan)/i,
-  KR: /[🇰🇷]\s*(韩国|KR|Korea)/i,
-  SG: /[🇸🇬]\s*(新加坡|SG|Singapore)/i,
-  HK: /[🇭🇰]\s*(香港|HK|Hong\s*Kong)/i,
-  TW: /[🇹🇼]\s*(台湾|TW|Taiwan)/i,
-  RU: /[🇷🇺]\s*(俄罗斯|RU|Russia)/i,
-  NL: /[🇳🇱]\s*(荷兰|NL|Netherlands)/i,
-  IN: /[🇮🇳]\s*(印度|IN|India)/i,
-  CA: /[🇨🇦]\s*(加拿大|CA|Canada)/i,
-  AU: /[🇦🇺]\s*(澳大利亚|AU|Australia)/i,
-  MY: /[🇲🇾]\s*(马来西亚|MY|Malaysia)/i,
+  US: /(?:[🇺🇸]\s*)?(美国|USA|United\s*States|\bUS\b)/i,
+  GB: /(?:[🇬🇧]\s*)?(英国|UK|United\s*Kingdom|\bGB\b)/i,
+  DE: /(?:[🇩🇪]\s*)?(德国|Germany|\bDE\b)/i,
+  FR: /(?:[🇫🇷]\s*)?(法国|France|\bFR\b)/i,
+  JP: /(?:[🇯🇵]\s*)?(日本|Japan|\bJP\b)/i,
+  KR: /(?:[🇰🇷]\s*)?(韩国|Korea|\bKR\b)/i,
+  SG: /(?:[🇸🇬]\s*)?(新加坡|Singapore|\bSG\b)/i,
+  HK: /(?:[🇭🇰]\s*)?(香港|Hong\s*Kong|\bHK\b)/i,
+  TW: /(?:[🇹🇼]\s*)?(台湾|Taiwan|\bTW\b)/i,
+  RU: /(?:[🇷🇺]\s*)?(俄罗斯|Russia|\bRU\b)/i,
+  NL: /(?:[🇳🇱]\s*)?(荷兰|Netherlands|\bNL\b)/i,
+  IN: /(?:[🇮🇳]\s*)?(印度|India|\bIN\b)/i,
+  CA: /(?:[🇨🇦]\s*)?(加拿大|Canada|\bCA\b)/i,
+  AU: /(?:[🇦🇺]\s*)?(澳大利亚|Australia|\bAU\b)/i,
+  MY: /(?:[🇲🇾]\s*)?(马来西亚|Malaysia|\bMY\b)/i,
 };
 
 let _proxyResolved = false;
@@ -73,6 +80,26 @@ export function resetProxyUrlCache() {
   _proxyResolved = false;
 }
 
+/**
+ * 应用自动发现结果（discover.js）
+ * 控制端口写入 CONFIG.apiPort；代理端口直接采用发现到的 mixed-port，
+ * 避免 resolveProxyUrl() 再对旧端口发起探测。
+ * 多控制端场景：proxyPort 用于切换对应控制端的健康节点列表文件。
+ * @param {{port?:number, proxyUrl?:string, proxyPort?:number}} disc
+ */
+export function applyDiscovered(disc = {}) {
+  if (disc.port) CONFIG.apiPort = disc.port;
+  if (disc.proxyUrl) {
+    CONFIG.proxyUrl = disc.proxyUrl;
+    _proxyResolved = true;
+  }
+  if (disc.proxyPort) {
+    _healthyFile = join(tmpdir(), `clash-healthy-nodes-${disc.proxyPort}.json`);
+  } else {
+    _healthyFile = HEALTHY_FILE;
+  }
+}
+
 // ══════════════════════════════════════════════
 // 2. 进程 / API 可达性检测
 // ══════════════════════════════════════════════
@@ -104,19 +131,25 @@ export function checkClashAliveWithReason() {
 function _detectProcess() {
   try {
     if (IS_WIN) {
-      const r = spawnSync(
-        "tasklist",
-        ["/FI", "IMAGENAME eq verge-mihomo.exe", "/NH"],
-        { encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] },
-      );
-      return r.stdout?.includes("verge-mihomo.exe");
+      for (const name of CLASH_PROCESS_NAMES) {
+        const r = spawnSync(
+          "tasklist",
+          ["/FI", `IMAGENAME eq ${name}.exe`, "/NH"],
+          { encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] },
+        );
+        if (r.stdout?.includes(`${name}.exe`)) return true;
+      }
+      return false;
     }
-    const r = spawnSync("pgrep", ["-x", "verge-mihomo"], {
-      encoding: "utf-8",
-      timeout: 5000,
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-    return r.status === 0 && !!r.stdout.trim();
+    for (const name of CLASH_PROCESS_NAMES) {
+      const r = spawnSync("pgrep", ["-x", name], {
+        encoding: "utf-8",
+        timeout: 5000,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+      if (r.status === 0 && r.stdout.trim()) return true;
+    }
+    return false;
   } catch {
     return false;
   }
@@ -367,8 +400,8 @@ export async function runDelayProbe({
  */
 export function loadHealthyList(country = null) {
   try {
-    if (!existsSync(HEALTHY_FILE)) return _emptyList();
-    const d = JSON.parse(readFileSync(HEALTHY_FILE, "utf-8"));
+    if (!existsSync(_healthyFile)) return _emptyList();
+    const d = JSON.parse(readFileSync(_healthyFile, "utf-8"));
     const allNodes = Array.isArray(d.nodes) ? d.nodes : [];
     const filter = country || CONFIG.nodeCountryFilter;
     const { filtered, excluded } = filterNodesByCountry(allNodes, filter);
@@ -388,7 +421,7 @@ export function loadHealthyList(country = null) {
 export function saveHealthyList(nodes) {
   try {
     writeFileSync(
-      HEALTHY_FILE,
+      _healthyFile,
       JSON.stringify({ updated: new Date().toISOString(), nodes }, null, 2),
       "utf-8",
     );