tt-help-cli-ycl 1.4.115 → 1.4.119

package/src/clash/discover.js

@@ -0,0 +1,451 @@
+/**
+ * Clash 控制端自动发现 — discover.js
+ *
+ * 职责:
+ *   1. 探测已知配置文件的 external-controller 与 secret（Clash Verge / 69cloud）
+ *   2. 兜底: 枚举 127.0.0.1 监听端口，按 mihomo /version 响应特征识别
+ *   3. 验证闭环: 端口 + secret 必须通过 /version 认证才算可用
+ *   4. 多控制端选择策略: system-proxy / preference / first-alive
+ *   5. 全部失败回退旧默认值（9097 + 原 secret，向后兼容）
+ *
+ * 需求文档: clash控制端自动发现需求.md（已拍板 1A 2A 3A 4A 5A）
+ */
+
+import { existsSync, readFileSync } from "fs";
+import { spawnSync } from "child_process";
+import { homedir } from "os";
+import { join } from "path";
+
+const IS_WIN = process.platform === "win32";
+
+export const DISCOVER_DEFAULTS = {
+  port: 9097,
+  secret: "abcdefg",
+  proxyPort: 7897,
+  selection: "system-proxy",
+};
+
+// 已知配置文件探测表（决策 4A: Clash Verge 优先）
+const CONFIG_PATHS = (() => {
+  const appData = process.env.APPDATA || "";
+  const home = homedir();
+  return IS_WIN
+    ? [
+        {
+          client: "Clash Verge",
+          path: join(
+            appData,
+            "io.github.clash-verge-rev.clash-verge-rev",
+            "config.yaml",
+          ),
+        },
+        {
+          client: "69cloud",
+          path: join(appData, "69cloud", "config", "config.yaml"),
+        },
+      ]
+    : [
+        {
+          client: "Clash Verge",
+          path: join(
+            home,
+            "Library/Application Support/io.github.clash-verge-rev.clash-verge-rev",
+            "config.yaml",
+          ),
+        },
+        {
+          client: "69cloud",
+          path: join(
+            home,
+            "Library/Application Support/69cloud",
+            "config",
+            "config.yaml",
+          ),
+        },
+      ];
+})();
+
+// ── 结果缓存（仅缓存成功结果；回退结果不缓存，便于重试时重新探测） ──
+let _cache = null;
+
+export function invalidateDiscoverCache() {
+  _cache = null;
+}
+
+// ══════════════════════════════════════════════
+// 工具函数（导出便于单测）
+// ══════════════════════════════════════════════
+
+/** 读取 ~/.tt-help.json 中的 clash 段（apiPort/secret/selection/configPaths） */
+export function readUserConfig() {
+  try {
+    const home = process.env.HOME || process.env.USERPROFILE || homedir();
+    const p = join(home, ".tt-help.json");
+    if (!existsSync(p)) return {};
+    const cfg = JSON.parse(readFileSync(p, "utf-8"));
+    return cfg.clash && typeof cfg.clash === "object" ? cfg.clash : {};
+  } catch {
+    return {};
+  }
+}
+
+/** 极简平面 YAML 解析：仅取顶层 `key: value` 行，够 config.yaml 用 */
+export function parseFlatYaml(text) {
+  const out = {};
+  for (const line of String(text).split(/\r?\n/)) {
+    if (/^\s*(#|$)/.test(line)) continue;
+    const idx = line.indexOf(":");
+    if (idx <= 0) continue;
+    const key = line.slice(0, idx).trim();
+    const raw = line.slice(idx + 1).trim();
+    if (!key || !/^[A-Za-z0-9_-]+$/.test(key)) continue;
+    if (
+      !raw ||
+      raw.startsWith("-") ||
+      raw.startsWith("{") ||
+      raw.startsWith("[")
+    )
+      continue;
+    out[key] = raw.replace(/^["']|["']$/g, "");
+  }
+  return out;
+}
+
+/** 从 external-controller 字符串（如 "127.0.0.1:9097"）解析端口 */
+export function parseController(str) {
+  if (!str) return null;
+  const m = String(str).match(/(?:127\.0\.0\.1|localhost|0\.0\.0\.0)?:(\d+)/);
+  return m ? parseInt(m[1], 10) : null;
+}
+
+/**
+ * GET /version 探测（不抛异常）
+ * @returns {{status:number, signature:'ok'|'unauthorized'|null}|null}
+ *   ok           - 200 且 JSON 含 version（已认证通过或免认证）
+ *   unauthorized - 401/403 且 body 含 Unauthorized（mihomo 特征，需要 secret）
+ *   null         - 非 mihomo / 不可达 / 超时
+ */
+export async function probeVersion(port, secret = "", timeoutMs = 2500) {
+  const headers = {};
+  if (secret) headers.Authorization = `Bearer ${secret}`;
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/version`, {
+      headers,
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    const text = await res.text().catch(() => "");
+    if (res.status === 200) {
+      try {
+        const j = JSON.parse(text);
+        if (typeof j?.version === "string")
+          return { status: res.status, signature: "ok" };
+      } catch {}
+    }
+    if (
+      (res.status === 401 || res.status === 403) &&
+      text.includes("Unauthorized")
+    ) {
+      return { status: res.status, signature: "unauthorized" };
+    }
+    return { status: res.status, signature: null };
+  } catch {
+    return null;
+  }
+}
+
+/** 验证「端口 + secret」是否可完成认证（/version 返回 ok） */
+export async function verifyController(port, secret = "") {
+  const r = await probeVersion(port, secret);
+  return !!r && r.signature === "ok";
+}
+
+/** 枚举本机 127.0.0.1 的 TCP LISTEN 端口 */
+export function listListeningPorts() {
+  const ports = new Set();
+  try {
+    if (IS_WIN) {
+      const r = spawnSync("netstat", ["-ano", "-p", "TCP"], {
+        encoding: "utf-8",
+        timeout: 5000,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+      for (const line of String(r.stdout || "").split(/\r?\n/)) {
+        if (!line.includes("LISTENING")) continue;
+        const m = line.match(/127\.0\.0\.1:(\d+)/);
+        if (m) ports.add(parseInt(m[1], 10));
+      }
+    } else {
+      const r = spawnSync("lsof", ["-nP", "-iTCP", "-sTCP:LISTEN"], {
+        encoding: "utf-8",
+        timeout: 5000,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+      for (const line of String(r.stdout || "").split(/\r?\n/)) {
+        if (!line.includes("(LISTEN)")) continue;
+        const m = line.match(/(?:127\.0\.0\.1|localhost):(\d+)/);
+        if (m) ports.add(parseInt(m[1], 10));
+      }
+    }
+  } catch {}
+  return [...ports];
+}
+
+/** 读取操作系统当前代理端口（mac scutil --proxy / win 注册表） */
+export function getSystemProxyPorts() {
+  const ports = new Set();
+  try {
+    if (IS_WIN) {
+      const r = spawnSync(
+        "reg",
+        [
+          "query",
+          "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",
+          "/v",
+          "ProxyServer",
+        ],
+        { encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] },
+      );
+      for (const m of String(r.stdout || "").matchAll(
+        /(?:127\.0\.0\.1|localhost):(\d+)/g,
+      )) {
+        ports.add(parseInt(m[1], 10));
+      }
+    } else {
+      const r = spawnSync("scutil", ["--proxy"], {
+        encoding: "utf-8",
+        timeout: 5000,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+      const out = String(r.stdout || "");
+      const enabled = (key) => {
+        const m = out.match(new RegExp(`${key}\\s*:\\s*(\\d+)`));
+        return !!m && parseInt(m[1], 10) === 1;
+      };
+      const portOf = (key) => {
+        const m = out.match(new RegExp(`${key}\\s*:\\s*(\\d+)`));
+        return m ? parseInt(m[1], 10) : null;
+      };
+      const proxyHost = (key) => {
+        const m = out.match(new RegExp(`${key}\\s*:\\s*([\\w.\\-]+)`));
+        return m ? m[1] : "";
+      };
+      if (enabled("HTTPEnable")) {
+        const h = proxyHost("HTTPProxy");
+        const p = portOf("HTTPPort");
+        if ((h === "127.0.0.1" || h === "localhost") && p) ports.add(p);
+      }
+      if (enabled("SOCKSEnable")) {
+        const h = proxyHost("SOCKSProxy");
+        const p = portOf("SOCKSPort");
+        if ((h === "127.0.0.1" || h === "localhost") && p) ports.add(p);
+      }
+    }
+  } catch {}
+  return [...ports];
+}
+
+/** 读取候选控制端的 mixed-port（代理端口） */
+export async function getMixedPort(port, secret = "") {
+  try {
+    const headers = {};
+    if (secret) headers.Authorization = `Bearer ${secret}`;
+    const res = await fetch(`http://127.0.0.1:${port}/configs`, {
+      headers,
+      signal: AbortSignal.timeout(3000),
+    });
+    if (!res.ok) return null;
+    const j = await res.json().catch(() => null);
+    return j && j["mixed-port"] ? parseInt(j["mixed-port"], 10) : null;
+  } catch {
+    return null;
+  }
+}
+
+// ══════════════════════════════════════════════
+// 主流程
+// ══════════════════════════════════════════════
+
+/**
+ * 收集可用控制端候选（discover / discoverAll 共用）
+ * 显式指定端口验证失败时抛错（不回退，便于排障）
+ */
+async function _collectCandidates({ apiPort, secret, extraPaths }) {
+  // 1) 显式指定端口：验证失败直接报错，不回退（逃生舱语义）
+  if (apiPort > 0) {
+    const ok = await verifyController(apiPort, secret);
+    if (!ok) {
+      throw new Error(
+        `显式指定的控制端口 127.0.0.1:${apiPort} 验证失败（secret ${secret ? "已提供" : "为空"}）`,
+      );
+    }
+    return [
+      { port: apiPort, secret, clientName: "mihomo", source: "手动指定" },
+    ];
+  }
+
+  // 2) 已知配置文件探测（按优先级顺序）
+  const candidates = [];
+  const pathList = [
+    ...CONFIG_PATHS,
+    ...extraPaths.map((p) => ({ client: "自定义", path: p })),
+  ];
+  for (const entry of pathList) {
+    let cfg = null;
+    try {
+      if (!existsSync(entry.path)) continue;
+      cfg = parseFlatYaml(readFileSync(entry.path, "utf-8"));
+    } catch (e) {
+      console.error(`[discover] 读取配置失败 ${entry.path}: ${e.message}`);
+      continue;
+    }
+    const port = parseController(cfg["external-controller"]);
+    if (!port) continue;
+    const fileSecret =
+      typeof cfg.secret === "string" && cfg.secret ? cfg.secret : "";
+    const okWithSecret = await verifyController(port, fileSecret);
+    const okEmpty = fileSecret ? false : await verifyController(port, "");
+    if (!okWithSecret && !okEmpty) continue;
+    candidates.push({
+      port,
+      secret: okWithSecret ? fileSecret : "",
+      clientName: entry.client,
+      source: `配置文件(${entry.path})`,
+    });
+  }
+
+  // 3) 端口枚举兜底（配置文件一无所获时）
+  if (!candidates.length) {
+    const probes = listListeningPorts().map(async (port) => {
+      const r = await probeVersion(port, "", 2000);
+      if (r?.signature !== "unauthorized") return null;
+      if (await verifyController(port, "")) return port;
+      return null;
+    });
+    const results = await Promise.all(probes);
+    const port = results.find((p) => p !== null);
+    if (port) {
+      candidates.push({
+        port,
+        secret: "",
+        clientName: "mihomo",
+        source: `端口探测(${port})`,
+      });
+    }
+  }
+
+  return candidates;
+}
+
+/** 回退默认条目（决策 5A，向后兼容） */
+function _fallbackEntry() {
+  return {
+    port: DISCOVER_DEFAULTS.port,
+    secret: DISCOVER_DEFAULTS.secret,
+    proxyPort: DISCOVER_DEFAULTS.proxyPort,
+    proxyUrl: `http://127.0.0.1:${DISCOVER_DEFAULTS.proxyPort}`,
+    clientName: "Clash Verge",
+    source: "未发现可用控制端",
+    fallback: true,
+  };
+}
+
+/**
+ * 为每个候选解析代理端口，并按 system-proxy 命中排序（命中排最前，主控制端）
+ * 稳定排序：未命中的候选保持发现顺序（Clash Verge 优先）
+ */
+async function _finalizeCandidates(candidates) {
+  const sysPorts = getSystemProxyPorts();
+  const out = [];
+  for (const c of candidates) {
+    const mp = await getMixedPort(c.port, c.secret);
+    const proxyPort = mp || DISCOVER_DEFAULTS.proxyPort;
+    out.push({ ...c, proxyPort, proxyUrl: `http://127.0.0.1:${proxyPort}` });
+  }
+  return out.sort((a, b) => {
+    const am = sysPorts.includes(a.proxyPort) ? 0 : 1;
+    const bm = sysPorts.includes(b.proxyPort) ? 0 : 1;
+    return am - bm;
+  });
+}
+
+/**
+ * 自动发现本机 mihomo 控制端（单选，保持原有选择策略语义）
+ * @param {object} [options]
+ * @param {number} [options.apiPort]   显式控制端口（CLI）
+ * @param {string} [options.secret]    显式 secret（CLI）
+ * @param {string} [options.selection] 选择策略 system-proxy / preference / first-alive
+ * @param {string[]} [options.configPaths] 追加配置路径
+ * @returns {Promise<{port,secret,proxyUrl,proxyPort,clientName,source,fallback}>}
+ * @throws 显式 apiPort 验证失败时抛错（不回退，便于排障）
+ */
+export async function discover(options = {}) {
+  const user = readUserConfig();
+  const apiPort = Number(options.apiPort ?? user.apiPort ?? 0) || 0;
+  const secret = options.secret ?? user.secret ?? "";
+  const selection =
+    options.selection || user.selection || DISCOVER_DEFAULTS.selection;
+  const extraPaths = [
+    ...(Array.isArray(user.configPaths) ? user.configPaths : []),
+    ...(Array.isArray(options.configPaths) ? options.configPaths : []),
+  ];
+
+  if (!apiPort && _cache) return _cache;
+
+  const candidates = await _collectCandidates({ apiPort, secret, extraPaths });
+
+  // 多候选选择
+  let chosen = null;
+  if (candidates.length === 1) {
+    chosen = candidates[0];
+  } else if (candidates.length > 1) {
+    chosen = await _selectCandidate(candidates, selection);
+  }
+
+  // 全失败 → 回退旧默认值（不缓存，等待期重试可重新探测）
+  if (!chosen) return _fallbackEntry();
+
+  const mixedPort = await getMixedPort(chosen.port, chosen.secret);
+  chosen.proxyPort = mixedPort || DISCOVER_DEFAULTS.proxyPort;
+  chosen.proxyUrl = `http://127.0.0.1:${chosen.proxyPort}`;
+  return _cacheResult(chosen);
+}
+
+/**
+ * 自动发现本机全部 mihomo 控制端（多控制端模式）
+ * 返回按 system-proxy 命中排序的控制器列表，每个元素含
+ * {port, secret, proxyPort, proxyUrl, clientName, source, fallback}
+ * 全部失败时返回单条回退默认条目（与 discover 一致）
+ */
+export async function discoverAll(options = {}) {
+  const user = readUserConfig();
+  const apiPort = Number(options.apiPort ?? user.apiPort ?? 0) || 0;
+  const secret = options.secret ?? user.secret ?? "";
+  const extraPaths = [
+    ...(Array.isArray(user.configPaths) ? user.configPaths : []),
+    ...(Array.isArray(options.configPaths) ? options.configPaths : []),
+  ];
+
+  const candidates = await _collectCandidates({ apiPort, secret, extraPaths });
+  if (!candidates.length) return [_fallbackEntry()];
+  return _finalizeCandidates(candidates);
+}
+
+async function _selectCandidate(candidates, selection) {
+  if (selection === "system-proxy") {
+    const sysPorts = getSystemProxyPorts();
+    if (sysPorts.length) {
+      for (const c of candidates) {
+        const mp = await getMixedPort(c.port, c.secret);
+        if (mp && sysPorts.includes(mp)) return c;
+      }
+    }
+    // 系统代理读取失败或无匹配 → 降级 preference（决策 1A 补充约定）
+  }
+  // preference 与 first-alive 均按发现顺序（配置路径表已是优先级顺序）
+  return candidates[0];
+}
+
+function _cacheResult(res) {
+  if (!res.fallback) _cache = res;
+  return res;
+}

package/src/clash/ipc.js

@@ -1,19 +1,55 @@
 /**
- * 文件 IPC 模块
+ * 文件 IPC 模块（支持按代理端口分通道）
  *
  * 与 watchdog 进程间通信，通过 tmpdir 下的 JSON 文件。
  *
- *   clash-health.json  — daemon → watchdog（代理健康状态 + 运行元数据）
- *   clash-cmd.json     — watchdog → daemon（远程命令）
+ *   单通道（默认，port=0，向后兼容）:
+ *     clash-health.json  — daemon → watchdog（代理健康状态 + 运行元数据）
+ *     clash-cmd.json     — 调用方 → daemon（远程命令）
+ *   多通道（port>0，多客户端场景，按代理端口区分）:
+ *     clash-health-{port}.json / clash-cmd-{port}.json
  */
-import { readFileSync, writeFileSync, existsSync } from "fs";
+import { readFileSync, writeFileSync, existsSync, readdirSync } from "fs";
 import { join } from "path";
 import { tmpdir } from "os";
 
 const HEALTH_FILE = join(tmpdir(), "clash-health.json");
 const CMD_FILE = join(tmpdir(), "clash-cmd.json");
 
-// ---- health（daemon → watchdog） ----
+/** 按通道端口计算文件路径（0 = 默认单通道） */
+function channelFile(base, port) {
+  if (!port) return base;
+  return base.replace(/\.json$/, `-${port}.json`);
+}
+
+/** 列出所有已存在的命令通道端口（含 0=默认通道） */
+export function listCommandChannels() {
+  try {
+    return readdirSync(tmpdir())
+      .filter((n) => n === "clash-cmd.json" || /^clash-cmd-\d+\.json$/.test(n))
+      .map((n) =>
+        n === "clash-cmd.json"
+          ? 0
+          : parseInt(n.match(/-(\d+)\.json$/)?.[1] || "0", 10),
+      );
+  } catch {
+    return [0];
+  }
+}
+
+/** 列出所有已存在的健康通道端口（不含默认通道 0，供看门狗上报多控制端状态） */
+export function listHealthChannels() {
+  try {
+    return readdirSync(tmpdir())
+      .filter((n) => /^clash-health-\d+\.json$/.test(n))
+      .map((n) => parseInt(n.match(/-(\d+)\.json$/)?.[1] || "0", 10))
+      .filter((p) => p > 0);
+  } catch {
+    return [];
+  }
+}
+
+// ---- health（daemon → watchdog / 调用方回执） ----
 
 /**
  * 写入健康状态到 IPC 文件
@@ -27,11 +63,12 @@ const CMD_FILE = join(tmpdir(), "clash-cmd.json");
  * @param {string} [state.error] - 错误信息
  * @param {string} [state.lastSwitch] - 最近一次切换记录
  * @param {object} [state.meta] - 运行元数据（groupName, proxyUrl, testUrl, healthyNodesCount 等）
+ * @param {number} [port] - 通道端口（0=默认单通道）
  */
-export function writeHealth(state) {
+export function writeHealth(state, port = 0) {
   try {
     writeFileSync(
-      HEALTH_FILE,
+      channelFile(HEALTH_FILE, port),
       JSON.stringify(
         {
           ...state,
@@ -47,10 +84,11 @@ export function writeHealth(state) {
   }
 }
 
-export function readHealth() {
+export function readHealth(port = 0) {
   try {
-    if (!existsSync(HEALTH_FILE)) return null;
-    const data = JSON.parse(readFileSync(HEALTH_FILE, "utf-8"));
+    const file = channelFile(HEALTH_FILE, port);
+    if (!existsSync(file)) return null;
+    const data = JSON.parse(readFileSync(file, "utf-8"));
     const age = Date.now() - new Date(data.lastCheck || 0).getTime();
     return {
       ...data,
@@ -62,26 +100,32 @@ export function readHealth() {
   }
 }
 
-// ---- command（watchdog → daemon） ----
+// ---- command（调用方/watchdog → daemon） ----
 
 /**
- * 写入命令（watchdog 调用，daemon 轮询读取）
+ * 写入命令（watchdog/业务进程调用，daemon 轮询读取）
  * 支持单条对象或命令数组，统一按数组存储，daemon 一次处理一批
- * @param {object|object[]} cmd - 命令对象或命令数组，如 { action: "setCountryFilter", countries: ["US"] }
+ * @param {object|object[]} cmd - 命令对象或命令数组，如 { action: "failover", reason: "...", proxyPort: 7890 }
+ * @param {number} [port] - 通道端口（0=默认单通道；多客户端时按代理端口写入对应通道）
  */
-export function writeCommand(cmd) {
+export function writeCommand(cmd, port = 0) {
   try {
     const payload = Array.isArray(cmd) ? cmd : [cmd];
-    writeFileSync(CMD_FILE, JSON.stringify(payload, null, 2), "utf-8");
+    writeFileSync(
+      channelFile(CMD_FILE, port),
+      JSON.stringify(payload, null, 2),
+      "utf-8",
+    );
   } catch {
     /* 非关键路径 */
   }
 }
 
-export function readCommand() {
+export function readCommand(port = 0) {
   try {
-    if (!existsSync(CMD_FILE)) return null;
-    const text = readFileSync(CMD_FILE, "utf-8").trim();
+    const file = channelFile(CMD_FILE, port);
+    if (!existsSync(file)) return null;
+    const text = readFileSync(file, "utf-8").trim();
     if (!text || text === "{}" || text === "[]") return null;
     const parsed = JSON.parse(text);
     return Array.isArray(parsed) ? parsed : [parsed];
@@ -90,8 +134,9 @@ export function readCommand() {
   }
 }
 
-export function clearCommand() {
+export function clearCommand(port = 0) {
   try {
-    if (existsSync(CMD_FILE)) writeFileSync(CMD_FILE, "{}", "utf-8");
+    const file = channelFile(CMD_FILE, port);
+    if (existsSync(file)) writeFileSync(file, "{}", "utf-8");
   } catch {}
 }

package/src/cli/clash-daemon.js

@@ -1,7 +1,9 @@
 /**
  * clash-daemon CLI 命令入口
  *
- * 用法: tt-help clash-daemon [--interval 120] [--benchmark 10] [--country US] [--dry-run]
+ * 用法: tt-help clash-daemon [--interval 120] [--benchmark 10] [--country US]
+ *       [--api-port <端口>] [--secret <secret>] [--selection <策略>] [--config-path <路径>] [--dry-run]
+ * 控制端（端口/secret）默认自动发现，显式参数优先于自动发现
  */
 import { ClashDaemon } from "../clash/daemon.js";
 
@@ -14,6 +16,13 @@ export async function handleClashDaemon(options) {
       options["dry-run"] === "" ||
       options["dry-run"] === true ||
       process.argv.includes("--dry-run"),
+    apiPort: parseInt(options["api-port"]) || undefined,
+    secret: options.secret || undefined,
+    selection: options.selection || undefined,
+    configPaths:
+      Array.isArray(options["config-paths"]) && options["config-paths"].length
+        ? options["config-paths"]
+        : undefined,
   });
   await d.start();
 }