ppxc-leads-mcp 0.1.0

package/README.md

@@ -0,0 +1,115 @@
+# PPXC Leads MCP
+
+把 PPXC「从评论区发现高意向客户」的能力，做成智能体可直接调用的 MCP 工具包。
+
+> **先读这两份，再动手：**
+> 1. [`AGENTS.md`](./AGENTS.md) — 本仓库的硬性边界规则（AI 协作员必读第一文件）
+> 2. [`docs/开发手册.md`](./docs/开发手册.md) — 架构、工具契约、平台适配层、验收标准
+>
+> 产品化（从本地半成品到正式可分发小组件）的路线：[`docs/产品化规划-2026-06-11.md`](./docs/产品化规划-2026-06-11.md)
+
+## 安装（一行配置）
+
+在支持 MCP 的智能体（Claude 桌面版 / Cursor / 其他）配置里加一段：
+
+```json
+{
+  "mcpServers": {
+    "ppxc-leads": {
+      "command": "npx",
+      "args": ["-y", "ppxc-leads-mcp"],
+      "env": {
+        "ELECTRON_MIRROR": "https://npmmirror.com/mirrors/electron/"
+      }
+    }
+  }
+}
+```
+
+- 首次使用会自动下载运行环境（约 100MB），国内网络保留上面的 `ELECTRON_MIRROR` 配置可显著提速。
+- 默认连 PPXC 生产站；开发联调时在 `env` 里加 `PPXC_API_BASE` 指向本地后端。
+- 装好后对智能体说「检查登录状态」，按提示完成 PPXC 登录和平台扫码即可使用。
+
+## 一句话定位
+
+用户在智能体里一行配置装好本工具包；首次登录 PPXC 账号 + 按需扫各平台二维码；之后对智能体说「分析这条内容 / 用这个词在小红书找客户」，工具包用自带的隐藏浏览器内核抓取数据、送 PPXC 后端分析，把「总体判断 + 高意向客户 + 跟进话术 + 内容选题」直接返回给智能体。
+
+## 支持的平台
+
+| 平台 | 链接分析评论 | 关键词搜索 | 数据获取方式 |
+|---|---|---|---|
+| 抖音 | ✅ | ✅ | 页内 fetch + 搜索 sniffer（已真机验证） |
+| 小红书 | ✅ 真机验证通过（2026-06-11） | ✅ 真机验证通过（2026-06-11） | CDP 监听 + 滚动；笔记页需带 xsec_token 签名链接 |
+| 快手 | ✅ 真机验证通过（2026-06-11） | ✅ 真机验证通过（2026-06-11） | CDP 监听 graphql（rootCommentsV2）；搜索走 /rest/v/search/feed |
+
+## 它不是什么
+
+- **不是**桌面客户端：没有产品界面，唯一允许出现的窗口是登录窗和验证码窗
+- **不是**浏览器插件：不依赖用户手动安装插件
+- **不是**爬虫平台：借用户本人登录态、保守频率、撞验证就请真人处理，不做任何过验证 / 共享账号的灰色手段
+
+## 形态（方案 A：自带浏览器内核的 CDP MCP）
+
+```
+智能体（Claude / Cursor / ...）
+   │  MCP 协议（stdio）
+   ▼
+本工具包（无界面后台进程）
+   ├── MCP 协议层      ← 7 个 tool，platform 参数 / 链接自动识别
+   ├── 浏览器执行层    ← 平台插座 + 三平台方言件 + 隐藏窗口内核
+   └── 后端对接层      ← 调 PPXC 生产后端的同步分析接口
+```
+
+## 工具
+
+| 工具 | 用户场景 | 状态 |
+|---|---|---|
+| `check_status_and_login` | 检查 PPXC + 抖音/小红书/快手登录；`login_*` 弹对应扫码窗 | 已接入三平台 |
+| `list_products` | 列出账号下产品，拿 productId | 第二期 |
+| `analyze_video_comments` | 给内容链接 + 产品 → 读评论 → AI 分析 → 战报 + 入池；platform 可省略 | 抖音已验；小红书/快手待真机 |
+| `search_keyword_for_leads` | 给关键词 + **platform** → 搜内容 → 读评论 → 分析 → 汇总战报 | 抖音已验；小红书/快手待真机 |
+| `suggest_search_keywords` | 开搜前先要词：读后端想词委员会为产品生成的精选搜索词（带词型+理由） | 0.2 新增 |
+| `query_leads` | 问「之前挖到的客户 / 高意向有哪些」→ 只读查客户池，支持按词/天数/状态筛 | 0.2 新增 |
+| `export_diagnostics` | 用户说「不好用 / 要反馈」→ 把运行日志打包成桌面上的诊断文件 | 已实测 |
+
+## 桌面战报（0.2）
+
+两件分析工具挖到客户后，会在用户桌面自动生成一份**客户战报**（自包含网页文件，离线可开）：总览数字、行动清单（先跟谁 + 为什么）、客户卡片（评论原话 / 判断理由 / 一键复制话术 / 主页直达）、每个词的成绩单。可转发给同事直接照着跟进。
+
+## 官方技能说明书（教智能体怎么用）
+
+[`skills/ppxc-find-customers/SKILL.md`](./skills/ppxc-find-customers/SKILL.md) 是给智能体的标准工作流：先查登录 → 选产品 → 要词 → 开搜 → 固定格式汇报（含战报文件位置）→ 隔天复盘换词，并写死了额度 / 验证码 / 电力的应对话术。装进 Claude / Cursor 等宿主的技能目录即可，npm 包里也随包分发。
+
+## 风控（按平台分日额度 + 全局 30 秒间隔）
+
+详见 [`docs/开发手册.md` §8](./docs/开发手册.md)。小红书/快手初版比抖音更保守。
+
+## 仓库关系（重要）
+
+本仓库**独立**，不与 `/Users/jianshi/ppxc`（网页 + 后端）、`/Users/jianshi/ppxc-desktop`（桌面客户端稳定线）共享代码、分支、git 历史。
+
+- 后端：本仓库作为 PPXC 后端的**客户端**调用；分析接口 `POST /api/v2/comments/analyze` 在 `ppxc` 仓库，支持 `userProfileUrl` 按平台传入主页链接。
+- 桌面客户端：从 `ppxc-desktop` 稳定线**单向搬运**执行内核，搬完解耦。
+
+详细边界见 [`AGENTS.md`](./AGENTS.md)。
+
+## 开发状态
+
+✅ **抖音三期主链路均已真机验证**（链接分析 + 关键词搜索 + 入池）。
+
+🟡 **多平台适配层（2026-06-11）**：
+
+- 阶段 A：`platform-runner` + `platforms/*` 插座架构；抖音逻辑平移；`typecheck` + `build` + `regression:static` 通过。
+- 阶段 B：**小红书真机验证通过**——扫码登录、关键词搜索（17 笔记/20 评论）、短链笔记拉评论（10 评论 + 主页链接）三链路实测 OK。探路结论：① 访客也有 web_session cookie，登录态必须读页面状态；② 笔记页必须带 xsec_token 签名链接，裸链接会被「暂时无法浏览」拦截；③ 短链跳转在慢网络下需轮询等待。MCP 工具层端到端（含后端分析+入池）待联调。
+- 阶段 C：**快手真机验证通过**——扫码登录、关键词搜索（20 视频/18 评论）、单视频链接拉评论（13 评论 + 主页链接）三链路实测 OK。探路结论：① 扫码先发 passToken（id.kuaishou.com），主站会话票叫 `kuaishou.server.webday7_st`（带灰度后缀且 httpOnly），userId/did 都不能当登录凭证；② 搜索接口是 `/rest/v/search/feed`（作者在 feed 级、评论数字段不可靠）；③ 视频页评论走 graphql `visionCommentList`，真数据在 `rootCommentsV2`（老字段是空壳）。MCP 工具层端到端（含后端分析+入池）待联调。
+- 阶段 D：后端 `userProfileUrl` 优先使用 MCP 传入的主页链接；开发手册/README 已更新。
+
+验证命令：
+
+```bash
+npm run regression:static          # 静态回归（无需登录）
+npm run smoke:comments             # 抖音 smoke（需登录 + PPXC_MCP_VIDEO_URL）
+PPXC_MCP_PLATFORM=xiaohongshu PPXC_MCP_LOGIN=1 npm run spike:probe   # 小红书探路
+```
+
+运行与验证步骤：见 [`docs/第一期-运行与验证.md`](./docs/第一期-运行与验证.md)。

package/dist/backend/config.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getApiBase = getApiBase;
+exports.isHttpUrl = isHttpUrl;
+const PRODUCTION_API_BASE = "https://opc1.me";
+function getApiBase() {
+    const raw = (process.env.PPXC_API_BASE || PRODUCTION_API_BASE).trim().replace(/\/+$/, "");
+    return raw;
+}
+function isHttpUrl(value) {
+    return /^https?:\/\//i.test(value);
+}
+//# sourceMappingURL=config.js.map

package/dist/backend/ppxc-client.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PpxcApiError = void 0;
+exports.listProducts = listProducts;
+exports.analyzeComments = analyzeComments;
+exports.getCommitteeKeywords = getCommitteeKeywords;
+exports.triggerCommitteeRun = triggerCommitteeRun;
+exports.queryLeads = queryLeads;
+const logger_1 = require("../browser/kernel/logger");
+const version_1 = require("../version");
+const config_1 = require("./config");
+const token_store_1 = require("./token-store");
+const log = logger_1.logger.scope("ppxc-client");
+const LIST_TIMEOUT_MS = 15000;
+const ANALYZE_TIMEOUT_MS = 180000;
+class PpxcApiError extends Error {
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = "PpxcApiError";
+    }
+}
+exports.PpxcApiError = PpxcApiError;
+function authHeaders() {
+    const token = (0, token_store_1.readToken)();
+    if (!token)
+        throw new PpxcApiError(401, "PPXC 未登录");
+    return {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+        "X-PPXC-MCP-Version": version_1.OWN_VERSION,
+    };
+}
+function handleUnauthorized() {
+    (0, token_store_1.clearToken)();
+    return new PpxcApiError(401, "PPXC 登录已失效");
+}
+async function fetchWithTimeout(url, init, timeoutMs) {
+    try {
+        return await fetch(url, { ...init, signal: AbortSignal.timeout(timeoutMs) });
+    }
+    catch (err) {
+        if (err instanceof Error && (err.name === "TimeoutError" || err.name === "AbortError")) {
+            throw new PpxcApiError(0, `后端响应超时（${Math.round(timeoutMs / 1000)} 秒）`);
+        }
+        throw err;
+    }
+}
+async function listProducts() {
+    const res = await fetchWithTimeout(`${(0, config_1.getApiBase)()}/api/v2/products`, { method: "GET", headers: authHeaders() }, LIST_TIMEOUT_MS);
+    if (res.status === 401)
+        throw handleUnauthorized();
+    if (!res.ok)
+        throw new PpxcApiError(res.status, `获取产品列表失败 (${res.status})`);
+    const data = (await res.json());
+    const arr = Array.isArray(data) ? data : [];
+    return arr
+        .map((p) => {
+        const obj = p;
+        const id = String(obj.id ?? "").trim();
+        const name = String(obj.product_name ?? obj.productName ?? obj.name ?? "").trim();
+        return { id, name };
+    })
+        .filter((p) => p.id);
+}
+async function analyzeComments(input) {
+    const body = {
+        productId: input.productId,
+        videoUrl: input.videoUrl ?? "",
+        videoDesc: input.videoDesc ?? "",
+        save: input.save !== false,
+        comments: input.comments.map((c) => ({
+            text: c.text,
+            nickname: c.nickname,
+            userSecUid: c.userSecUid,
+            userProfileUrl: c.userProfileUrl,
+            avatarUrl: c.avatarUrl,
+            ipLabel: c.ipLabel,
+            createTime: c.createTime,
+        })),
+    };
+    const res = await fetchWithTimeout(`${(0, config_1.getApiBase)()}/api/v2/comments/analyze`, { method: "POST", headers: authHeaders(), body: JSON.stringify(body) }, ANALYZE_TIMEOUT_MS);
+    if (res.status === 401)
+        throw handleUnauthorized();
+    if (res.status === 403)
+        throw new PpxcApiError(403, "无权访问该产品");
+    if (!res.ok) {
+        let detail = `分析失败 (${res.status})`;
+        try {
+            const err = (await res.json());
+            if (err?.error)
+                detail = err.error;
+        }
+        catch {
+        }
+        throw new PpxcApiError(res.status, detail);
+    }
+    const data = (await res.json());
+    log.info("analyze done", {
+        analyzed: data.summary?.commentsAnalyzed,
+        demands: data.summary?.demandsFound,
+        saved: data.saved,
+    });
+    return data;
+}
+async function getCommitteeKeywords(productId) {
+    const url = `${(0, config_1.getApiBase)()}/api/v2/keywords/committee?productId=${encodeURIComponent(productId)}`;
+    const res = await fetchWithTimeout(url, { method: "GET", headers: authHeaders() }, LIST_TIMEOUT_MS);
+    if (res.status === 401)
+        throw handleUnauthorized();
+    if (res.status === 403)
+        throw new PpxcApiError(403, "无权访问该产品");
+    if (!res.ok)
+        throw new PpxcApiError(res.status, `读取搜词词单失败 (${res.status})`);
+    const data = (await res.json());
+    return {
+        generationStatus: data.generationStatus ?? "not_started",
+        errorMessage: data.errorMessage ?? "",
+        keywords: Array.isArray(data.keywords) ? data.keywords : [],
+    };
+}
+async function triggerCommitteeRun(productId) {
+    const res = await fetchWithTimeout(`${(0, config_1.getApiBase)()}/api/v2/keywords/committee/retry`, { method: "POST", headers: authHeaders(), body: JSON.stringify({ productId }) }, LIST_TIMEOUT_MS);
+    if (res.status === 401)
+        throw handleUnauthorized();
+    if (res.status === 403)
+        throw new PpxcApiError(403, "无权访问该产品");
+    if (res.status === 503)
+        throw new PpxcApiError(503, "想词功能未对该产品开启");
+    if (!res.ok)
+        throw new PpxcApiError(res.status, `触发想词失败 (${res.status})`);
+    log.info("committee run triggered", { productId });
+}
+const LEADS_TIMEOUT_MS = 30000;
+async function queryLeads(opts) {
+    const params = new URLSearchParams();
+    if (opts.productId)
+        params.set("productId", opts.productId);
+    if (opts.keyword)
+        params.set("keyword", opts.keyword);
+    if (opts.since)
+        params.set("since", opts.since);
+    const qs = params.toString();
+    const url = `${(0, config_1.getApiBase)()}/api/v2/leads${qs ? `?${qs}` : ""}`;
+    const res = await fetchWithTimeout(url, { method: "GET", headers: authHeaders() }, LEADS_TIMEOUT_MS);
+    if (res.status === 401)
+        throw handleUnauthorized();
+    if (res.status === 403)
+        throw new PpxcApiError(403, "无权访问该产品");
+    if (!res.ok)
+        throw new PpxcApiError(res.status, `查询客户池失败 (${res.status})`);
+    const data = (await res.json());
+    const paywallLocked = res.headers.get("x-ppxc-paywall") === "locked";
+    return { rows: Array.isArray(data) ? data : [], paywallLocked };
+}
+//# sourceMappingURL=ppxc-client.js.map

package/dist/backend/ppxc-login-window.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPpxcLoggedIn = isPpxcLoggedIn;
+exports.openPpxcLoginWindow = openPpxcLoginWindow;
+exports.logoutPpxc = logoutPpxc;
+const electron_1 = require("electron");
+const logger_1 = require("../browser/kernel/logger");
+const config_1 = require("./config");
+const token_store_1 = require("./token-store");
+const log = logger_1.logger.scope("ppxc-login");
+const LOGIN_PARTITION = "persist:ppxc-mcp-login";
+const LOGIN_TIMEOUT_MS = 10 * 60 * 1000;
+const EXCHANGE_DELAY_MS = 150;
+let activeLoginWindow = null;
+async function tryExchangeToken(win) {
+    if (win.isDestroyed())
+        return null;
+    try {
+        const script = `
+      (async () => {
+        try {
+          const r = await fetch('/api/auth/extension-token', { credentials: 'include' });
+          if (!r.ok) return { ok: false };
+          return (await r.json().catch(() => null)) || { ok: false };
+        } catch (e) { return { ok: false }; }
+      })()
+    `;
+        return (await win.webContents.executeJavaScript(script, true)) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function isPpxcLoggedIn() {
+    return (0, token_store_1.readToken)() !== null;
+}
+async function openPpxcLoginWindow() {
+    const apiBase = (0, config_1.getApiBase)();
+    if (!(0, config_1.isHttpUrl)(apiBase)) {
+        return { ok: false, code: "api_base_invalid", message: "后端地址无效，请配置 PPXC_API_BASE" };
+    }
+    if (activeLoginWindow && !activeLoginWindow.isDestroyed()) {
+        activeLoginWindow.focus();
+        return { ok: false, code: "user_cancelled", message: "登录窗口已在打开中" };
+    }
+    const win = new electron_1.BrowserWindow({
+        title: "登录 PPXC",
+        width: 460,
+        height: 680,
+        show: false,
+        autoHideMenuBar: true,
+        minimizable: false,
+        maximizable: false,
+        webPreferences: {
+            contextIsolation: true,
+            nodeIntegration: false,
+            sandbox: true,
+            partition: LOGIN_PARTITION,
+        },
+    });
+    win.webContents.setAudioMuted(true);
+    activeLoginWindow = win;
+    const allowedOrigin = (() => {
+        try {
+            return new URL(apiBase).origin;
+        }
+        catch {
+            return null;
+        }
+    })();
+    const isAllowedUrl = (url) => {
+        try {
+            return allowedOrigin !== null && new URL(url).origin === allowedOrigin;
+        }
+        catch {
+            return false;
+        }
+    };
+    win.webContents.setWindowOpenHandler(() => ({ action: "deny" }));
+    const blockForeignNavigation = (event, url) => {
+        if (isAllowedUrl(url))
+            return;
+        event.preventDefault();
+        log.info("blocked foreign navigation in login window");
+    };
+    win.webContents.on("will-navigate", blockForeignNavigation);
+    win.webContents.on("will-redirect", blockForeignNavigation);
+    const loginUrl = `${apiBase}/login?redirect=${encodeURIComponent("/inbox")}&from=mcp`;
+    log.info("opening ppxc login window", { apiBase });
+    try {
+        await win.loadURL(loginUrl);
+    }
+    catch (err) {
+        log.warn("load login url failed", err instanceof Error ? err.message : String(err));
+        if (!win.isDestroyed())
+            win.destroy();
+        activeLoginWindow = null;
+        return { ok: false, code: "network_error", message: "无法打开登录页，请检查后端地址是否可达" };
+    }
+    win.show();
+    return new Promise((resolve) => {
+        let settled = false;
+        let timer = null;
+        let exchangePending = null;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            if (exchangePending)
+                clearTimeout(exchangePending);
+            try {
+                win.removeAllListeners("closed");
+                if (!win.isDestroyed())
+                    win.close();
+            }
+            catch {
+            }
+            activeLoginWindow = null;
+            resolve(result);
+        };
+        timer = setTimeout(() => finish({ ok: false, code: "timeout", message: "登录超时，请重试" }), LOGIN_TIMEOUT_MS);
+        win.on("closed", () => {
+            if (!settled)
+                finish({ ok: false, code: "user_cancelled", message: "登录窗口被关闭，没完成登录" });
+        });
+        const scheduleExchange = () => {
+            if (settled || win.isDestroyed())
+                return;
+            if (exchangePending)
+                clearTimeout(exchangePending);
+            exchangePending = setTimeout(async () => {
+                exchangePending = null;
+                if (settled || win.isDestroyed())
+                    return;
+                const result = await tryExchangeToken(win);
+                if (!result || !result.ok || !result.extensionToken)
+                    return;
+                (0, token_store_1.writeToken)(result.extensionToken);
+                const u = result.user || {};
+                log.info("ppxc login success", { userId: u.id ? String(u.id) : "?" });
+                finish({
+                    ok: true,
+                    user: {
+                        id: String(u.id ?? ""),
+                        email: String(u.email ?? ""),
+                        name: typeof u.name === "string" ? u.name : null,
+                    },
+                });
+            }, EXCHANGE_DELAY_MS);
+        };
+        win.webContents.on("did-navigate", scheduleExchange);
+        win.webContents.on("did-navigate-in-page", scheduleExchange);
+        win.webContents.on("did-finish-load", scheduleExchange);
+        scheduleExchange();
+    });
+}
+async function logoutPpxc() {
+    try {
+        const ses = electron_1.session.fromPartition(LOGIN_PARTITION);
+        await ses.clearStorageData({ storages: ["cookies", "localstorage"] });
+    }
+    catch (err) {
+        log.warn("clear login partition failed", err instanceof Error ? err.message : String(err));
+    }
+}
+//# sourceMappingURL=ppxc-login-window.js.map

package/dist/backend/token-store.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readToken = readToken;
+exports.writeToken = writeToken;
+exports.clearToken = clearToken;
+const electron_1 = require("electron");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const logger_1 = require("../browser/kernel/logger");
+const log = logger_1.logger.scope("token-store");
+function tokenFilePath() {
+    return node_path_1.default.join(electron_1.app.getPath("userData"), "ppxc-token.json");
+}
+function jwtExpiryMs(token) {
+    try {
+        const payloadPart = token.split(".")[1];
+        if (!payloadPart)
+            return null;
+        const json = Buffer.from(payloadPart, "base64url").toString("utf8");
+        const payload = JSON.parse(json);
+        return typeof payload.exp === "number" ? payload.exp * 1000 : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readToken() {
+    try {
+        const raw = (0, node_fs_1.readFileSync)(tokenFilePath(), "utf8");
+        const parsed = JSON.parse(raw);
+        const token = typeof parsed.token === "string" ? parsed.token.trim() : "";
+        if (!token)
+            return null;
+        const expMs = jwtExpiryMs(token);
+        if (expMs !== null && expMs <= Date.now()) {
+            log.info("ppxc token expired, clearing");
+            clearToken();
+            return null;
+        }
+        return token;
+    }
+    catch {
+        return null;
+    }
+}
+function writeToken(token) {
+    try {
+        (0, node_fs_1.writeFileSync)(tokenFilePath(), JSON.stringify({ token }), { mode: 0o600 });
+        log.info("ppxc token saved");
+    }
+    catch (err) {
+        log.error("failed to save ppxc token", err instanceof Error ? err.message : String(err));
+    }
+}
+function clearToken() {
+    try {
+        (0, node_fs_1.rmSync)(tokenFilePath(), { force: true });
+    }
+    catch {
+    }
+}
+//# sourceMappingURL=token-store.js.map

package/dist/browser/comments.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDouyinShortLink = exports.extractAwemeId = exports.commentsFromJson = exports.buildCommentUrl = void 0;
+var comments_1 = require("./platforms/douyin/comments");
+Object.defineProperty(exports, "buildCommentUrl", { enumerable: true, get: function () { return comments_1.buildCommentUrl; } });
+Object.defineProperty(exports, "commentsFromJson", { enumerable: true, get: function () { return comments_1.commentsFromJson; } });
+Object.defineProperty(exports, "extractAwemeId", { enumerable: true, get: function () { return comments_1.extractAwemeId; } });
+Object.defineProperty(exports, "isDouyinShortLink", { enumerable: true, get: function () { return comments_1.isDouyinShortLink; } });
+//# sourceMappingURL=comments.js.map

package/dist/browser/douyin-runner.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapSearchResultForDouyin = exports.shutdownRunner = exports.startPlatformLogin = exports.startDouyinLogin = exports.searchKeywordsBatch = exports.searchKeywordForLeads = exports.getLoginStatus = exports.fetchContentComments = exports.fetchVideoComments = exports.RunnerError = void 0;
+var platform_runner_1 = require("./platform-runner");
+Object.defineProperty(exports, "RunnerError", { enumerable: true, get: function () { return platform_runner_1.RunnerError; } });
+Object.defineProperty(exports, "fetchVideoComments", { enumerable: true, get: function () { return platform_runner_1.fetchVideoComments; } });
+Object.defineProperty(exports, "fetchContentComments", { enumerable: true, get: function () { return platform_runner_1.fetchContentComments; } });
+Object.defineProperty(exports, "getLoginStatus", { enumerable: true, get: function () { return platform_runner_1.getLoginStatus; } });
+Object.defineProperty(exports, "searchKeywordForLeads", { enumerable: true, get: function () { return platform_runner_1.searchKeywordForLeads; } });
+Object.defineProperty(exports, "searchKeywordsBatch", { enumerable: true, get: function () { return platform_runner_1.searchKeywordsBatch; } });
+Object.defineProperty(exports, "startDouyinLogin", { enumerable: true, get: function () { return platform_runner_1.startDouyinLogin; } });
+Object.defineProperty(exports, "startPlatformLogin", { enumerable: true, get: function () { return platform_runner_1.startPlatformLogin; } });
+Object.defineProperty(exports, "shutdownRunner", { enumerable: true, get: function () { return platform_runner_1.shutdownRunner; } });
+Object.defineProperty(exports, "mapSearchResultForDouyin", { enumerable: true, get: function () { return platform_runner_1.mapSearchResultForDouyin; } });
+//# sourceMappingURL=douyin-runner.js.map

package/dist/browser/kernel/electron-profile.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_DESKTOP_PROFILE_NAME = void 0;
+exports.configureDesktopElectronProfile = configureDesktopElectronProfile;
+const node_path_1 = __importDefault(require("node:path"));
+exports.DEFAULT_DESKTOP_PROFILE_NAME = "OPC1 Desktop";
+function resolveProfileName(options) {
+    const envName = process.env.OPC1_ELECTRON_PROFILE_NAME?.trim();
+    return (options?.profileName || envName || exports.DEFAULT_DESKTOP_PROFILE_NAME).trim();
+}
+function resolveUserDataDir(app, profileName, options) {
+    const envDir = process.env.OPC1_ELECTRON_USER_DATA_DIR?.trim();
+    const explicit = options?.userDataDir || envDir;
+    if (explicit && explicit.trim())
+        return explicit.trim();
+    return node_path_1.default.join(app.getPath("appData"), profileName);
+}
+function configureDesktopElectronProfile(app, options) {
+    const profileName = resolveProfileName(options);
+    const userDataDir = resolveUserDataDir(app, profileName, options);
+    app.setName(profileName);
+    app.setPath("userData", userDataDir);
+    if (options?.logUserDataPathOnce) {
+        const log = options.log || ((msg) => console.log(msg));
+        log(`[opc1] electron userData = ${app.getPath("userData")}`);
+    }
+    return { profileName, userDataDir };
+}
+//# sourceMappingURL=electron-profile.js.map

package/dist/browser/kernel/logger.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOG_FILE_PATH = exports.logger = void 0;
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+function resolveLogFile() {
+    const dir = process.env.PPXC_MCP_LOG_DIR?.trim() || node_path_1.default.join((0, node_os_1.tmpdir)(), "ppxc-mcp-logs");
+    try {
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    }
+    catch {
+    }
+    return node_path_1.default.join(dir, "ppxc-mcp.log");
+}
+const LOG_FILE = resolveLogFile();
+function formatMessage(level, tag, ...args) {
+    const ts = new Date().toISOString();
+    const body = args
+        .map((arg) => {
+        if (typeof arg === "string")
+            return arg;
+        try {
+            return JSON.stringify(arg);
+        }
+        catch {
+            return String(arg);
+        }
+    })
+        .join(" ");
+    return `[${ts}] [${level.toUpperCase()}] [${tag}] ${body}`;
+}
+function writeLine(line) {
+    try {
+        (0, node_fs_1.appendFileSync)(LOG_FILE, line + "\n");
+    }
+    catch {
+    }
+}
+function createScopedLogger(tag) {
+    return {
+        info: (...args) => writeLine(formatMessage("info", tag, ...args)),
+        warn: (...args) => writeLine(formatMessage("warn", tag, ...args)),
+        error: (...args) => writeLine(formatMessage("error", tag, ...args)),
+    };
+}
+exports.logger = {
+    info: (...args) => writeLine(formatMessage("info", "app", ...args)),
+    warn: (...args) => writeLine(formatMessage("warn", "app", ...args)),
+    error: (...args) => writeLine(formatMessage("error", "app", ...args)),
+    scope: createScopedLogger,
+};
+exports.LOG_FILE_PATH = LOG_FILE;
+//# sourceMappingURL=logger.js.map