tt-help-cli-ycl 1.4.112 → 1.4.114

package/src/lib/constants.js

@@ -148,6 +148,7 @@ const HELP_TEXT = [
   `      --location <国家代码>     国家筛选，逗号分隔，默认 ${DEFAULT_TARGET_LOCATIONS_CSV}`,
   "      --job-locations <国家>    任务国家筛选，逗号分隔（仅筛选服务端任务），基于真实国家字段 location_created",
   "      --max-videos <数量>       每用户最大视频数，默认 16",
+  "      --mini                   精简模式：只采集视频列表及由视频推导的信息（EC视频、最新发布时间），跳过用户信息、国家采样、关注/粉丝与商品详情，大幅提速",
   "      --enable-follow           启用关注/粉丝提取（默认启用）",
   "      --disable-follow          禁用关注/粉丝提取",
   "      --max-following <数量>    最大获取关注数，默认 100",
@@ -162,6 +163,27 @@ const HELP_TEXT = [
   "--proxy <地址>            浏览器代理（如 socks5://127.0.0.1:1080），未指定时使用配置文件 proxy",
   "--webserver <URL>         集中式视频国家查询服务（如 http://127.0.0.1:3000），省去本地 Playwright 浏览器",
   "",
+  "  tt-help refresh-mini [选项]",
+  "    视频信息更新专用客户端：固定 CDP 端口 4222，只做 mini 采集（视频列表+视频推导信息）",
+  "    不检测登录、不做多账户轮换；Clash 节点自动轮换（每 10 分钟主动切换）",
+  "    验证码 → 等待人工在浏览器中解决（超时兜底切节点）",
+  "    被封 / 连续任务错误 ≥ 3 / CDN 限流连续 ≥ 3 → 切换代理节点",
+  "    选项:",
+  "      --server <URL>            服务端地址，默认 http://127.0.0.1:3001",
+  `      --location <国家代码>     国家筛选，逗号分隔，默认 ${DEFAULT_TARGET_LOCATIONS_CSV}`,
+  "      --job-locations <国家>    任务国家筛选，逗号分隔（仅筛选服务端任务）",
+  "      --max-videos <数量>       每用户最大视频数，默认 16",
+  "      --max-users <数量>        最大处理用户数，默认无限制",
+  "      -i, --interval <秒数>     无任务时轮询间隔，默认 30 秒",
+  "      --max-age <秒数>          最小刷新间隔，默认 0（不限）",
+  "      --port <端口号>           固定 CDP 端口，默认 4222",
+  "      --user-id <编号>          客户端编号（设备ID），默认自动生成",
+  "      --rotate-min <分钟>       代理节点轮换周期，默认 10（0=关闭定时轮换）",
+  "      --captcha-wait-min <分钟> 验证码等待人工解决上限，默认 10",
+  "      --ensure-daemon           启动时检查 clash-daemon 是否存活，未存活则自动拉起（默认不检测）",
+  "      --preset <预设>           延迟预设 fast/normal/slow/stealth，默认 normal",
+  "      --proxy <地址>            浏览器代理（默认走 Clash 本地端口，切换节点才有效）",
+  "",
   "  tt-help precheck [选项]",
   "    对目标商家用户进行轻量预检，通过 HTTP 获取 videoCount 判断是否有新视频",
   "    有更新 → 标记 pending_refresh=1（等待 refresh 客户端完整采集）",

package/src/main.js

@@ -13,6 +13,7 @@ import { handleVideoStats } from "./cli/videostats.js";
 import { handleDbImport } from "./cli/db-import.js";
 import { handleWebserver } from "./cli/webserver.js";
 import { handleRefresh } from "./cli/refresh.js";
+import { handleRefreshMini } from "./cli/refresh-mini.js";
 import { handlePrecheck } from "./cli/precheck.js";
 import {
   handleTag,
@@ -54,6 +55,8 @@ async function main() {
       return handleDbImport(parsed);
     case "refresh":
       return handleRefresh(parsed);
+    case "refresh-mini":
+      return handleRefreshMini(parsed);
     case "precheck":
       return handlePrecheck(parsed);
     case "tag":

package/src/npm-main.js

@@ -9,6 +9,7 @@ import { handleConfig, showConfig, showUsage, version } from "./cli/config.js";
 import { handleOpen } from "./cli/open.js";
 import { handleComments } from "./cli/comments.js";
 import { handleRefresh } from "./cli/refresh.js";
+import { handleRefreshMini } from "./cli/refresh-mini.js";
 import { handlePrecheck } from "./cli/precheck.js";
 import { handleWebserver } from "./cli/webserver.js";
 import {
@@ -55,6 +56,8 @@ async function main() {
       return handleComments(parsed);
     case "refresh":
       return handleRefresh(parsed);
+    case "refresh-mini":
+      return handleRefreshMini(parsed);
     case "precheck":
       return handlePrecheck(parsed);
     case "tag":

package/src/scraper/explore-core.js

@@ -28,6 +28,7 @@ async function processExplore(page, username, options, log) {
     proxyServer = null,
     webserverUrl = null,
     noProduct = false,
+    mini = false, // 精简模式：仅采集视频数据，跳过用户信息/国家采样/关注粉丝/商品详情
   } = options;
 
   const result = {
@@ -63,13 +64,17 @@ async function processExplore(page, username, options, log) {
     log(`  访问 @${username} 主页...`);
     const videoList = await collectVideos(page, username, maxVideos, log);
 
-    log("  获取用户信息...");
-    const info = await getUserInfo(page);
-    if (info) {
-      result.userInfo = info;
-      log(
-        `  用户: ${info.nickname || username} | 粉丝: ${info.followerCount || "-"} | 视频: ${info.videoCount || "-"}`,
-      );
+    if (!mini) {
+      log("  获取用户信息...");
+      const info = await getUserInfo(page);
+      if (info) {
+        result.userInfo = info;
+        log(
+          `  用户: ${info.nickname || username} | 粉丝: ${info.followerCount || "-"} | 视频: ${info.videoCount || "-"}`,
+        );
+      }
+    } else {
+      log("  [mini] 跳过用户信息");
     }
 
     const captcha = await detectCaptcha(page);
@@ -132,8 +137,8 @@ async function processExplore(page, username, options, log) {
       };
 
       // 如果有商品链接且未禁用，通过 WebService API 抓取商品详情页（评分、销量等）
-      // --no-product 时跳过（由独立商品程序异步补抓，避免阻塞 explore/refresh 主流程）
-      if (topVideo.seoUrl && options.webserverUrl && !noProduct) {
+      // --no-product / mini 模式时跳过（由独立商品程序异步补抓，避免阻塞主流程）
+      if (topVideo.seoUrl && options.webserverUrl && !noProduct && !mini) {
         try {
           const resp = await fetch(
             `${options.webserverUrl}/api/tiktok/product`,
@@ -166,6 +171,16 @@ async function processExplore(page, username, options, log) {
       return result;
     }
 
+    // mini 模式：跳过国家采样与关注/粉丝，仅登记视频列表，大幅提速
+    if (mini) {
+      result.keepFollow = false;
+      result.hasFollowData = false;
+      result.videoList = videoArray;
+      result.processed = true;
+      log(`  [mini] 仅采集视频数据，跳过国家采样与关注/粉丝`);
+      return result;
+    }
+
     // 国家采样判断
     // explore 模式：采样 5 个，优先命中目标国家，不匹配则回退众数 → 写 locationCreated
     // refresh 模式：采样 7 个，纯众数逻辑 → 写 confirmedLocation（二次确认）

package/src/watch/llm-config.js

@@ -177,6 +177,20 @@ export function getLlmConfig() {
   };
 }
 
+/**
+ * 获取完整 LLM 配置（含完整 API Key）— 仅供本机内部服务使用
+ * 由 /api/llm-config/raw 端点暴露，该端点仅允许 127.0.0.1 访问
+ */
+export function getLlmConfigRaw() {
+  if (!_loaded) loadLlmConfig();
+  return {
+    provider: _cachedProvider,
+    model: _cachedModel,
+    url: _cachedUrl,
+    apiKey: _cachedApiKey,
+  };
+}
+
 /** 获取当前 LLM URL（内部调用） */
 export function getLlmUrl() {
   if (!_loaded) loadLlmConfig();

package/src/watch/server.js

@@ -447,6 +447,23 @@ export function startWatchServer(
         }
       }
 
+      // ── LLM 完整配置端点（仅本机可访问，供看门狗独立服务动态拉取） ──
+      if (req.method === "GET" && routePath === "/api/llm-config/raw") {
+        const remote = req.socket.remoteAddress || "";
+        const isLocal =
+          remote === "127.0.0.1" ||
+          remote === "::1" ||
+          remote === "::ffff:127.0.0.1";
+        if (!isLocal) {
+          console.error(`[llm-raw] 拒绝非本机访问: ${remote}`);
+          sendJSON(res, 403, { error: "forbidden" });
+          return;
+        }
+        const { getLlmConfigRaw } = await import("./llm-config.js");
+        sendJSON(res, 200, getLlmConfigRaw());
+        return;
+      }
+
       if (req.method === "POST" && routePath === "/api/users") {
         try {
           const { usernames, sources, guessedLocation } = await readBody(req);

package/src/watchdog/process-manager.js

@@ -24,6 +24,60 @@ const IS_WIN = process.platform === "win32";
 const SPAWN_STAGGER_MS = 30000; // 批量启动时每个进程间隔 30 秒，避免抢网络
 const STALE_LOG_TIMEOUT_MS = 15 * 60 * 1000; // 15 分钟无日志输出视为假死
 
+// === 控制台日志格式化（仅显示层增强，不影响任何功能链路） ===
+// 目标：多进程日志交错打印时，通过时间戳 + 固定宽度彩色 [cmdId] 前缀方便人眼分流。
+// 兼容：Windows（Windows Terminal 彩色 / 旧 conhost 自动降级纯文本）与 macOS（原生 ANSI 彩色）。
+
+// 每进程固定一种颜色（按 cmdId 哈希取色），新增进程自动分配且不重复
+const PROC_COLORS = [32, 36, 33, 35, 34, 92, 96, 93, 95, 94];
+const ID_PAD_WIDTH = 10; // cmdId 前缀固定宽度，短 ID 补齐保持消息列对齐
+
+function getProcColor(id) {
+  let sum = 0;
+  const s = String(id);
+  for (let i = 0; i < s.length; i++) sum = (sum + s.charCodeAt(i)) % 997;
+  return PROC_COLORS[sum % PROC_COLORS.length];
+}
+
+function canUseColor() {
+  if (!process.stderr.isTTY) return false;
+  if (process.env.NO_COLOR) return false;
+  if (process.env.FORCE_COLOR === "1" || process.env.FORCE_COLOR === "true")
+    return true;
+  // macOS 终端恒 ≥4；Windows Terminal ≥4；旧 conhost 未开启 VT 时为 1 → 自动降级纯文本
+  const depth =
+    typeof process.stderr.getColorDepth === "function"
+      ? process.stderr.getColorDepth()
+      : 1;
+  return depth >= 4;
+}
+
+function fmtClock(d = new Date()) {
+  const p = (n) => String(n).padStart(2, "0");
+  return `${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
+}
+
+/**
+ * 打印子进程日志行（替代裸 console.error）。
+ * 只改显示形态，msg 内容一行不少；多行消息逐行加前缀。
+ */
+function printProcessLine(id, msg) {
+  const lines = String(msg).split(/\r?\n/);
+  const prefixId = `[${String(id).padEnd(ID_PAD_WIDTH)}]`;
+  const color = getProcColor(id);
+  const useColor = canUseColor();
+  for (const line of lines) {
+    const clock = fmtClock();
+    if (useColor) {
+      process.stderr.write(
+        `\x1b[90m${clock}\x1b[0m \x1b[${color}m${prefixId}\x1b[0m ${line}\n`,
+      );
+    } else {
+      process.stderr.write(`${clock} ${prefixId} ${line}\n`);
+    }
+  }
+}
+
 // 从命令行中提取 CDP 端口列表（解析 --base-port 和 --port-count）
 function extractCdpPorts(cmdLine) {
   const match = cmdLine.match(/--base-port\s+(\d+)/);
@@ -219,7 +273,10 @@ export class ProcessManager extends EventEmitter {
       const msg = data.toString().trim();
       if (msg) {
         const short = msg.substring(0, 200);
-        console.error(`[${id}] ${short}`);
+        // 仅显示层格式化：时间戳 + 彩色固定宽度前缀，内容不变。
+        // 前缀优先用命令名（如 explore-F1），未命名时退回 cmdId。
+        const displayId = (cmdDef && cmdDef.name) || id;
+        printProcessLine(displayId, short);
         // 环形缓冲：保留最近 N 行供 LLM 分析
         const info = this.processes.get(id);
         if (info) {

package/src/watchdog/reporter.js

@@ -39,6 +39,7 @@ export function getClientConfig() {
       const cfg = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
       return {
         server: cfg.server || "",
+        watchdogServer: cfg.watchdogServer || "",
         proxy: cfg.proxy || "",
         browser: cfg.browser || "",
         userId: cfg.userId || "",

package/src/watchdog/standalone-server.js

@@ -0,0 +1,228 @@
+/**
+ * 看门狗独立服务 — 与 watch 完全隔离的独立进程
+ *
+ * 复用 src/watch/watchdog-server.js 的全部看门狗逻辑
+ * （内存状态 + ~/.tt-help-watchdog.json 持久化），
+ * 不接触 watch 的 SQLite 数据库、不依赖 watch 的 http 服务。
+ *
+ * 用法:
+ *   node src/watchdog/standalone-server.js [--port 17302]
+ *   WATCHDOG_PORT=17302 node src/watchdog/standalone-server.js
+ *
+ * LLM 配置（可选，仅影响 POST /api/watchdog/analyze-logs）:
+ *   环境变量 LLM_URL / LLM_MODEL / APIKEY，缺省时用 llm-config 内置默认值。
+ *   本进程永不打开 SQLite（getDb() 恒为 null），LLM 配置自动走环境变量兜底。
+ */
+
+import http from "http";
+import {
+  existsSync,
+  createReadStream,
+  readFileSync,
+  writeFileSync,
+} from "fs";
+import { extname, join, normalize, dirname, sep } from "path";
+import { fileURLToPath } from "url";
+import { homedir } from "os";
+import {
+  registerWatchdogRoutes,
+  tryHandleWatchdogRoute,
+} from "../watch/watchdog-server.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PUBLIC_DIR = join(__dirname, "..", "watch", "public");
+
+// ── 端口解析：--port 参数 > WATCHDOG_PORT 环境变量 > 默认 17302 ──
+function resolvePort() {
+  const argv = process.argv.slice(2);
+  const idx = argv.indexOf("--port");
+  if (idx !== -1 && argv[idx + 1]) {
+    const p = parseInt(argv[idx + 1], 10);
+    if (p > 0 && p < 65536) return p;
+  }
+  const env = parseInt(process.env.WATCHDOG_PORT, 10);
+  if (env > 0 && env < 65536) return env;
+  return 17302;
+}
+
+// ── watch 端口（本机 127.0.0.1）：--watch-port 参数 > WATCHDOG_WATCH_PORT 环境变量 > 默认 3011 ──
+function resolveWatchPort() {
+  const argv = process.argv.slice(2);
+  const idx = argv.indexOf("--watch-port");
+  if (idx !== -1 && argv[idx + 1]) {
+    const p = parseInt(argv[idx + 1], 10);
+    if (p > 0 && p < 65536) return p;
+  }
+  const env = parseInt(process.env.WATCHDOG_WATCH_PORT, 10);
+  if (env > 0 && env < 65536) return env;
+  return 3011;
+}
+
+// LLM 配置本地缓存（“以前的”配置，watch 不可达时兜底）
+const LLM_CACHE_PATH = join(homedir(), ".tt-help-watchdog-llm.json");
+const WATCH_PORT = resolveWatchPort();
+
+/**
+ * 动态刷新 LLM 配置：
+ * 1. 从 watch 的受限端点 /api/llm-config/raw（仅 127.0.0.1）拉取完整配置
+ * 2. 拉取成功 → 注入环境变量 + 更新本地缓存
+ * 3. 拉取失败 → 读本地缓存（“以前的”）注入
+ * 4. reloadLlmConfig() 强制 llm-config 重读 env（绕开其 _loaded 缓存）
+ */
+async function refreshLlmConfig() {
+  let cfg = null;
+  try {
+    const resp = await fetch(
+      `http://127.0.0.1:${WATCH_PORT}/api/llm-config/raw`,
+      { signal: AbortSignal.timeout(3000) },
+    );
+    if (resp.ok) {
+      cfg = await resp.json();
+      if (cfg && cfg.apiKey) {
+        try {
+          writeFileSync(LLM_CACHE_PATH, JSON.stringify(cfg, null, 2), "utf-8");
+        } catch {}
+        console.error(
+          `[watchdog-standalone] LLM 配置已从 watch 刷新并更新本地缓存 (model=${cfg.model})`,
+        );
+      }
+    }
+  } catch {}
+
+  if (!cfg || !cfg.apiKey) {
+    try {
+      if (existsSync(LLM_CACHE_PATH)) {
+        cfg = JSON.parse(readFileSync(LLM_CACHE_PATH, "utf-8"));
+        if (cfg && cfg.apiKey) {
+          console.error(
+            "[watchdog-standalone] watch LLM 端点不可达，使用本地缓存配置",
+          );
+        }
+      }
+    } catch {}
+  }
+
+  if (cfg) {
+    if (cfg.apiKey) process.env.APIKEY = cfg.apiKey;
+    if (cfg.url) process.env.LLM_URL = cfg.url;
+    if (cfg.model) process.env.LLM_MODEL = cfg.model;
+  }
+  try {
+    const { reloadLlmConfig } = await import("../watch/llm-config.js");
+    reloadLlmConfig();
+  } catch {}
+}
+
+const MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+};
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => (body += chunk));
+    req.on("end", () => {
+      try {
+        resolve(body ? JSON.parse(body) : {});
+      } catch (e) {
+        reject(e);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+
+function sendJSON(res, code, data) {
+  res.writeHead(code, { "Content-Type": "application/json; charset=utf-8" });
+  res.end(JSON.stringify(data));
+}
+
+// 静态文件（仅限 public 目录内，防路径穿越）
+function serveStatic(res, pathname) {
+  let decoded;
+  try {
+    decoded = decodeURIComponent(pathname);
+  } catch {
+    sendJSON(res, 400, { error: "bad request" });
+    return;
+  }
+  const filePath =
+    decoded === "/"
+      ? join(PUBLIC_DIR, "index.html")
+      : join(PUBLIC_DIR, decoded);
+  const normalized = normalize(filePath);
+  const base = normalize(PUBLIC_DIR);
+  if (normalized !== base && !normalized.startsWith(base + sep)) {
+    sendJSON(res, 403, { error: "forbidden" });
+    return;
+  }
+  if (!existsSync(normalized)) {
+    sendJSON(res, 404, { error: "not found" });
+    return;
+  }
+  const ext = extname(normalized).toLowerCase();
+  res.writeHead(200, {
+    "Content-Type": MIME_TYPES[ext] || "application/octet-stream",
+  });
+  createReadStream(normalized).pipe(res);
+}
+
+const server = http.createServer(async (req, res) => {
+  const url = new URL(req.url, "http://127.0.0.1");
+  const routePath = url.pathname;
+  const params = Object.fromEntries(url.searchParams.entries());
+
+  // analyze-logs 前动态刷新 LLM 配置（watch 换 key 无需重启本服务）
+  if (req.method === "POST" && routePath === "/api/watchdog/analyze-logs") {
+    await refreshLlmConfig();
+  }
+
+  // 看门狗 API：复用 watchdog-server.js 的完整路由
+  if (routePath.startsWith("/api/watchdog/")) {
+    try {
+      let body = {};
+      if (req.method === "POST") body = await readBody(req);
+      const handled = await tryHandleWatchdogRoute(
+        routePath,
+        req.method,
+        params,
+        body,
+        res,
+      );
+      if (handled) return;
+      sendJSON(res, 404, { error: "watchdog route not found" });
+      return;
+    } catch (e) {
+      sendJSON(res, 400, { error: e.message });
+      return;
+    }
+  }
+
+  // 其余 GET：serve watch 的前端静态页（看门狗页签同源可用）
+  if (req.method === "GET" || req.method === "HEAD") {
+    serveStatic(res, routePath);
+    return;
+  }
+
+  sendJSON(res, 404, { error: "not found" });
+});
+
+const port = resolvePort();
+registerWatchdogRoutes(server);
+server.listen(port, "0.0.0.0", () => {
+  console.error(
+    `[watchdog-standalone] 看门狗独立服务已启动: http://0.0.0.0:${port}`,
+  );
+  console.error(`[watchdog-standalone] 前端页面: http://<本机IP>:${port}/`);
+  console.error(
+    `[watchdog-standalone] LLM 配置源: http://127.0.0.1:${WATCH_PORT}/api/llm-config/raw（本地缓存兜底: ${LLM_CACHE_PATH}）`,
+  );
+  // 启动后异步预热 LLM 配置（不阻塞启动，失败静默）
+  refreshLlmConfig().catch(() => {});
+});