tt-help-cli-ycl 1.3.92 → 1.3.94

package/package.json

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

package/src/cli/comments.js

@@ -1,13 +1,18 @@
 import { chromium } from "playwright";
 import { fetchUserCommentsAPI } from "../lib/api-interceptor-comment.js";
 import { closeCommentPanel } from "../lib/browser/page.js";
-import { server as defaultServer } from "../lib/constants.js";
+import {
+  server as defaultServer,
+  proxy as configuredProxy,
+} from "../lib/constants.js";
 import {
   DEFAULT_TARGET_LOCATIONS,
   isLocationInList,
   normalizeLocation,
 } from "../lib/target-locations.js";
 import { createApiClient } from "../lib/api-client.js";
+import { ensureBrowserReady as ensureBrowserReadyCDP } from "../lib/browser/cdp.js";
+import { delay } from "../lib/delay.js";
 
 async function waitForPageReady(page, timeout = 30000) {
   const startTime = Date.now();
@@ -33,8 +38,6 @@ async function safeEvaluate(page, fn) {
   }
 }
 
-
-
 function isBrowserClosedError(err) {
   if (!err) return false;
   const msg = err.message || err.toString() || "";
@@ -53,20 +56,31 @@ function isBrowserClosedError(err) {
  * 自动模式：循环从服务端取视频任务，抓评论，提交
  */
 async function runAutoMode(options) {
-  const { serverUrl, parallel, interval, maxComments } = options;
+  const {
+    serverUrl,
+    parallel,
+    interval,
+    maxComments,
+    basePort,
+    proxy: proxyOption,
+  } = options;
+  const actualParallel = Math.max(1, parallel || 1);
+  const actualInterval = interval || 10;
+  const actualMaxComments = maxComments || 200;
+  const actualBasePort = basePort || 9222;
+  const effectiveProxy = proxyOption || configuredProxy;
+  let shuttingDown = false;
+
   const { apiGet, apiPost, apiPut } = createApiClient({
     checkStatus: true,
     maxRetries: 2,
     backoff: 2000,
     log: true,
+    meta: { port: actualBasePort },
   });
-  const actualParallel = Math.max(1, parallel || 1);
-  const actualInterval = interval || 10;
-  const actualMaxComments = maxComments || 200;
-  let shuttingDown = false;
 
   console.error(
-    `\n[Comments Auto] 并行: ${actualParallel}, 间隔: ${actualInterval}s, 评论数: ${actualMaxComments}`,
+    `\n[Comments Auto] 并行: ${actualParallel}, 间隔: ${actualInterval}s, 评论数: ${actualMaxComments}, 端口: ${actualBasePort}`,
   );
   console.error(`服务器: ${serverUrl}`);
   console.error(`目标国家: ${DEFAULT_TARGET_LOCATIONS.join(", ")}`);
@@ -110,7 +124,9 @@ async function runAutoMode(options) {
         browser = null;
       }
     }
-    browser = await chromium.connectOverCDP("http://127.0.0.1:9222");
+    const cdpOpts = { port: actualBasePort };
+    if (effectiveProxy) cdpOpts.proxyServer = effectiveProxy;
+    browser = await ensureBrowserReadyCDP(cdpOpts);
     return browser;
   }
 
@@ -131,7 +147,7 @@ async function runAutoMode(options) {
         page = await getPage(browser);
         if (!page) {
           console.error("[Comments Auto] 未找到可用页面，等待中...");
-          await new Promise((r) => setTimeout(r, actualInterval * 1000));
+          await delay(1000, actualInterval * 1000);
           continue;
         }
 
@@ -149,16 +165,16 @@ async function runAutoMode(options) {
             console.error("[Comments Auto] 连续获取失败超过10次，请检查服务端");
             process.exit(1);
           }
-          await new Promise((r) => setTimeout(r, actualInterval * 1000));
+          await delay(1000, actualInterval * 1000);
           continue;
         }
         consecutiveErrors = 0;
 
         if (tasks.length === 0) {
           console.error(
-            `[Comments Auto] 暂无任务，${actualInterval}s 后重试...`,
+            `[Comments Auto] 暂无任务，${actualInterval}s 内随机等待后重试...`,
           );
-          await new Promise((r) => setTimeout(r, actualInterval * 1000));
+          await delay(1000, actualInterval * 1000);
           continue;
         }
 
@@ -298,8 +314,8 @@ async function runAutoMode(options) {
         }
       }
 
-      // 等待间隔
-      await new Promise((r) => setTimeout(r, actualInterval * 1000));
+      // 等待间隔（随机 1~N 秒）
+      await delay(1000, actualInterval * 1000);
     }
   } finally {
     process.removeListener("SIGINT", onSigint);
@@ -316,35 +332,44 @@ export async function handleComments(options) {
     commentsParallel,
     commentsInterval,
     commentsServer,
+    commentsBasePort,
+    commentsProxy,
   } = options;
 
-  // 自动模式：无URL且传了 -s/--server 参数（或任何参数）
-  if (!commentsUrl && process.argv.length > 3) {
+  const effectiveProxy = commentsProxy || configuredProxy;
+
+  // 自动模式：无URL就进入自动模式
+  if (!commentsUrl) {
     return runAutoMode({
-      serverUrl: commentsServer,
+      serverUrl: commentsServer || defaultServer,
       parallel: commentsParallel,
       interval: commentsInterval,
       maxComments: commentsMax || 200,
+      basePort: commentsBasePort || 9222,
+      proxy: effectiveProxy,
     });
   }
 
-  // 手动模式（需要 URL）
-  if (!commentsUrl) {
+  // 手动模式（有 URL）
+  if (commentsUrl) {
     console.error("用法: tt-help comments <视频URL> [最大评论数] [--save]");
     console.error(
       "      tt-help comments [-p N] [-i N] [-s server] [-m maxComments]",
     );
     console.error("");
     console.error("手动模式: tt-help comments <URL> [N] [--save]");
-    console.error("自动模式: tt-help comments -p 1 -i 10 -m 200 -s <server>");
+    console.error("自动模式: tt-help comments          （全部默认值）");
     console.error("");
     console.error(
       "选项: --save           去重后保存到服务端，来源标记为 comment",
     );
     console.error("      -p, --parallel   并行数 (默认 1)");
-    console.error("      -i, --interval   空闲间隔秒 (默认 10)");
-    console.error("      -s, --server     服务端地址");
+    console.error(
+      "      -i, --interval   空闲间隔上限秒 (默认 10，实际 1~N 随机)",
+    );
+    console.error(`      -s, --server     服务端地址 (默认 ${defaultServer})`);
     console.error("      -m, --max-comments 每视频最大评论数 (默认 200)");
+    console.error("      --base-port      浏览器CDP端口 (默认 9222)");
     process.exit(1);
   }
 

package/src/cli/tag.js

@@ -1,13 +1,19 @@
 import { writeFileSync } from "fs";
 import { randomUUID } from "crypto";
+import readline from "readline";
 import { fetchTagData, enrichVideosWithLocation } from "../lib/tag-fetcher.js";
+import { killEdgeProcesses, ensureBrowserReady } from "../lib/browser/cdp.js";
+import { getOrCreatePage } from "../lib/browser/page.js";
 import { TikTokScraper } from "../lib/tiktok-scraper.mjs";
 import {
   DEFAULT_TARGET_LOCATIONS,
   isLocationInList,
 } from "../lib/target-locations.js";
 import { discoverTags } from "../lib/tag-discover.js";
-import { server as cfgServer } from "../lib/constants.js";
+import {
+  server as cfgServer,
+  proxy as configuredProxy,
+} from "../lib/constants.js";
 
 const ALL_COUNTRIES = DEFAULT_TARGET_LOCATIONS;
 const DEFAULT_SERVER = cfgServer || "http://127.0.0.1:3000";
@@ -105,13 +111,14 @@ async function processTag(
   tag,
   index,
   total,
-  { enrich, targetLocations, noFilter, serverUrl, recordTags },
+  { enrich, targetLocations, noFilter, serverUrl, recordTags, port },
 ) {
   const prefix = total > 1 ? `[${index + 1}/${total}]` : "";
   process.stderr.write(`${prefix} 正在获取 #${tag} ... `);
 
   try {
     const result = await fetchTagData(tag, {
+      port: port || 9222,
       onProgress: ({ videos, authors }) => {
         process.stderr.write(
           `\r${prefix} #${tag}: ${videos} 视频, ${authors} 作者`,
@@ -270,56 +277,31 @@ export async function handleDiscover(parsed) {
   }
 }
 
-export async function handleScore(parsed) {
-  const { tagScore } = parsed;
-  const { tag, countries, serverUrl } = tagScore || {};
-
-  if (!tag) {
-    console.error(
-      "用法: tt-help tag score <tag名称> [--countries <CSV>] [-s <服务端>]",
-    );
-    console.error("");
-    console.error("示例:");
-    console.error(
-      "  tt-help tag score ventas                                        # 打分单个标签",
-    );
-    console.error(
-      "  tt-help tag score ventas --countries ES,FR                      # 指定目标国家",
-    );
-    console.error(
-      "  tt-help tag score ventas -s http://127.0.0.1:3001              # 指定服务端",
-    );
-    process.exit(1);
-  }
-
-  const baseUrl = serverUrl || DEFAULT_SERVER;
-  const targetCountries = countries || [
-    "ES",
-    "FR",
-    "DE",
-    "PT",
-    "IT",
-    "NL",
-    "BE",
-    "AT",
-    "IE",
-    "PL",
-    "CZ",
-    "GR",
-    "HU",
-  ];
+function askTagQuestion(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stderr,
+    });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
 
+async function scoreSingleTag(
+  tag,
+  { baseUrl, cdpPort, targetCountries, effectiveProxy },
+) {
   const log = (...args) => process.stderr.write(args.join(" ") + "\n");
+  const progress = (msg) => process.stderr.write(`\r  ${msg}`);
+  const clearLine = () => process.stderr.write("\r" + " ".repeat(80) + "\r");
+
   const startTime = Date.now();
 
   log("");
-  log("========================================");
-  log(`  标签打分: #${tag}`);
-  log(`  目标国家: ${targetCountries.join(", ")}`);
-  log(`  服务端:   ${baseUrl}`);
-  log("  模式:     客户端本地打分（Playwright → enrich → 算分 → 上报）");
-  log("========================================");
-  log("");
+  log(`▶ 开始打分: #${tag}`);
 
   const result = {
     tag,
@@ -334,46 +316,56 @@ export async function handleScore(parsed) {
   };
 
   try {
-    // Step 1: 打开标签页抓取视频
-    log("Step 1/4: 打开 TikTok 标签页抓取视频...");
+    // Step 1: 抓取视频
+    log("  ⏳ 抓取标签页视频...");
     const tagResult = await fetchTagData(tag, {
+      port: cdpPort,
+      proxyServer: effectiveProxy || undefined,
       onProgress: ({ videos, authors }) => {
-        process.stderr.write(`\r  已抓取: ${videos} 视频, ${authors} 作者`);
+        progress(`${videos} 视频, ${authors} 作者`);
       },
     });
+    clearLine();
     log(
-      `\r  完成: ${tagResult.videoCount} 视频, ${tagResult.uniqueAuthorCount} 作者`,
+      `  ✓ 抓取完成: ${tagResult.videoCount} 视频, ${tagResult.uniqueAuthorCount} 作者`,
     );
     result.totalPosts = tagResult.totalPosts || 0;
     result.authorCount = tagResult.uniqueAuthorCount || 0;
 
     let videos = tagResult.videos;
     if (!videos || videos.length === 0) {
-      log("  ⚠️ 没有视频，标记为 dead");
-      result.status = "dead";
-      result.error = "no videos found";
+      if (tagResult.error === "tag_not_found") {
+        log(`  ✗ 标签不存在（TikTok 提示"找不到此话题标签"），标记为 dead`);
+        result.status = "dead";
+        result.error = "tag_not_found";
+      } else {
+        log(`  ✗ 没有视频数据，标记为 dead（可能是网络问题或页面未加载）`);
+        result.status = "dead";
+        result.error = "no videos found";
+      }
       await reportToServer(baseUrl, result);
-      return;
+      return result;
     }
 
-    // Step 2/4: 通过 TikTokScraper.getVideoInfo 逐个视频获取国家
-    log(`Step 2/4: 补充国家信息 (${videos.length} 个视频)...`);
-    const enriched = await enrichVideosWithLocation(videos, {
+    // Step 2: 补充国家信息
+    log(`  ⏳ 补充国家信息 (${videos.length} 个视频)...`);
+    const enrichOpts = {
       mode: "videos",
       onProgress: ({ done, total, current, locationCreated }) => {
         if (done % 10 === 0 || done === total) {
-          process.stderr.write(
-            `\r  [${done}/${total}] ${current.split("/").pop().slice(0, 20)} → ${locationCreated || "-"}`,
-          );
+          const name = current.split("/").pop().slice(0, 20);
+          progress(`[${done}/${total}] ${name} → ${locationCreated || "-"}`);
         }
       },
-    });
+    };
+    if (effectiveProxy) enrichOpts.proxyServer = effectiveProxy;
+    const enriched = await enrichVideosWithLocation(videos, enrichOpts);
+    clearLine();
     videos = enriched.videos;
     const withLoc = videos.filter((v) => v.locationCreated).length;
-    log(`\r  完成: ${withLoc}/${videos.length} 个视频有国家信息`);
+    log(`  ✓ 国家信息: ${withLoc}/${videos.length} 个视频有国家`);
 
-    // Step 3/4: 过滤 + 算分
-    log("Step 3/4: 过滤目标国家 + 计算分数...");
+    // Step 3: 过滤 + 算分
     const { matchedAuthorSet } = applyFilterAndScore(
       videos,
       targetCountries,
@@ -381,16 +373,15 @@ export async function handleScore(parsed) {
     );
 
     log(
-      `  算分: ${result.score}/100 → ${result.status} (匹配 ${result.matchedAuthors}/${result.authorCount} 作者)`,
+      `  ✓ 算分: ${result.score}/100 → ${result.status} (匹配 ${result.matchedAuthors}/${result.authorCount} 作者)`,
     );
     if (result.matchedCountries.length > 0) {
       log(
-        `  国家: ${result.matchedCountries.map((c) => `${c.c}:${c.n}`).join(", ")}`,
+        `     国家分布: ${result.matchedCountries.map((c) => `${c.c}:${c.n}`).join(", ")}`,
       );
     }
 
-    // Step 4/4: 推送用户 + 上报结果
-    log("Step 4/4: 推送用户到服务端 + 上报打分结果...");
+    // Step 4: 推送 + 上报
     if (result.matchedAuthors > 0) {
       const pushResult = await pushToServer(
         baseUrl,
@@ -398,15 +389,17 @@ export async function handleScore(parsed) {
         videos,
       );
       result.pushedUsers = pushResult.added || 0;
+      log(`  ✓ 推送用户: ${result.pushedUsers} 人`);
     }
     await reportToServer(baseUrl, result);
   } catch (e) {
-    log(`❌ 错误: ${e.message}`);
+    clearLine();
+    log(`  ✗ 错误: ${e.message}`);
     result.error = e.message;
     try {
       await reportToServer(baseUrl, result);
     } catch {}
-    return;
+    return result;
   }
 
   const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
@@ -418,16 +411,141 @@ export async function handleScore(parsed) {
         : result.status === "dead"
           ? "🔴"
           : "⚪";
-  log("");
-  log("----------------------------------------");
-  log(`  ${icon} 打分完成 (${elapsed}s)`);
-  log(`  状态: ${result.status}  分数: ${result.score}/100`);
   log(
-    `  视频作者: ${result.authorCount}  匹配: ${result.matchedAuthors}  推送: ${result.pushedUsers}`,
+    `  ${icon} #${tag} 完成 (${elapsed}s) — 分数: ${result.score}/100, 状态: ${result.status}`,
   );
-  log("----------------------------------------");
 
-  console.log(JSON.stringify(result, null, 2));
+  return result;
+}
+
+export async function handleScore(parsed) {
+  const { tagScore } = parsed;
+  const { tag, countries, serverUrl, port, proxy: cliProxy } = tagScore || {};
+
+  const baseUrl = serverUrl || DEFAULT_SERVER;
+  const cdpPort = port || 9222;
+  const effectiveProxy = cliProxy || configuredProxy;
+  const targetCountries = countries || [
+    "ES",
+    "FR",
+    "DE",
+    "PT",
+    "IT",
+    "NL",
+    "BE",
+    "AT",
+    "IE",
+    "PL",
+    "CZ",
+    "GR",
+    "HU",
+  ];
+
+  const log = (...args) => process.stderr.write(args.join(" ") + "\n");
+
+  if (!tag) {
+    log("");
+    log("╔══════════════════════════════════════════╗");
+    log(
+      "║     标签打分模式  (CDP: " +
+        cdpPort +
+        "  国家: " +
+        targetCountries.slice(0, 6).join(",") +
+        "...)",
+    );
+    log("║  多个 tag 用逗号/空格分隔                 ║");
+    log("║  quit/q 退出  |  回车重复上一个           ║");
+    log("╚══════════════════════════════════════════╝");
+    log("");
+  }
+
+  // 解析 tag：支持逗号或空格分隔多个 tag
+  const parseTags = (input) =>
+    input
+      .split(/[,，\s]+/)
+      .map((t) => t.trim().replace("#", "").toLowerCase())
+      .filter(Boolean);
+
+  let tagQueue = tag ? parseTags(tag) : [];
+
+  while (true) {
+    // 从队列取 tag，没有则交互式输入
+    let currentTag = tagQueue.shift();
+
+    if (!currentTag) {
+      const answer = await askTagQuestion(
+        `请输入标签名称 (多个用逗号/空格分隔, quit/q 退出): `,
+      );
+      if (
+        !answer ||
+        answer.trim().toLowerCase() === "quit" ||
+        answer.trim().toLowerCase() === "q"
+      ) {
+        log("再见！");
+        break;
+      }
+      const tags = parseTags(answer);
+      if (tags.length > 1) {
+        // 倒序入队，保证顺序正确
+        for (let i = tags.length - 1; i >= 0; i--) {
+          tagQueue.push(tags[i]);
+        }
+      }
+      currentTag = tags[0];
+    }
+
+    const remaining = tagQueue.length;
+    if (remaining > 0) {
+      log(`  [排队中: 还有 ${remaining} 个标签待处理]`);
+    }
+
+    await scoreSingleTag(currentTag, {
+      baseUrl,
+      cdpPort,
+      targetCountries,
+      effectiveProxy,
+    });
+
+    // 如果队列还有 tag，自动继续；否则询问
+    if (tagQueue.length > 0) {
+      continue;
+    }
+
+    const answer = await askTagQuestion(
+      `\n请输入下一个标签 (直接回车重复上一个, quit/q 退出): `,
+    );
+    if (!answer || answer.trim() === "") {
+      // 重复上一个：入队后 continue，会被 while 开头 shift 出来
+      tagQueue.unshift(currentTag);
+      continue;
+    }
+    if (
+      answer.trim().toLowerCase() === "quit" ||
+      answer.trim().toLowerCase() === "q"
+    ) {
+      log("再见！");
+      break;
+    }
+    const tags = parseTags(answer);
+    if (tags.length > 1) {
+      for (let i = tags.length - 1; i >= 0; i--) {
+        tagQueue.push(tags[i]);
+      }
+    } else {
+      tagQueue.push(tags[0]);
+    }
+  }
+
+  // 退出时关闭浏览器
+  log("");
+  log(`正在关闭 CDP 端口 ${cdpPort} 对应的浏览器...`);
+  try {
+    killEdgeProcesses(null, cdpPort);
+    log("浏览器已关闭");
+  } catch (e) {
+    log(`关闭浏览器失败: ${e.message}`);
+  }
+  log("");
 }
 
 async function reportToServer(baseUrl, result, clientId, meta) {
@@ -448,9 +566,17 @@ async function reportToServer(baseUrl, result, clientId, meta) {
 
 export async function handleScoreAll(parsed) {
   const { tagScoreAll } = parsed;
-  let { countries, serverUrl, autoDiscover } = tagScoreAll || {};
+  let {
+    countries,
+    serverUrl,
+    autoDiscover,
+    port,
+    proxy: cliProxy,
+  } = tagScoreAll || {};
 
   const baseUrl = serverUrl || DEFAULT_SERVER;
+  const cdpPort = port || 9222;
+  const effectiveProxy = cliProxy || configuredProxy;
   const targetCountries = countries || [
     "ES",
     "FR",
@@ -470,16 +596,25 @@ export async function handleScoreAll(parsed) {
   const log = (...args) => process.stderr.write(args.join(" ") + "\n");
 
   log("");
-  log("========================================");
-  log("  自动循环打分模式（客户端本地执行）");
-  log(`  目标国家: ${targetCountries.join(", ")}`);
-  log(`  服务端:   ${baseUrl}`);
-  if (autoDiscover) log(`  自动发现: 开启（无任务时自动生成标签）`);
-  log("  流程: 从服务端拉 tag → 本地 Playwright 抓取 → enrich → 算分 → 上报");
-  log("  每个标签约 1-2 分钟");
-  log("========================================");
+  log("╔══════════════════════════════════════════╗");
+  log("║     自动循环打分模式（CDP 连接已登录浏览器）");
+  log("║  目标国家: " + targetCountries.slice(0, 6).join(",") + "...");
+  log("║  服务端:   " + baseUrl);
+  log(
+    "║  CDP 端口: " +
+      cdpPort +
+      (effectiveProxy ? "  代理: " + effectiveProxy : ""),
+  );
+  if (autoDiscover) log("║  自动发现: 开启");
+  log("╚══════════════════════════════════════════╝");
   log("");
 
+  // 连接 CDP 浏览器
+  const cdpOpts = { port: cdpPort };
+  if (effectiveProxy) cdpOpts.proxyServer = effectiveProxy;
+  const browser = await ensureBrowserReady(cdpOpts);
+  const page = await getOrCreatePage(browser);
+
   let totalScored = 0;
   let emptyRounds = 0; // 连续无任务的轮数
   const DISCOVER_AFTER_EMPTY = 3; // 连续 3 轮无任务时触发 discover
@@ -489,7 +624,10 @@ export async function handleScoreAll(parsed) {
   const clientMeta = { type: "scoring" };
 
   // 复用 TikTokScraper 实例，避免每次 enrich 都启动/关闭 headless 浏览器
-  const enrichScraper = new TikTokScraper({ poolSize: 3 });
+  const enrichScraper = new TikTokScraper({
+    poolSize: 3,
+    proxyServer: effectiveProxy || undefined,
+  });
   await enrichScraper.init();
   log("✅ TikTokScraper 已就绪 (enrich 复用)");
   log(`  客户端 ID: ${clientId.substring(0, 8)}...`);
@@ -581,9 +719,10 @@ export async function handleScoreAll(parsed) {
           continue;
         }
 
-        // 抓取视频
+        // 抓取视频（CDP 连接已登录 Edge）
         log(`  抓取 TikTok 标签页...`);
         const tagResult = await fetchTagData(tag, {
+          port: cdpPort,
           onProgress: ({ videos, authors }) => {
             process.stderr.write(`\r  抓取中: ${videos} 视频, ${authors} 作者`);
           },
@@ -606,7 +745,7 @@ export async function handleScoreAll(parsed) {
         }
 
         // enrich: 逐个视频查 view-source 获取国家
-        const enriched = await enrichVideosWithLocation(videos, {
+        const enrichOpts = {
           mode: "videos",
           existingScraper: enrichScraper,
           onProgress: ({ done, total, current, locationCreated }) => {
@@ -616,12 +755,11 @@ export async function handleScoreAll(parsed) {
               );
             }
           },
-        });
+        };
+        if (effectiveProxy) enrichOpts.proxyServer = effectiveProxy;
+        const enriched = await enrichVideosWithLocation(videos, enrichOpts);
         videos = enriched.videos;
 
-        // 更新 meta 中当前正在处理的标签
-        clientMeta.tag = tag;
-
         // 过滤 + 算分 (共用函数)
         const { matchedAuthorSet } = applyFilterAndScore(
           videos,
@@ -696,6 +834,13 @@ export async function handleScoreAll(parsed) {
   } finally {
     await enrichScraper.close();
     log("✅ TikTokScraper 已关闭");
+    log("正在关闭 CDP 浏览器...");
+    try {
+      killEdgeProcesses(null, cdpPort);
+      log("浏览器已关闭");
+    } catch (e) {
+      log(`关闭浏览器失败: ${e.message}`);
+    }
   }
 }