tt-help-cli-ycl 1.4.157 → 1.4.158

package/package.json

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

package/src/clash/daemon.js

@@ -11,7 +11,7 @@ import { normalizeCountries } from "./checker.js";
 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 { discoverAll, invalidateDiscoverCache, DISCOVER_DEFAULTS, RUNTIME_MAX_INSTANCES } from "./discover.js";
 import * as runtime from "./runtime.js";
 
 // ── 国家过滤辅助（normalizeCountries 由 checker.js 提供单一来源） ──
@@ -298,22 +298,32 @@ export class ClashDaemon {
     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();
+        const stored = runtime.readStoredSubscriptions();
+        const want = Math.max(1, stored.length);
+        for (let i = 0; i < want; i++) {
+          const idx = i + 1;
+          if (!stored[i] && idx > 1) break; // 无订阅时只尝试实例1（兼容无订阅+Verge 接管路径）
+          const r = await runtime
+            .ensureMihomoRunning({
+              subscriptions: stored[i] ? [stored[i]] : undefined,
+              index: idx,
+              log: (m) => this._log(`[实例${idx}] ${m}`),
+            })
+            .catch((e) => ({ status: "failed", error: e.message }));
+          this._runtimeStatus = { ...r, at: Date.now(), index: idx };
+          if (r.status === "started") {
+            this._log(`✓ 实例${idx} 内置 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}（不影响发现已有控制端）`);
           }
-        } else if (r.status === "port-busy") {
-          this._log(`⚠ ${r.error}（不影响发现已有控制端）`);
         }
       } catch (e) {
         this._log(`内置内核拉起异常: ${e.message}`);
@@ -396,27 +406,74 @@ export class ClashDaemon {
       for (const c of this._controllers) {
         await this._healthCheckController(c);
       }
+      // 期望实例自愈：订阅对应的全部实例，不在线的自动拉起
+      // （覆盖 discover 发现不了的死实例——挂掉的实例不会出现在控制端列表，只能按订阅配置主动拉）
+      await this._ensureDesiredInstances();
     }).catch((e) => this._log(`巡检异常: ${e.message}`));
   }
 
+  /**
+   * 内置期望实例自愈: stored 订阅每条对应一个实例，逐个检查 API 存活，
+   * 不在线的 ensureMihomoRunning 拉起（per-instance 冷却防崩溃循环，端口占用内部自会跳过）
+   * @returns {Promise<{started:number, failed:number}>}
+   */
+  async _ensureDesiredInstances() {
+    const stored = runtime.readStoredSubscriptions();
+    if (!stored.length) return { started: 0, failed: 0 };
+    let started = 0;
+    let failed = 0;
+    for (let i = 0; i < stored.length; i++) {
+      const idx = i + 1;
+      const spec = runtime.instanceSpec(idx);
+      if (await runtime.controllerAlive(spec.apiPort, spec.secret)) continue;
+      const r = await runtime
+        .ensureMihomoRunning({
+          subscriptions: [stored[i]],
+          index: idx,
+          log: (m) => this._log(`[实例${idx}] ${m}`),
+        })
+        .catch((e) => ({ status: "failed", error: e.message }));
+      this._runtimeStatus = { ...r, at: Date.now(), index: idx };
+      if (r.status === "started") {
+        started++;
+        this._log(`✓ 实例${idx} (${spec.apiPort}/${spec.mixedPort}) 自愈拉起成功，下轮发现将接管`);
+      } else if (r.status === "failed" || r.status === "no-vendor") {
+        failed++;
+        this._log(`⚠ 实例${idx} 自愈拉起失败: ${r.error || r.status}`);
+      }
+      // adopted/cooldown/port-busy/no-subscription: 正常等待场景，不打日志刷屏
+    }
+    return { started, failed };
+  }
+
   async _healthCheckController(c) {
     if (c._probing) return; // delay 初测中跳过本轮巡检
     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() };
+        // 控制端失联: 若是内置实例（端口在 9097+N 段内）按对应实例拉起（冷却保护，
+        // 端口占用场景内部会跳过）；外来控制端不动。本轮先报不健康，拉起结果下轮巡检验证
+        const idx =
+          c.port >= DISCOVER_DEFAULTS.port && c.port < DISCOVER_DEFAULTS.port + RUNTIME_MAX_INSTANCES
+            ? c.port - DISCOVER_DEFAULTS.port + 1
+            : 0;
+        if (idx) {
+          const stored = runtime.readStoredSubscriptions();
+          if (stored[idx - 1]) {
+            const r = await runtime
+              .ensureMihomoRunning({
+                subscriptions: [stored[idx - 1]],
+                index: idx,
+                log: (m) => this._log(`[实例${idx}] ${m}`),
+              })
+              .catch((e) => ({ status: "failed", error: e.message }));
+            this._runtimeStatus = { ...r, at: Date.now(), index: idx };
+          }
+        }
         return this._writeHealth(c, {
           node: "?",
           healthy: false,
-          error: `${c.clientName} 未运行${r.status === "started" ? "（内置内核已自动拉起）" : ""}`,
+          error: `${c.clientName} 未运行${idx ? "（内置实例已尝试自动拉起）" : ""}`,
         });
       }
       const node = await api
@@ -953,14 +1010,15 @@ export class ClashDaemon {
 
   /**
    * 看门狗指令: 应用订阅配置（服务端页面改动 → 心跳下发 → 此处热应用）
-   * 幂等: 与运行时配置比对，无变化不动作；成功后持久化到 ~/.tt-help.json
+   * 多实例: 一条订阅 = 一个内置 mihomo 实例（sub[0]→实例1@9097/7897，sub[n]→9097+n/7897+n）
+   * 幂等: 与运行时配置比对，无变化不动作；全部成功后持久化到 ~/.tt-help.json
    * 保证 daemon/机器重启后自动恢复，不依赖服务端可达
    */
   async _handleSetSubscription(cmd, c) {
     try {
       const subs = runtime.normalizeSubscriptions(cmd.subscriptions);
       if (!subs.length) {
-        // 清空订阅: 回收内置 mihomo + 清持久化 → 回到"无订阅不接管"态（用户可回退到 Verge）
+        // 清空订阅: 回收全部内置实例 + 清持久化 → 回到"无订阅不接管"态（用户可回退到 Verge）
         const killed = await runtime.stopRuntimeMihomo({ log: (m) => this._log(m) });
         runtime.storeSubscriptions([]);
         c._subsSnapshot = [];
@@ -969,17 +1027,42 @@ export class ClashDaemon {
         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) {
+      this._log(`📋 收到订阅配置: ${subs.length} 条，按条启动独立实例（9097+每条递增）...`);
+      // 一条订阅 = 一个实例，逐个应用；单实例失败不影响其余
+      const results = [];
+      for (let i = 0; i < subs.length; i++) {
+        const idx = i + 1;
+        const spec = runtime.instanceSpec(idx);
+        const r = await runtime
+          .applyUserSubscriptions([subs[i]], { index: idx, log: (m) => this._log(`[实例${idx}] ${m}`) })
+          .catch((e) => ({ ok: false, error: e.message }));
+        results.push({ index: idx, url: subs[i].url, ok: !!r.ok, error: r.error || null });
+        this._log(
+          r.ok
+            ? `✓ 实例${idx} (${spec.apiPort}/${spec.mixedPort}) 订阅应用成功: ${subs[i].url.slice(0, 60)}`
+            : `⚠ 实例${idx} (${spec.apiPort}/${spec.mixedPort}) 订阅应用失败: ${r.error}`,
+        );
+      }
+      // 订阅减少 → 回收多余实例
+      const pruned = await runtime.pruneRuntimeInstances(subs.length, { log: (m) => this._log(m) });
+      const failed = results.filter((r) => !r.ok);
+      const allOk = failed.length === 0;
+      if (allOk) {
+        // 全部成功才持久化；部分失败不持久化，服务端下轮心跳重发全量重试（成功实例幂等短路）
         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 ? "" : "（无变化）"}`);
+        this._log(`📋 订阅应用完成（${subs.length} 实例${pruned ? `，回收多余 ${pruned} 个` : ""}）`);
       } else {
-        c._applyResult = { ok: false, error: r.error, at: Date.now() };
-        this._log(`⚠ 订阅应用失败: ${r.error}`);
+        this._log(`⚠ ${failed.length}/${subs.length} 个实例应用失败（未持久化，待下轮心跳重试）: ${failed.map((f) => `实例${f.index}`).join(",")}`);
       }
+      c._subsSnapshot = await api.getSubscriptionSummaries().catch(() => null);
+      c._applyResult = {
+        ok: allOk,
+        changed: true,
+        at: Date.now(),
+        count: subs.length,
+        instances: results.map((r) => ({ index: r.index, apiPort: runtime.instanceSpec(r.index).apiPort, ok: r.ok, error: r.error })),
+        error: allOk ? null : failed.map((f) => `实例${f.index}: ${f.error}`).join("; "),
+      };
       // 结果写健康文件，页面下次心跳可见
       const node = await api.getCurrentNode(checker.CONFIG.groupName).catch(() => "?");
       this._writeHealth(c, { node, healthy: null });

package/src/clash/discover.js

@@ -25,6 +25,13 @@ export const DISCOVER_DEFAULTS = {
   selection: "system-proxy",
 };
 
+/**
+ * 内置 mihomo 多实例上限（一条订阅 = 一个实例）:
+ *   实例 n 的 API 端口 = 9097+(n-1)，mixed 端口 = 7897+(n-1)，secret 统一 abcdefg
+ *   发现/回收均按此端口段枚举（9097-9104 / 7897-7904）
+ */
+export const RUNTIME_MAX_INSTANCES = 8;
+
 // 已知配置文件探测表（决策 4A: Clash Verge 优先）
 const CONFIG_PATHS = (() => {
   const appData = process.env.APPDATA || "";
@@ -313,7 +320,21 @@ async function _collectCandidates({ apiPort, secret, extraPaths }) {
     });
   }
 
-  // 3) 端口枚举兜底（配置文件一无所获时）
+  // 3) 内置 runtime 实例段探测（~/.tt-help/mihomo 拉起的多实例: 9097+N，secret 统一 abcdefg）
+  for (let i = 1; i <= RUNTIME_MAX_INSTANCES; i++) {
+    const rtPort = DISCOVER_DEFAULTS.port + (i - 1);
+    if (candidates.some((c) => c.port === rtPort)) continue;
+    if (await verifyController(rtPort, DISCOVER_DEFAULTS.secret)) {
+      candidates.push({
+        port: rtPort,
+        secret: DISCOVER_DEFAULTS.secret,
+        clientName: "mihomo(内置)",
+        source: `内置实例${i}(${rtPort})`,
+      });
+    }
+  }
+
+  // 4) 端口枚举兜底（配置文件一无所获时）
   if (!candidates.length) {
     const probes = listListeningPorts().map(async (port) => {
       const r = await probeVersion(port, "", 2000);

package/src/clash/runtime.js

@@ -13,7 +13,7 @@
  * 被调用方: daemon.js（自动托管）、CLI（tt-help proxy，共用同一套）
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync, statSync, readdirSync, copyFileSync, openSync, renameSync } from "fs";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync, statSync, readdirSync, copyFileSync, openSync, renameSync, lstatSync, symlinkSync } from "fs";
 import net from "net";
 import { homedir, platform, arch } from "os";
 import { join, dirname } from "path";
@@ -22,7 +22,7 @@ import { gunzipSync } from "zlib";
 import { createHash } from "crypto";
 import { fileURLToPath } from "url";
 import { parseNetstatListeningPids } from "../lib/browser/cdp.js";
-import { DISCOVER_DEFAULTS } from "./discover.js";
+import { DISCOVER_DEFAULTS, RUNTIME_MAX_INSTANCES } from "./discover.js";
 
 const IS_WIN = platform() === "win32";
 
@@ -32,18 +32,35 @@ const IS_WIN = platform() === "win32";
 const PKG_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
 /** 随包内核目录 */
 export const VENDOR_DIR = join(PKG_ROOT, "vendor", "mihomo");
-/** 运行时目录 */
+/** 运行时根目录（实例1；bin/ui/stamp 共享，各实例 config/log/providers 隔离在子目录） */
 export const RUNTIME_DIR = join(homedir(), ".tt-help", "mihomo");
 
-export function runtimePaths() {
+/**
+ * 实例 n（1-based）的端口/目录规格 — 一条订阅 = 一个实例:
+ *   API 端口 = 9097+(n-1)，mixed 端口 = 7897+(n-1)，secret 统一 DISCOVER_DEFAULTS.secret
+ *   实例1 沿用根目录（向后兼容），实例2+ 在 i2/i3/… 子目录（config/providers/run.log 隔离）
+ */
+export function instanceSpec(index = 1) {
+  const n = Math.max(1, Math.floor(index) || 1);
   return {
-    dir: RUNTIME_DIR,
+    index: n,
+    apiPort: DISCOVER_DEFAULTS.port + (n - 1),
+    mixedPort: DISCOVER_DEFAULTS.proxyPort + (n - 1),
+    secret: DISCOVER_DEFAULTS.secret,
+    dir: n <= 1 ? RUNTIME_DIR : join(RUNTIME_DIR, `i${n}`),
+  };
+}
+
+export function runtimePaths(index = 1) {
+  const spec = instanceSpec(index);
+  return {
+    dir: spec.dir,
     bin: join(RUNTIME_DIR, "bin", IS_WIN ? "mihomo.exe" : "mihomo"),
     ui: join(RUNTIME_DIR, "ui"),
-    configFile: join(RUNTIME_DIR, "config.yaml"),
-    logFile: join(RUNTIME_DIR, "run.log"),
+    configFile: join(spec.dir, "config.yaml"),
+    logFile: join(spec.dir, "run.log"),
     stampFile: join(RUNTIME_DIR, ".installed"),
-    providersDir: join(RUNTIME_DIR, "providers"),
+    providersDir: join(spec.dir, "providers"),
   };
 }
 
@@ -62,9 +79,11 @@ const UI_MANIFEST = { file: "metacubexd-dist.tgz", sha256: "93eb334af7e37d213317
 /**
  * 内核/面板下载源（顺序 failover）:
  *   1. ~/.tt-help.json → clash.vendorBase 或环境变量 TT_VENDOR_BASE（覆盖）
- *   2. 自建服务器公网（201 watch 静态路由 /scripts/vendor，免鉴权）
- *   3. 自建服务器内网（农场机器直连）
- *   4. GitHub Releases（仅海外/兜底；农场不可达属预期）
+ *   2. 配置的服务端（~/.tt-help.json → server）→ {server}/scripts/vendor
+ *      （内网 watch 优先：213 等内网机器走内网下载，不绕公网）
+ *   3. 自建服务器公网（201 watch 静态路由 /scripts/vendor，免鉴权）
+ *   4. 自建服务器内网（农场机器直连）
+ *   5. GitHub Releases（仅海外/兜底；农场不可达属预期）
  */
 export function vendorBases() {
   const urls = [];
@@ -76,6 +95,11 @@ export function vendorBases() {
     if (existsSync(cfgPath)) {
       const cfg = JSON.parse(readFileSync(cfgPath, "utf-8"));
       push(cfg?.clash?.vendorBase);
+      const server = String(cfg?.server || "").replace(/\/+$/, "");
+      // 显式配置的服务端地址 → 推导 vendor 下载源（未配置/非 http 则跳过，避免污染 127.0.0.1 默认值）
+      if (/^https?:\/\//.test(server) && !/^https?:\/\/127\.0\.0\.1/.test(server)) {
+        push(`${server}/scripts/vendor`);
+      }
     }
   } catch {}
   push(process.env.TT_VENDOR_BASE);
@@ -309,6 +333,34 @@ function installUIFromArt(artPath, { log = () => {} } = {}) {
   }
 }
 
+/**
+ * 实例目录内就位 ui 入口（子目录实例专用）:
+ *   mihomo 限制 external-ui 必须在 -d 目录子路径内，共享面板在根目录，
+ *   子目录实例建符号链接 ui → ../ui（Windows 用 junction，免管理员权限）
+ * @returns {boolean} 面板入口是否可用
+ */
+export function ensureInstanceUI(index = 1) {
+  if (index <= 1) return true; // 实例1 直用根目录 ui/
+  const { dir } = runtimePaths(index);
+  const link = join(dir, "ui");
+  const target = join(RUNTIME_DIR, "ui");
+  if (!existsSync(target)) return false; // 共享面板未就位，热加载路径不强求面板
+  try {
+    const st = lstatSync(link);
+    if (st.isSymbolicLink()) return true;
+    return true; // 实体目录（老版本残留）也可用
+  } catch {
+    // 不存在 → 建链接
+  }
+  try {
+    mkdirSync(dir, { recursive: true });
+    symlinkSync(target, link, IS_WIN ? "junction" : "dir");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function findFileRecursive(dir, regex) {
   try {
     for (const f of readdirSync(dir, { withFileTypes: true })) {
@@ -375,6 +427,8 @@ export function storeSubscriptions(list) {
  *   external-ui 挂面板（仅启动时生效，所以必须生成时就写入）
  */
 export function buildConfig({ subscriptions, apiPort, secret, mixedPort }) {
+  // external-ui 用相对路径（相对 -d 运行目录）：实例1 直连共享 ui/，
+  // 子目录实例由 ensureInstanceUI 建 ui 符号链接指向共享面板（内核限制: 路径必须在 -d 内）
   const lines = [
     "# 由 tt-help runtime 自动生成 — 手动修改会被覆盖",
     `mixed-port: ${mixedPort}`,
@@ -417,11 +471,11 @@ export function buildConfig({ subscriptions, apiPort, secret, mixedPort }) {
  * 写 config.yaml（内容不变则跳过，返回是否变化）
  * @returns {{ok:boolean, changed:boolean, error?:string}}
  */
-export function writeConfig({ subscriptions, apiPort, secret, mixedPort }) {
-  const { configFile } = runtimePaths();
+export function writeConfig({ subscriptions, apiPort, secret, mixedPort, index = 1 }) {
+  const { configFile, providersDir } = runtimePaths(index);
   try {
-    mkdirSync(RUNTIME_DIR, { recursive: true });
-    mkdirSync(join(RUNTIME_DIR, "providers"), { recursive: true });
+    mkdirSync(runtimePaths(index).dir, { recursive: true });
+    mkdirSync(providersDir, { recursive: true });
     const content = buildConfig({ subscriptions, apiPort, secret, mixedPort });
     const prev = existsSync(configFile) ? readFileSync(configFile, "utf-8") : "";
     if (prev === content) return { ok: true, changed: false };
@@ -563,18 +617,24 @@ export async function runtimeControllerIsOurs(apiPort = DISCOVER_DEFAULTS.port)
   return false;
 }
 
-/** 回收我们拉起的内置 mihomo（清空订阅时调用；外来内核不动） */
-export async function stopRuntimeMihomo({
-  apiPort = DISCOVER_DEFAULTS.port,
-  mixedPort = DISCOVER_DEFAULTS.proxyPort,
-  log = () => {},
-} = {}) {
+/** 回收我们拉起的全部内置 mihomo 实例（清空订阅时调用；外来内核不动） */
+export async function stopRuntimeMihomo({ log = () => {} } = {}) {
   let killed = 0;
-  for (const port of [apiPort, mixedPort]) {
+  for (let i = 1; i <= RUNTIME_MAX_INSTANCES; i++) {
+    killed += await stopRuntimeInstance(i, { log });
+  }
+  return killed;
+}
+
+/** 回收指定实例（按端口找命令行匹配内置目录的进程；外来内核不动） */
+export async function stopRuntimeInstance(index = 1, { log = () => {} } = {}) {
+  const spec = instanceSpec(index);
+  let killed = 0;
+  for (const port of [spec.apiPort, spec.mixedPort]) {
     for (const pid of getListeningPids(port)) {
       const cmd = getProcessCmd(pid);
       if (!cmd || !RUNTIME_DIR_RE.test(cmd)) continue;
-      log(`🧹 回收内置 mihomo (pid ${pid})`);
+      log(`🧹 回收内置 mihomo 实例${index} (pid ${pid})`);
       try {
         if (IS_WIN) {
           execSync(`taskkill /PID ${pid} /T /F`, { stdio: "ignore", timeout: 15000, windowsHide: true });
@@ -588,45 +648,75 @@ export async function stopRuntimeMihomo({
   return killed;
 }
 
+/**
+ * 回收多余实例（订阅减少后调用）：保留前 keepCount 个，其余内置实例逐个回收
+ * @returns {Promise<number>} 回收的实例数
+ */
+export async function pruneRuntimeInstances(keepCount, { log = () => {} } = {}) {
+  let pruned = 0;
+  for (let i = Math.max(1, keepCount) + 1; i <= RUNTIME_MAX_INSTANCES; i++) {
+    const spec = instanceSpec(i);
+    if (!(await controllerAlive(spec.apiPort, spec.secret))) continue;
+    const killed = await stopRuntimeInstance(i, { log });
+    if (killed) {
+      pruned++;
+      log(`🧹 实例${i} (${spec.apiPort}/${spec.mixedPort}) 已回收（订阅已减少）`);
+    }
+  }
+  return pruned;
+}
+
 // ── 进程托管 ──
 
-let _lastSpawnAt = 0;
+/** 拉起冷却（per-instance，防崩溃循环；多实例并行拉起互不阻塞） */
+const _lastSpawnAt = new Map();
 const SPAWN_COOLDOWN_MS = 60_000;
 
 const delay = (ms) => new Promise((r) => setTimeout(r, ms));
 
 /**
- * 确保 mihomo 运行（订阅 = 接管授权）:
+ * 确保 mihomo 实例运行（订阅 = 接管授权）:
  *   - 未配置订阅 → no-subscription，不拉起不占位不碰任何现有代理（用户可自用 Verge）
  *   - 控制端已可用（Verge / 上次拉起的 mihomo）→ adopted，不动（force 模式跳过）
  *   - 端口被 clash 内核签名进程占用 → 清理后拉起（接管）；非内核程序 → port-busy 不抢
  *   - 拉起冷却期内 → cooldown（force 绕过）
  *   - 解压 + 生成配置 + detached 拉起 + 等 API → started / failed
  *
+ * 多实例（一条订阅 = 一个实例）:
+ *   index=1 → 9097/7897 + 根目录（向后兼容）；index=n → 9097+(n-1)/7897+(n-1) + i{n} 子目录
+ *   显式传入 apiPort/mixedPort 时优先（CLI 兼容），否则由 index 推导
+ *
  * @returns {Promise<{status:'no-subscription'|'adopted'|'started'|'port-busy'|'cooldown'|'no-vendor'|'failed', error?:string, bin?:string}>}
  */
 export async function ensureMihomoRunning({
   subscriptions,
   force = false,
-  apiPort = DISCOVER_DEFAULTS.port,
-  secret = DISCOVER_DEFAULTS.secret,
-  mixedPort = DISCOVER_DEFAULTS.proxyPort,
+  index = 1,
+  apiPort,
+  secret,
+  mixedPort,
   log = () => {},
 } = {}) {
+  const spec = instanceSpec(index);
+  apiPort = apiPort || spec.apiPort;
+  secret = secret || spec.secret;
+  mixedPort = mixedPort || spec.mixedPort;
+  const paths = runtimePaths(spec.index);
+
   // 1) 订阅 = 接管授权: 无订阅不拉起、不占位、不碰任何现有代理（用户可自用 Verge）
   const subs = normalizeSubscriptions(subscriptions || readStoredSubscriptions());
   if (!subs.length) {
-    log("⏭ 未配置订阅，内置 mihomo 不参与（后台配置订阅后自动接管）");
+    log(`⏭ 实例${spec.index} 未配置订阅，不拉起`);
     return { status: "no-subscription" };
   }
 
   // 2) 控制端已可用 → 认领（force=订阅接管模式跳过，用于换掉外来内核）
   if (!force && (await controllerAlive(apiPort, secret))) return { status: "adopted" };
 
-  // 3) 冷却期（force=用户主动订阅动作，绕过）
-  const gap = Date.now() - _lastSpawnAt;
+  // 3) 冷却期（per-instance，force=用户主动订阅动作，绕过）
+  const gap = Date.now() - (_lastSpawnAt.get(spec.index) || 0);
   if (!force && gap < SPAWN_COOLDOWN_MS) {
-    return { status: "cooldown", error: `拉起冷却中 ${Math.ceil((SPAWN_COOLDOWN_MS - gap) / 1000)}s` };
+    return { status: "cooldown", error: `实例${spec.index} 拉起冷却中 ${Math.ceil((SPAWN_COOLDOWN_MS - gap) / 1000)}s` };
   }
 
   // 4) 端口占用 → 仅清理 clash 内核签名占用者（Verge 内核等），其余不抢
@@ -642,27 +732,30 @@ export async function ensureMihomoRunning({
     }
   }
 
-  // 5) 落位 + 生成配置
-  _lastSpawnAt = Date.now();
+  // 5) 落位 + 生成配置（bin/ui 共享，config/log/providers 按实例目录隔离）
+  _lastSpawnAt.set(spec.index, Date.now());
   const coreR = await ensureBinary({ log });
   if (!coreR.ok) return { status: "no-vendor", error: coreR.error };
   const uiR = await ensureUI({ log });
   if (!uiR.ok) log(`⚠ 面板就位失败（不影响代理）: ${uiR.error}`);
-  const cfgR = writeConfig({ subscriptions: subs, apiPort, secret, mixedPort });
+  ensureInstanceUI(spec.index); // 子目录实例建 ui 符号链接（内核限制: external-ui 须在 -d 内）
+  const cfgR = writeConfig({ subscriptions: subs, apiPort, secret, mixedPort, index: spec.index });
   if (!cfgR.ok) return { status: "failed", error: `config.yaml 写入失败: ${cfgR.error}` };
 
-  // 6) detached 拉起（daemon 退出不影响代理），日志追加到 run.log
-  const paths = runtimePaths();
+  // 6) detached 拉起（daemon 退出不影响代理），日志追加到实例 run.log
   let logFd;
   try {
     logFd = openSync(paths.logFile, "a");
   } catch {
     logFd = "ignore";
   }
-  const child = spawn(coreR.bin, ["-d", RUNTIME_DIR, "-f", paths.configFile], {
+  const child = spawn(coreR.bin, ["-d", paths.dir, "-f", paths.configFile], {
     detached: true,
     stdio: ["ignore", logFd, logFd],
     windowsHide: true,
+    // 显式指定 cwd：不传会继承父进程工作目录，若在 npm 包目录内启动 tt-help，
+    // detached 常驻的 mihomo 会锁死包目录，导致 npm install -g 重命名时 EBUSY
+    cwd: paths.dir,
   });
   child.unref();
 
@@ -675,13 +768,13 @@ export async function ensureMihomoRunning({
         return { status: "failed", error: "API 已就绪但监听进程非本次拉起的内置内核（端口被旧内核抢占）" };
       }
       log(`✓ 内置 mihomo 已拉起 (pid ${child.pid})，面板: http://127.0.0.1:${apiPort}/ui/`);
-      return { status: "started", pid: child.pid, bin: coreR.bin };
+      return { status: "started", pid: child.pid, bin: coreR.bin, index: spec.index, apiPort, mixedPort };
     }
     if (child.exitCode !== null) {
       return { status: "failed", error: `mihomo 进程退出 (code ${child.exitCode})，见 ${paths.logFile}` };
     }
   }
-  return { status: "failed", error: "mihomo 启动后 API 20s 未就绪" };
+  return { status: "failed", error: `实例${spec.index} 启动后 API 20s 未就绪` };
 }
 
 /**
@@ -691,16 +784,20 @@ export async function ensureMihomoRunning({
  */
 export async function applySubscriptions(
   subscriptions,
-  { apiPort = DISCOVER_DEFAULTS.port, secret = DISCOVER_DEFAULTS.secret, mixedPort = DISCOVER_DEFAULTS.proxyPort, log = () => {} } = {},
+  { index = 1, apiPort, secret, mixedPort, log = () => {} } = {},
 ) {
+  const spec = instanceSpec(index);
+  apiPort = apiPort || spec.apiPort;
+  secret = secret || spec.secret;
+  mixedPort = mixedPort || spec.mixedPort;
   const subs = normalizeSubscriptions(subscriptions);
   if (!subs.length) return { ok: false, error: "订阅列表为空" };
 
-  const cfgR = writeConfig({ subscriptions: subs, apiPort, secret, mixedPort });
+  const cfgR = writeConfig({ subscriptions: subs, apiPort, secret, mixedPort, index: spec.index });
   if (!cfgR.ok) return { ok: false, error: cfgR.error };
 
   if (!cfgR.changed) {
-    log("订阅配置无变化，跳过热加载");
+    log(`实例${spec.index} 订阅配置无变化，跳过热加载`);
     return { ok: true, changed: false };
   }
 
@@ -711,40 +808,43 @@ export async function applySubscriptions(
     const res = await fetch(`http://127.0.0.1:${apiPort}/configs?force=true`, {
       method: "PUT",
       headers,
-      body: JSON.stringify({ path: runtimePaths().configFile }),
+      body: JSON.stringify({ path: runtimePaths(spec.index).configFile }),
       signal: AbortSignal.timeout(15_000),
     });
     if (res.status !== 204) {
       const t = await res.text().catch(() => "");
-      await rollbackConfig(cfgR.prevContent, { apiPort, secret });
+      await rollbackConfig(cfgR.prevContent, { index: spec.index, apiPort, secret });
       return { ok: false, error: `热加载 HTTP ${res.status}: ${t.slice(0, 120)}（已回滚原配置）` };
     }
   } catch (e) {
-    await rollbackConfig(cfgR.prevContent, { apiPort, secret });
+    await rollbackConfig(cfgR.prevContent, { index: spec.index, apiPort, secret });
     return { ok: false, error: `热加载失败: ${e.message}（已回滚盘上配置）` };
   }
 
   const v = await verifyProviders(subs, { apiPort, secret, log });
   if (!v.ok && cfgR.prevContent) {
     // 新订阅不可用（URL 失效/机场挂了）→ 回滚到上一个可用配置，保持代理不断
-    await rollbackConfig(cfgR.prevContent, { apiPort, secret });
-    log("⚠ 新订阅不可用，已回滚到原配置（持久化未变更，代理保持可用）");
+    await rollbackConfig(cfgR.prevContent, { index: spec.index, apiPort, secret });
+    log(`⚠ 实例${spec.index} 新订阅不可用，已回滚到原配置（持久化未变更，代理保持可用）`);
     return { ...v, rolledBack: true };
   }
   return v;
 }
 
 /** 回滚 config.yaml 并热加载（保持盘上配置与运行内核一致） */
-async function rollbackConfig(content, { apiPort = DISCOVER_DEFAULTS.port, secret = DISCOVER_DEFAULTS.secret } = {}) {
+async function rollbackConfig(content, { index = 1, apiPort, secret } = {}) {
   try {
     if (!content) return;
-    writeFileSync(runtimePaths().configFile, content);
+    const spec = instanceSpec(index);
+    apiPort = apiPort || spec.apiPort;
+    secret = secret || spec.secret;
+    writeFileSync(runtimePaths(spec.index).configFile, content);
     const headers = { "Content-Type": "application/json" };
     if (secret) headers.Authorization = `Bearer ${secret}`;
     await fetch(`http://127.0.0.1:${apiPort}/configs?force=true`, {
       method: "PUT",
       headers,
-      body: JSON.stringify({ path: runtimePaths().configFile }),
+      body: JSON.stringify({ path: runtimePaths(spec.index).configFile }),
       signal: AbortSignal.timeout(15_000),
     });
   } catch {}
@@ -791,17 +891,23 @@ export async function verifyProviders(
 }
 
 /**
- * 用户订阅应用入口（后台配置下发唯一路径）。
+ * 用户订阅应用入口（后台配置下发唯一路径，单实例粒度：一条订阅 = 一个实例）。
  *
  * 订阅 = 接管授权（2026-09-25 设计）:
  *   - 内置内核在位 → 热应用（不中断代理；盘上配置一致则短路，顺便自愈崩溃残留）
  *   - 外来内核（Verge 等）占位或无控制端 → 清理端口内核 + 带订阅拉起内置 mihomo
  *   - 新订阅不可用（0 节点/热加载失败）→ 自动回滚上一个可用配置，代理不断
+ *
+ * @param {Array} subs 单条订阅（数组长度 1；多实例循环由 daemon 调度）
+ * @param {number} [opts.index] 实例序号（1-based），决定端口与运行目录
  */
 export async function applyUserSubscriptions(
   subs,
-  { apiPort = DISCOVER_DEFAULTS.port, secret = DISCOVER_DEFAULTS.secret, log = () => {} } = {},
+  { index = 1, apiPort, secret, log = () => {} } = {},
 ) {
+  const spec = instanceSpec(index);
+  apiPort = apiPort || spec.apiPort;
+  secret = secret || spec.secret;
   subs = normalizeSubscriptions(subs);
   if (!subs.length) return { ok: false, error: "订阅列表为空" };
 
@@ -810,11 +916,11 @@ export async function applyUserSubscriptions(
 
   if (ours) {
     // 热应用；盘上配置已一致时由 applySubscriptions 内部短路（顺便自愈崩溃残留）
-    return applySubscriptions(subs, { apiPort, secret, log });
+    return applySubscriptions(subs, { index: spec.index, apiPort, secret, log });
   }
 
   // 外来内核占位或无控制端 → 接管
-  const r = await ensureMihomoRunning({ subscriptions: subs, force: true, apiPort, secret, log });
+  const r = await ensureMihomoRunning({ subscriptions: subs, force: true, index: spec.index, apiPort, secret, log });
   if (r.status !== "started") {
     return { ok: false, error: `接管失败: ${r.status}${r.error ? ` ${r.error}` : ""}` };
   }

package/src/cli/refresh-mini.js

@@ -102,7 +102,8 @@ function spawnClashDaemon() {
     const child = spawn(process.execPath, [mainJs, "clash-daemon"], {
       detached: true,
       stdio: "ignore",
-      cwd: path.dirname(mainJs),
+      // cwd 不能指向包内目录：detached 常驻进程会锁死包目录，导致 npm install -g 重命名时 EBUSY
+      cwd: os.homedir(),
     });
     child.unref();
     spawnedDaemonPid = child.pid;

package/src/watch/public/app.js

@@ -4795,7 +4795,7 @@ async function wdSaveProxySettings() {
     alert(
       "已保存 " +
         (d.subscriptions ? d.subscriptions.length : lines.length) +
-        " 条订阅\n\n客户端将在下次心跳时热应用（无需重启，约 15～30 秒后刷新页面可见订阅用量）。",
+        " 条订阅\n\n每条订阅将启动独立 mihomo 实例（代理端口依次 7897、7898、7899…）。\n客户端将在下次心跳时热应用（无需重启，约 15～30 秒后刷新页面可见订阅用量）。",
     );
   } catch (e) {
     alert("保存失败: " + e.message);

package/src/watch/public/index.html

@@ -786,7 +786,7 @@
     style="display:none;position:fixed;top:0;left:0;right:0;bottom:0;background:rgba(0,0,0,0.6);z-index:9999;align-items:center;justify-content:center">
     <div style="background:#1e1e2e;border:1px solid #333;border-radius:12px;padding:24px;width:90%;max-width:560px">
       <div style="font-size:16px;color:#fbbf24;margin-bottom:4px">🛜 代理订阅配置 — <span id="wdProxyUserId"></span></div>
-      <div style="color:#888;font-size:12px;margin-bottom:12px">每行一个订阅地址（http/https）。保存后客户端下次心跳时自动热应用（无需重启 mihomo），<br>应用成功后此处可看到剩余流量与到期时间；临期（&lt;7天）或超量（剩余&lt;10%）会标红。</div>
+      <div style="color:#888;font-size:12px;margin-bottom:12px">每行一个订阅地址（http/https），<b style="color:#fbbf24">一条订阅 = 一个独立 mihomo 实例</b>：代理端口依次 127.0.0.1:7897、7898、7899…（API 端口 9097 起，同步 +1），各命令用 --proxy 参数指定使用哪个。<br>保存后客户端下次心跳时自动热应用（无需重启），应用成功后此处可看到剩余流量与到期时间；临期（&lt;7天）或超量（剩余&lt;10%）会标红。</div>
       <textarea id="wdProxySubsText" rows="6" placeholder="https://example.com/api/v1/client/subscribe?token=xxxx\nhttps://another-airport.com/sub?token=yyyy"
         style="width:100%;box-sizing:border-box;padding:10px;background:#16161e;border:1px solid #333;border-radius:8px;color:#e0e0e0;font-size:12px;font-family:monospace;resize:vertical"></textarea>
       <div style="display:flex;justify-content:flex-end;gap:8px;margin-top:16px">

package/src/watchdog/upgrader.js

@@ -225,6 +225,8 @@ function spawnChild(args, { logFd, hide = false } = {}) {
     detached: true,
     stdio: ["ignore", logFd || "ignore", logFd || "ignore"],
     windowsHide: hide,
+    // cwd 固定到用户主目录：不传会继承父进程 CWD，若从包目录内启动会把包目录锁死（npm install EBUSY）
+    cwd: homeDir,
   });
   child.unref();
   // 防 spawn 失败（如目标脚本缺失）触发未监听的 'error' 事件静默崩溃；日志落盘可查
@@ -559,7 +561,8 @@ function spawnNewWatchdog(cliPath, args, logFd) {
     const child = spawn(
       "cmd.exe",
       ["/c", "start", "cmd", "/k", process.execPath, cliPath, ...args],
-      { detached: true, stdio: "ignore", windowsHide: true },
+      // cwd 固定到用户主目录：防止新版 watchdog 继承包目录 CWD 锁死包目录（npm install EBUSY）
+      { detached: true, stdio: "ignore", windowsHide: true, cwd: homeDir },
     );
     child.unref();
     child.on("error", (err) => {