tt-help-cli-ycl 1.4.155 → 1.4.157

package/package.json

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

package/src/clash/api.js

@@ -210,6 +210,29 @@ export async function getRules() {
 export async function getProxyProviders() {
   return request("/providers/proxies");
 }
+
+/**
+ * 订阅摘要（仅 HTTP 类型 provider）:
+ * 节点数 + subscriptionInfo（官方口径的已用/总量/到期，用于看门狗页面展示）
+ * @returns {Promise<Array<{name,proxies,upload,download,total,expire}>>}
+ */
+export async function getSubscriptionSummaries() {
+  const data = await getProxyProviders();
+  const out = [];
+  for (const [name, p] of Object.entries(data.providers || {})) {
+    if (p.vehicleType !== "HTTP") continue;
+    const si = p.subscriptionInfo || {};
+    out.push({
+      name,
+      proxies: (p.proxies || []).length,
+      upload: si.Upload || 0,
+      download: si.Download || 0,
+      total: si.Total || 0,
+      expire: si.Expire || 0,
+    });
+  }
+  return out;
+}
 export async function updateProxyProvider(name) {
   return request(`/providers/proxies/${encodeURIComponent(name)}`, {
     method: "PUT",
@@ -279,3 +302,29 @@ export async function getProxyDelay(name, url, timeoutMs = 5000) {
     return { delay: -1, timeout: true };
   }
 }
+
+/**
+ * 组批量延迟测试（一次测完全组成员，含 provider 节点）
+ *
+ * 背景: provider 模式下订阅节点不在 /proxies 表内，/proxies/{name}/delay 对其
+ * 返回 404（Resource not found），只能走本端点整组测速。
+ *
+ * @returns {Promise<Object<string,number>|null>} name → delay(ms)，失败节点不在返回中；请求失败返回 null（调用方回退逐个探测）
+ */
+export async function getGroupDelay(groupName, url, timeoutMs = 5000) {
+  try {
+    const qs = `url=${encodeURIComponent(url)}&timeout=${timeoutMs}`;
+    const res = await fetch(
+      `${BASE_URL}/group/${encodeURIComponent(groupName)}/delay?${qs}`,
+      {
+        headers: headers(),
+        signal: AbortSignal.timeout(timeoutMs + 15000),
+      },
+    );
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data && typeof data === "object" ? data : null;
+  } catch {
+    return null;
+  }
+}

package/src/clash/checker.js

@@ -395,19 +395,36 @@ export async function runDelayProbe({
   const total = all.length;
 
   const results = [];
-  const queue = [...filtered];
-  async function worker() {
-    while (queue.length) {
-      const name = queue.shift();
-      const r = await api.getProxyDelay(name, CONFIG.testUrl, timeoutMs);
-      results.push({ node: name, delay: r.delay, timeout: r.timeout });
+  // 批量优先: /group/{G}/delay 一次测完全组（含 provider 节点 —— 该类节点不在
+  // /proxies 表内，逐个探测必 404）；批量不可用时回退逐个探测（兼容旧行为）
+  const batch = await api.getGroupDelay(CONFIG.groupName, CONFIG.testUrl, timeoutMs);
+  if (batch) {
+    for (const name of filtered) {
+      const delay = batch[name];
+      results.push({
+        node: name,
+        delay: typeof delay === "number" && delay > 0 ? delay : -1,
+        timeout: !(typeof delay === "number" && delay > 0),
+      });
+    }
+  } else {
+    console.error(
+      "[checker] 批量测速不可用，回退逐个探测（provider 节点将不可见）",
+    );
+    const queue = [...filtered];
+    async function worker() {
+      while (queue.length) {
+        const name = queue.shift();
+        const r = await api.getProxyDelay(name, CONFIG.testUrl, timeoutMs);
+        results.push({ node: name, delay: r.delay, timeout: r.timeout });
+      }
     }
+    const workers = Array.from(
+      { length: Math.min(concurrency, Math.max(1, filtered.length)) },
+      () => worker(),
+    );
+    await Promise.all(workers);
   }
-  const workers = Array.from(
-    { length: Math.min(concurrency, Math.max(1, filtered.length)) },
-    () => worker(),
-  );
-  await Promise.all(workers);
 
   const good = results
     .filter((r) => !r.timeout && r.delay > 0 && r.delay <= thresholdMs)

package/src/clash/daemon.js

@@ -12,6 +12,7 @@ import * as api from "./api.js";
 import * as checker from "./checker.js";
 import * as ipc from "./ipc.js";
 import { discoverAll, invalidateDiscoverCache } from "./discover.js";
+import * as runtime from "./runtime.js";
 
 // ── 国家过滤辅助（normalizeCountries 由 checker.js 提供单一来源） ──
 /** 国家配置显示（数组 join） */
@@ -58,6 +59,8 @@ export class ClashDaemon {
     };
     this._apiFailCount = 0;
     this._running = false;
+    // 内置 mihomo 运行时状态（ensureMihomoRunning 最近一次结果，透出到 health meta）
+    this._runtimeStatus = null;
     this._timers = [];
     this._waitTimer = null; // 等待控制端就绪的重试定时器
     this._startedOnce = false; // 首次启动标记（banner/信号只打印注册一次）
@@ -293,6 +296,28 @@ export class ClashDaemon {
       return false;
     });
     if (!aliveAny) {
+      // 内置内核自动拉起（先发现后拉起：Verge/已跑的 mihomo 会被发现并认领，
+      // 真没有才 spawn；端口被占/冷却期会跳过，详见 runtime.ensureMihomoRunning）
+      try {
+        const r = await runtime.ensureMihomoRunning({
+          subscriptions: runtime.readStoredSubscriptions(),
+          log: (m) => this._log(m),
+        });
+        this._runtimeStatus = { ...r, at: Date.now() };
+        if (r.status === "started") {
+          this._log(`✓ 内置 mihomo 已就绪，下轮发现将接管`);
+        } else if (r.status === "no-subscription") {
+          // 无订阅不接管（不拉起不占位），防刷屏降频打日志
+          if (Date.now() - (this._lastNoSubLogAt || 0) > 300000) {
+            this._log(`⏭ 未配置订阅，内置 mihomo 不参与（后台配置订阅后自动接管）`);
+            this._lastNoSubLogAt = Date.now();
+          }
+        } else if (r.status === "port-busy") {
+          this._log(`⚠ ${r.error}（不影响发现已有控制端）`);
+        }
+      } catch (e) {
+        this._log(`内置内核拉起异常: ${e.message}`);
+      }
       this._waitRetry = (this._waitRetry || 0) + 1;
       const shouldLog = this._waitRetry <= 3 || this._waitRetry % 6 === 0;
       if (shouldLog) {
@@ -379,15 +404,49 @@ export class ClashDaemon {
     this._useController(c);
     try {
       if (!checker.checkClashAlive()) {
+        // 控制端失联：尝试自动拉起内置内核（冷却保护，端口占用场景内部会跳过），
+        // 本轮先报不健康，拉起结果下轮巡检验证
+        const r = await runtime
+          .ensureMihomoRunning({
+            subscriptions: runtime.readStoredSubscriptions(),
+            log: (m) => this._log(m),
+          })
+          .catch((e) => ({ status: "failed", error: e.message }));
+        this._runtimeStatus = { ...r, at: Date.now() };
         return this._writeHealth(c, {
           node: "?",
           healthy: false,
-          error: `${c.clientName} 未运行`,
+          error: `${c.clientName} 未运行${r.status === "started" ? "（内置内核已自动拉起）" : ""}`,
         });
       }
       const node = await api
         .getCurrentNode(checker.CONFIG.groupName)
         .catch(() => "?");
+
+      // 订阅信息 + 流量采样（随巡检周期，差分算速率）
+      c._subsSnapshot = await api.getSubscriptionSummaries().catch(() => null);
+      const conn = await api.getConnections().catch(() => null);
+      if (conn) {
+        const now = Date.now();
+        const totals = {
+          down: conn.downloadTotal || 0,
+          up: conn.uploadTotal || 0,
+          at: now,
+        };
+        const last = c._trafficLast;
+        if (last && now > last.at) {
+          const sec = (now - last.at) / 1000;
+          c._traffic = {
+            downRate: Math.max(0, (totals.down - last.down) / sec),
+            upRate: Math.max(0, (totals.up - last.up) / sec),
+            totalDown: totals.down,
+            totalUp: totals.up,
+            sampledAt: now,
+          };
+        }
+        c._trafficLast = totals;
+      }
+
       let h = checker.checkNodeHealth();
       this._writeHealth(c, {
         node,
@@ -404,6 +463,13 @@ export class ClashDaemon {
       try {
         const proxies = await api.getProxies();
         const valid = new Set(Object.keys(proxies?.proxies || {}));
+        // provider 模式: 订阅节点不在 /proxies 表内，并入 GLOBAL 全员作为合法全集，
+        // 否则每个候选都会被误判失效，导致每轮巡检都重复 delay 初测
+        try {
+          for (const n of await api.listGroupNodes(checker.CONFIG.groupName)) {
+            valid.add(n);
+          }
+        } catch {}
         const pruned = checker.pruneHealthyListByCurrentProxies(valid);
         if (pruned.removed > 0) {
           if (pruned.allGone) {
@@ -885,6 +951,43 @@ export class ClashDaemon {
     }
   }
 
+  /**
+   * 看门狗指令: 应用订阅配置（服务端页面改动 → 心跳下发 → 此处热应用）
+   * 幂等: 与运行时配置比对，无变化不动作；成功后持久化到 ~/.tt-help.json
+   * 保证 daemon/机器重启后自动恢复，不依赖服务端可达
+   */
+  async _handleSetSubscription(cmd, c) {
+    try {
+      const subs = runtime.normalizeSubscriptions(cmd.subscriptions);
+      if (!subs.length) {
+        // 清空订阅: 回收内置 mihomo + 清持久化 → 回到"无订阅不接管"态（用户可回退到 Verge）
+        const killed = await runtime.stopRuntimeMihomo({ log: (m) => this._log(m) });
+        runtime.storeSubscriptions([]);
+        c._subsSnapshot = [];
+        c._applyResult = { ok: true, changed: true, cleared: true, at: Date.now() };
+        this._log(`📋 订阅已清空: 回收内置 mihomo ${killed} 个进程，不再接管端口`);
+        this._writeHealth(c, { node: "?", healthy: null });
+        return;
+      }
+      this._log(`📋 收到订阅配置: ${subs.length} 条，开始应用...`);
+      const r = await runtime.applyUserSubscriptions(subs, { log: (m) => this._log(m) });
+      if (r.ok) {
+        runtime.storeSubscriptions(subs);
+        if (r.providers) c._subsSnapshot = r.providers;
+        c._applyResult = { ok: true, changed: r.changed, at: Date.now(), count: subs.length };
+        this._log(`📋 订阅应用成功（${subs.length} 条）${r.changed ? "" : "（无变化）"}`);
+      } else {
+        c._applyResult = { ok: false, error: r.error, at: Date.now() };
+        this._log(`⚠ 订阅应用失败: ${r.error}`);
+      }
+      // 结果写健康文件，页面下次心跳可见
+      const node = await api.getCurrentNode(checker.CONFIG.groupName).catch(() => "?");
+      this._writeHealth(c, { node, healthy: null });
+    } catch (e) {
+      this._log(`📋 订阅应用异常: ${e.message}`);
+    }
+  }
+
   // ── helpers ──
 
   _buildMeta(c) {
@@ -900,6 +1003,13 @@ export class ClashDaemon {
       healthyNodesTotal: list.totalNodes,
       healthyNodes: list.nodes.slice(0, 50),
       healthyNodeDelays: list.delays || {},
+      // 代理运行时：订阅用量/到期 + 实时速率（看门狗页面展示）
+      proxy: {
+        subscriptions: (c && c._subsSnapshot) || [],
+        traffic: (c && c._traffic) || null,
+        runtime: this._runtimeStatus || null,
+        applyResult: (c && c._applyResult) || null,
+      },
     });
     return base;
   }
@@ -983,6 +1093,7 @@ function _buildCmdHandlers(daemon) {
     },
     switchNode: (cmd, c) => daemon._handleSwitchNode(cmd, c),
     failover: (cmd, c) => daemon._handleFailover(cmd, c),
+    setSubscription: (cmd, c) => daemon._handleSetSubscription(cmd, c),
   };
 }