tt-help-cli-ycl 1.4.172 → 1.4.175

package/src/watchdog/login-apply.js

@@ -0,0 +1,232 @@
+/**
+ * 登录池节点侧执行器 — applyLogin / clearLogin 的真实浏览器操作
+ *
+ * 流程（applyLogin，F-1→F-11 实证 SOP，见知识库 topics/edge-login-transfer.md）:
+ *   1. 清理该端口残留 Edge（占 user-data-dir 的旧实例必须先杀，否则 ProcessSingleton 转发）
+ *   2. ensureBrowserReady 起 Edge（CDP + 代理出口；代理 = proxyHint > 节点配置 proxy）
+ *   3. CDP context.addCookies 注入明文 cookies
+ *   4. 活实例验证：account/info 接口拿 username（拿到 = 已登录）
+ *   5. 等 ≥35s（Edge flush 周期）→ browser.close() 优雅退出（强杀必丢内存态，实证坑）
+ *   6. 重启复验：从磁盘重新加载 → 再验 username（验证持久化成功）
+ *   7. 全部通过后关闭浏览器（磁盘已有登录态，业务进程下次启动直接带登录）
+ *
+ * clearLogin: 杀 Edge → 删 Cookies 数据库（Default/Network 两位置都清）
+ *
+ * 安全: cookies 明文只在内存流转，不写任何临时文件；日志只打 username/端口。
+ */
+
+import os from "os";
+import path from "path";
+import { existsSync, rmSync } from "fs";
+import { ensureBrowserReady, killEdgeProcesses } from "../lib/browser/cdp.js";
+
+const PERSIST_WAIT_MS = 35 * 1000; // Edge cookie flush 周期裕量（实证 ≥35s）
+const ACCOUNT_INFO_URL = "https://www.tiktok.com/passport/web/account/info/";
+
+/** 与 login-check.js / open.js 一致的端口→profile 目录约定 */
+export function userDataDirForPort(port) {
+  return path.join(
+    os.homedir(),
+    "Library",
+    "Application Support",
+    `Microsoft Edge For Testing_p${port}`,
+  );
+}
+
+/** 硬超时：部分 CDP 操作（如对僵死渲染进程的 page.close）会无限挂起，必须到点打断 */
+function withTimeout(promise, ms, label) {
+  return Promise.race([
+    Promise.resolve(promise),
+    new Promise((_, rej) =>
+      setTimeout(() => rej(new Error(`${label} 超时(${Math.round(ms / 1000)}s)`)), ms),
+    ),
+  ]);
+}
+
+/** proxyHint 归一化："7897" → "http://127.0.0.1:7897" */
+function normalizeProxy(proxyHint, configProxy) {
+  if (proxyHint) {
+    const s = String(proxyHint).trim();
+    if (/^\d+$/.test(s)) return `http://127.0.0.1:${s}`;
+    if (/^https?:\/\//.test(s)) return s;
+    if (/^[\d.]+:\d+$/.test(s)) return `http://${s}`;
+  }
+  return configProxy || null;
+}
+
+/** 活实例登录验证：page 上下文 fetch account/info，拿 username 即已登录 */
+async function verifyLoggedIn(context) {
+  const page = await context.newPage();
+  try {
+    await page.goto("https://www.tiktok.com/", {
+      waitUntil: "domcontentloaded",
+      timeout: 30000,
+    });
+    const r = await page.evaluate(
+      async ({ url, timeout }) => {
+        try {
+          const controller = new AbortController();
+          const timer = setTimeout(() => controller.abort(), timeout);
+          const res = await fetch(url, {
+            signal: controller.signal,
+            credentials: "include",
+            headers: { accept: "application/json" },
+          });
+          clearTimeout(timer);
+          let data = null;
+          try {
+            data = await res.json();
+          } catch {}
+          const d = data?.data || null;
+          return {
+            username: d?.username || d?.unique_id || null,
+            hasAccount: !!d && !!(d.user_id || d.sec_user_id),
+            expired: d?.name === "session_expired" || d?.error_code === 13,
+          };
+        } catch (e) {
+          return { username: null, hasAccount: false, expired: false, error: String(e) };
+        }
+      },
+      { url: ACCOUNT_INFO_URL, timeout: 10000 },
+    );
+    return r;
+  } finally {
+    await withTimeout(page.close(), 5000, "page.close").catch(() => {});
+  }
+}
+
+/** 杀掉占用该端口的 Edge（精确 user-data-dir 匹配，不误伤其他实例） */
+async function stopEdgeForPort(port) {
+  const dir = userDataDirForPort(port);
+  try {
+    await killEdgeProcesses(dir, port);
+  } catch (e) {
+    // killEdgeProcesses 在无匹配进程时可能报错，忽略
+  }
+  await new Promise((r) => setTimeout(r, 3000));
+}
+
+/**
+ * 向指定端口的 Edge profile 注入登录态并验证持久化（带总死线，防止单次操作卡死整个命令队列）
+ * @returns {Promise<{ok: boolean, username?: string, persisted?: boolean, steps?: string[], error?: string}>}
+ */
+export async function applyLoginToPort(opts) {
+  const port = Number(opts.port);
+  try {
+    // 总死线 240s：正常全程 ≈80s（启动+注入+验证+35s flush+重启复验），2倍余量足够
+    return await withTimeout(applyLoginToPortInner(opts), 240000, `applyLogin@${port}`);
+  } catch (e) {
+    // 超时/异常：强清现场（杀该端口 Edge），避免留下僵尸实例占住 CDP
+    try {
+      await withTimeout(stopEdgeForPort(port), 15000, "stopEdge");
+    } catch {}
+    return { ok: false, error: e.message, steps: [] };
+  }
+}
+
+async function applyLoginToPortInner({ port, cookies, proxyHint, username, configProxy }) {
+  const steps = [];
+  const log = (s) => {
+    steps.push(s);
+    console.error(`[登录池] ${s}`);
+  };
+  try {
+    if (!Array.isArray(cookies) || cookies.length === 0) {
+      return { ok: false, error: "cookies 为空", steps };
+    }
+    const proxyServer = normalizeProxy(proxyHint, configProxy);
+    const dir = userDataDirForPort(port);
+
+    // 1. 清理残留实例
+    log(`端口 ${port}: 清理残留 Edge...`);
+    await stopEdgeForPort(port);
+
+    // 2. 起 Edge（CDP + 代理）
+    log(`端口 ${port}: 启动 Edge${proxyServer ? ` (代理 ${proxyServer})` : ""}...`);
+    const browser = await ensureBrowserReady({ port, userDataDir: dir, proxyServer });
+    const context = browser.contexts()[0] || (await browser.newContext());
+
+    // 3. 注入（先清旧 cookie，避免同域残留干扰判定）
+    log(`端口 ${port}: 注入 ${cookies.length} 条 cookies...`);
+    try {
+      await context.clearCookies();
+    } catch {}
+    await context.addCookies(
+      cookies.map((c) => ({
+        name: c.name,
+        value: c.value,
+        domain: c.domain || ".tiktok.com",
+        path: c.path || "/",
+        secure: c.secure !== false,
+        httpOnly: c.httpOnly !== false,
+        ...(typeof c.expires === "number" && c.expires > 0 ? { expires: c.expires } : {}),
+      })),
+    );
+
+    // 4. 活实例验证
+    log(`端口 ${port}: 活实例验证...`);
+    const v = await verifyLoggedIn(context);
+    if (!v.username) {
+      await withTimeout(browser.close(), 20000, "browser.close").catch(() => {});
+      return {
+        ok: false,
+        error: `注入后未登录（${v.expired ? "会话过期" : v.error || "无账号数据"}）`,
+        steps,
+      };
+    }
+    log(`端口 ${port}: 已登录 @${v.username} ✓`);
+
+    // 5. 等 flush + 优雅退出
+    log(`端口 ${port}: 等待 ${PERSIST_WAIT_MS / 1000}s flush 后优雅退出...`);
+    await new Promise((r) => setTimeout(r, PERSIST_WAIT_MS));
+    await withTimeout(browser.close(), 30000, "browser.close(优雅落盘)").catch(() => {});
+    await new Promise((r) => setTimeout(r, 5000));
+
+    // 6. 重启复验（持久化验证）
+    log(`端口 ${port}: 重启复验（磁盘加载）...`);
+    const browser2 = await ensureBrowserReady({ port, userDataDir: dir, proxyServer });
+    const context2 = browser2.contexts()[0] || (await browser2.newContext());
+    const v2 = await verifyLoggedIn(context2);
+    let persisted = !!v2.username;
+    if (persisted) {
+      log(`端口 ${port}: 持久化复验 @${v2.username} ✓`);
+    } else {
+      log(`端口 ${port}: ⚠️ 重启后未保持登录（${v2.expired ? "会话过期" : v2.error || "无账号数据"}）`);
+    }
+    await withTimeout(browser2.close(), 20000, "browser2.close").catch(() => {});
+    await new Promise((r) => setTimeout(r, 3000));
+
+    return { ok: true, username: v.username, persisted, steps };
+  } catch (e) {
+    return { ok: false, error: e.message, steps };
+  }
+}
+
+/**
+ * 清除指定端口 profile 的 TikTok 登录态（杀 Edge + 删 Cookies 库）
+ * @returns {Promise<{ok: boolean, error?: string}>}
+ */
+export async function clearLoginOnPort({ port }) {
+  try {
+    const dir = userDataDirForPort(port);
+    await stopEdgeForPort(port);
+    for (const rel of [
+      path.join("Default", "Cookies"),
+      path.join("Default", "Network", "Cookies"),
+    ]) {
+      const f = path.join(dir, rel);
+      for (const suffix of ["", "-wal", "-shm", "-journal"]) {
+        const p = f + suffix;
+        if (existsSync(p)) {
+          try {
+            rmSync(p);
+          } catch {}
+        }
+      }
+    }
+    console.error(`[登录池] 端口 ${port}: 已清除登录态`);
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}

package/src/watchdog/login-import.js

@@ -0,0 +1,177 @@
+/**
+ * 登录态导入（节点 → 账号中心）— 看门狗启动时独立执行的一步
+ *
+ * 与 login-check 等其他逻辑零耦合：对登录检测配置的端口（loginPorts，服务端下发）
+ * 逐口「起/附 Edge → passport 验证 → 导出 cookies → 上传账号中心」。
+ *
+ * 服务端语义（以号为主键，POST /api/login-pool/import）:
+ *   - 新号 → 入池为【空闲】（导入只是登记，租约只由真实消费产生；pool 模式
+ *     消费方启动时自会 acquire）
+ *   - 已在池 → 幂等跳过（不覆盖、不动租约）；服务端记录 lastImportFrom 来源元数据
+ *
+ * 同步自己起的探测 Edge 在导出后关掉（不残留吃内存）；本来就跑着的不动。
+ * 任何失败仅记录，不阻塞看门狗启动。
+ */
+import { ensureBrowserReady, killEdgeProcesses } from "../lib/browser/cdp.js";
+import { gotoTiktok, whoAmI } from "../lib/login-pool-client.js";
+import { userDataDirForPort } from "./login-apply.js";
+import { readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+// 本地已导入标识：记录端口 → 已同步的登录号。写入即永久跳过（无论账号中心后续状态如何），
+// 保证「永远只导入一次」；文件损坏按无标识处理（重新逐口探测，服务端去重兜底）
+const MARKER_FILE = join(homedir(), ".tt-help-watchdog-login-imported.json");
+
+function loadMarker() {
+  try {
+    const d = JSON.parse(readFileSync(MARKER_FILE, "utf-8"));
+    return d && typeof d === "object" ? d : {};
+  } catch {
+    return {};
+  }
+}
+
+function saveMarker(marker) {
+  try {
+    writeFileSync(MARKER_FILE, JSON.stringify(marker, null, 2), "utf-8");
+  } catch (e) {
+    console.error(`[登录导入] 标识写入失败（不影响导入）: ${e.message}`);
+  }
+}
+
+/** 硬超时：Edge 启动/导航可能挂死，到点打断 */
+function withTimeout(promise, ms, label) {
+  return Promise.race([
+    Promise.resolve(promise),
+    new Promise((_, rej) =>
+      setTimeout(() => rej(new Error(`${label} 超时(${Math.round(ms / 1000)}s)`)), ms),
+    ),
+  ]);
+}
+
+/** 单口导入：起/附 Edge → 验证 → 导出 cookies → 上传。未登录返回 skip */
+async function importPort({ serverUrl, userId, port, proxyServer }) {
+  // 探测该口是否已有 Edge 在跑：同步自己起的，导出完关掉；本来就跑着的不动
+  let selfStarted = false;
+  try {
+    await fetch(`http://127.0.0.1:${port}/json/version`, { signal: AbortSignal.timeout(2000) });
+  } catch {
+    selfStarted = true;
+  }
+  const browser = await ensureBrowserReady({
+    port,
+    userDataDir: userDataDirForPort(port),
+    ...(proxyServer ? { proxyServer } : {}),
+  });
+  const context = browser.contexts()[0] || (await browser.newContext());
+  const page = await context.newPage();
+  try {
+    await gotoTiktok(page);
+    const id = await whoAmI(page);
+    if (!id.hasAccount) {
+      return { ok: false, skip: true, reason: id.expired ? "会话过期" : "未登录" };
+    }
+    // 注意：未登录口不写标识——以后人工登录了还能被导入
+    const cookies = await context.cookies();
+    const res = await fetch(
+      `${String(serverUrl).replace(/\/+$/, "")}/api/login-pool/import`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          userId,
+          port,
+          username: id.username,
+          cookies,
+          note: `节点启动同步 ${new Date().toISOString().slice(0, 10)}`,
+        }),
+        signal: AbortSignal.timeout(30000),
+      },
+    );
+    const j = await res.json().catch(() => null);
+    if (!res.ok || !j || j.error) throw new Error((j && j.error) || `HTTP ${res.status}`);
+    // 成功（含 dedup：中心已有即视为已同步）→ 写本地标识，永久只导一次
+    marker[port] = j.account.username;
+    saveMarker(marker);
+    return { ok: true, dedup: !!j.dedup, username: j.account.username, status: j.account.status };
+  } finally {
+    await page.close().catch(() => {}); // 只关自建页，不清光页面（POC 坑②）
+    if (selfStarted) {
+      // 关掉同步自己起的实例（此刻业务未启动，无占用风险）；本来跑着的不动
+      await killEdgeProcesses(userDataDirForPort(port), port).catch(() => {});
+    }
+  }
+}
+
+/**
+ * 同步入口：逐口导入本节点登录态。
+ * @param {object} opts { serverUrl, userId, ports[], proxyServer?, portTimeoutMs?, totalTimeoutMs? }
+ * @returns {Promise<{imported: Array, skipped: Array, failed: Array}>}
+ */
+export async function syncLoginStates(opts = {}) {
+  const {
+    serverUrl,
+    userId,
+    ports = [],
+    proxyServer = null,
+    portTimeoutMs = 90 * 1000,
+    totalTimeoutMs = 5 * 60 * 1000,
+  } = opts;
+  const summary = { imported: [], skipped: [], failed: [] };
+  if (!serverUrl || !userId || !Array.isArray(ports) || ports.length === 0) return summary;
+  const deadline = Date.now() + totalTimeoutMs;
+
+  // 中心视图：本节点已租的口直接跳过（二次启动热路径，免重复起 Edge）
+  // 热路径：本节点此前已成功导入过的口（lastImportFrom 元数据）直接跳过，免重复起 Edge
+  const imported = new Set();
+  try {
+    const r = await fetch(`${String(serverUrl).replace(/\/+$/, "")}/api/login-pool`, {
+      signal: AbortSignal.timeout(15000),
+    });
+    const j = await r.json();
+    for (const a of j.accounts || []) {
+      const m = a.lastImportFrom;
+      if (m && m.userId === userId && ports.includes(Number(m.port))) {
+        imported.add(Number(m.port));
+      }
+    }
+  } catch (e) {
+    console.error(`[登录导入] 中心视图获取失败（继续逐口尝试）: ${e.message}`);
+  }
+
+  for (const port of ports) {
+    const p = Number(port);
+    if (Date.now() > deadline) {
+      summary.failed.push({ port: p, reason: "总超时" });
+      console.error(`[登录导入] 端口 ${p}: 总超时，剩余端口放弃`);
+      continue;
+    }
+    if (imported.has(p)) {
+      summary.skipped.push({ port: p, reason: "本节点此前已导入" });
+      console.error(`[登录导入] 端口 ${p}: 此前已导入，跳过`);
+      continue;
+    }
+    console.error(`[登录导入] 端口 ${p}: 检测并导入...`);
+    try {
+      const r = await withTimeout(
+        importPort({ serverUrl, userId, port: p, proxyServer }),
+        portTimeoutMs,
+        `端口 ${p} 导入`,
+      );
+      if (r.ok) {
+        summary.imported.push({ port: p, username: r.username, dedup: r.dedup });
+        console.error(
+          `[登录导入] 端口 ${p}: @${r.username} ${r.dedup ? "已在池，幂等跳过" : "新入池（空闲）✓"}`,
+        );
+      } else {
+        summary.skipped.push({ port: p, reason: r.reason });
+        console.error(`[登录导入] 端口 ${p}: 跳过（${r.reason}）`);
+      }
+    } catch (e) {
+      summary.failed.push({ port: p, reason: e.message });
+      console.error(`[登录导入] 端口 ${p}: 失败（${e.message}）`);
+    }
+  }
+  return summary;
+}

package/src/watchdog/upgrader.js

@@ -8,7 +8,7 @@
 
 import { exec, spawn, execFile } from "child_process";
 import { promisify } from "util";
-import { readFileSync, writeFileSync, openSync, unlinkSync } from "fs";
+import { existsSync, readFileSync, writeFileSync, openSync, unlinkSync } from "fs";
 import { fileURLToPath } from "url";
 import { dirname, join } from "path";
 import { homedir, tmpdir } from "os";
@@ -548,6 +548,44 @@ async function listWatchdogPids() {
   }
 }
 
+/** POSIX：旧 watchdog 是否由 systemd 托管（ppid=1 且机器跑 systemd）。
+ *  托管场景杀旧后 systemd(Restart=always) 会自动拉起新版；若再自行 spawn 会双实例——
+ *  同名心跳互踢 + 业务命令双跑（Linux 适配踩坑，F-11 systemd 部署实测）。
+ *  仅 systemd unit ExecStart 直启时 ppid=1；终端手动跑 ppid=shell，走原 spawn 路径。 */
+function isPosixSystemdManaged(oldPid) {
+  if (process.platform === "win32" || !oldPid) return false;
+  try {
+    if (!existsSync("/run/systemd/system")) return false;
+    const stat = readFileSync(`/proc/${oldPid}/stat`, "utf-8");
+    // comm 可含空格/括号：取最后一个 ')' 之后，第 2 个字段为 ppid（stat field 4）
+    const after = stat.slice(stat.lastIndexOf(")") + 1).trim();
+    return parseInt(after.split(/\s+/)[1], 10) === 1;
+  } catch {
+    return false;
+  }
+}
+
+/** systemd 托管升级收尾：不自行 spawn，轮询等 systemd 拉起新版（Restart=always） */
+async function waitSystemdRespawn(beforePids, tag = "upgrade-proc") {
+  const deadline = Date.now() + 60_000;
+  while (Date.now() < deadline) {
+    const newPids = (await listWatchdogPids()).filter(
+      (p) => !beforePids.includes(p),
+    );
+    if (newPids.length > 0) {
+      console.error(
+        `[${tag}] systemd 已拉起新版 watchdog (pid=${newPids.join(",")})，升级完成`,
+      );
+      process.exit(0);
+    }
+    await new Promise((r) => setTimeout(r, 2000));
+  }
+  console.error(
+    `[${tag}] 等待 systemd 拉起新版超时(60s)，请 systemctl status tt-watchdog 排查`,
+  );
+  process.exit(1);
+}
+
 /**
  * 启动新版 watchdog（Windows 方式 2026-09-25 重写 — 214 实测教训）：
  *
@@ -620,6 +658,9 @@ async function runRestartOnlyMode(argv) {
     process.exit(1);
   }
   console.error(`[restart-only] 重启 watchdog (旧 pid=${oldPid})...`);
+  const systemdManaged = isPosixSystemdManaged(oldPid);
+  // 杀旧前快照：systemd 场景用于识别「systemd 拉起的新 pid」
+  const beforePids = systemdManaged ? await listWatchdogPids() : [];
 
   // 杀旧：与完整模式一致（Ctrl+C 优雅 → 强杀 → 清树 → 孤儿 → 关窗）
   const procSnapshot = await snapshotAllProcesses();
@@ -643,6 +684,10 @@ async function runRestartOnlyMode(argv) {
   await killOldWatchdogWindow();
 
   // 启新（与完整模式一致：Windows 弹独立 cmd /k 窗口）
+  if (systemdManaged) {
+    console.error(`[restart-only] systemd 托管：交由 systemd(Restart=always) 拉起新版，不自行 spawn（防双实例）`);
+    return waitSystemdRespawn(beforePids, "restart-only");
+  }
   console.error(`[restart-only] 启动新版 watchdog ...`);
   const cliPath = join(__dirname, "..", "..", "cli.js");
   const args = buildWatchdogArgs({ serverUrl, clientId, intervalSec, noDaemon });
@@ -742,6 +787,10 @@ export async function runUpgradeMode(argv) {
   //      再兜底清理「父已死」的孤儿业务进程，最后关闭旧 watchdog 所在的 cmd 窗口
   //      （按窗口标题匹配 tasklist /V，绕开 WMI——部分机器 WMI 损坏时快照为空）。
   console.error(`[upgrade-proc] 通知旧 watchdog (pid=${oldPid}) 退出 ...`);
+  const systemdManaged = isPosixSystemdManaged(oldPid);
+  // 杀旧前快照：systemd 场景用于识别「systemd 拉起的新 pid」；非 win32 spawn 校验也用它
+  const beforePids =
+    process.platform === "win32" ? [] : await listWatchdogPids();
   const procSnapshot = await snapshotAllProcesses();
   const descPids = listDescendantPids(procSnapshot, oldPid, process.pid);
 
@@ -777,7 +826,15 @@ export async function runUpgradeMode(argv) {
   await killOldWatchdogWindow();
 
   // 4) 旧进程已退，启新版 watchdog
-  //     Windows：显式弹独立交互 cmd 窗口（start → cmd /k），日志直接显示在窗口，
+  //     systemd 托管（POSIX）：杀旧即完成使命，由 systemd(Restart=always) 拉新版；
+  //     自行 spawn 会与 systemd 拉起的实例并行 → 同名心跳互踢 + 业务双跑，防双实例
+  if (systemdManaged) {
+    console.error(
+      `[upgrade-proc] systemd 托管：交由 systemd 拉起新版，不自行 spawn`,
+    );
+    return waitSystemdRespawn(beforePids);
+  }
+  //     Windows：显式弹独立交互 cmd 窗口（start → cmd /k），日志直接显示在窗口,
   //     与旧 cmd /k 窗口解耦（旧窗口控制台在旧 watchdog 被杀后不可复用）
   console.error(`[upgrade-proc] 启动新版 watchdog ...`);
   const cliPath = join(__dirname, "..", "..", "cli.js");
@@ -794,9 +851,6 @@ export async function runUpgradeMode(argv) {
   // Windows 存活校验改读新版 watchdog 写出的标记文件（WMI 损坏时枚举进程表失效），
   // spawn 前先删掉旧 watchdog 的残留，确保读到的是新进程写的
   if (process.platform === "win32") deleteStartedFile();
-  // POSIX：记录启动前的 watchdog 进程集合，用于存活校验前后对比
-  const beforePids =
-    process.platform === "win32" ? [] : await listWatchdogPids();
   let child;
   try {
     child = spawnNewWatchdog(cliPath, args, logFd);