@pomelolabs/leads 0.0.0-stage → 0.1.1

package/host/index.js

@@ -0,0 +1,1361 @@
+/**
+ * 柚客 Pomelo — Host half.
+ * Local JSON store + token-guarded RPC + DSH model calls.
+ * Browser automation and the production license service are next.
+ */
+import crypto from 'node:crypto';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { browserStatus, openLink, openLogin, searchPeerProfile, searchPublic } from './browser.js';
+
+const execFileAsync = promisify(execFile);
+
+const RPC_PATH = '/pomelo-rpc';
+const MAX_BODY = 2 * 1024 * 1024;
+
+const SYSTEM_PROMPT = `你是「柚客 Pomelo」的内容策略助手，服务对象是中国的个体商家、个人 IP 和小团队。
+你的建议必须具体、可执行、口语化，避免空泛的“要垂直”“要做差异化”。
+所有分析都要结合创作者提供的 6 个问题资料；资料里没有的数据不要编造。
+只输出中文。除非用户明确要求，否则不要输出 Markdown 代码块。`;
+
+const PROFILE_FIELDS = [
+  ['q1', '你是谁？目前在做什么生意？'],
+  ['q2', '你有哪些值得分享的个人经历？'],
+  ['q3', '你的客户主要是哪些人？他们有什么需求？'],
+  ['q4', '你有哪些专业经验或行业观点？'],
+  ['q5', '你的产品或服务有哪些特点？'],
+  ['q6', '你希望客户如何认识和评价你？'],
+];
+
+function homeDir() {
+  return process.env.DSH_HOME || path.join(os.homedir(), '.dsh');
+}
+
+function dataDir() {
+  return path.join(homeDir(), 'pomelo');
+}
+
+function todayKey() {
+  const d = new Date();
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+}
+
+function nowISO() {
+  return new Date().toISOString();
+}
+
+const LICENSE_TIERS = {
+  month: { label: '月度卡', days: 30, letter: 'M' },
+  quarter: { label: '季度卡', days: 90, letter: 'Q' },
+  year: { label: '年度卡', days: 365, letter: 'Y' },
+};
+const LICENSE_SECRET = process.env.POMELO_LICENSE_SECRET || 'pomelo-license-v1-7f3d9a2c4e6b8d10';
+
+function licenseTierFromLetter(letter) {
+  return Object.entries(LICENSE_TIERS).find(([, meta]) => meta.letter === letter)?.[0] || '';
+}
+
+function licenseSignature(tier, serial) {
+  return crypto
+    .createHmac('sha256', LICENSE_SECRET)
+    .update(`pomelo-v1:${tier}:${serial}`)
+    .digest('hex')
+    .slice(0, 12)
+    .toUpperCase();
+}
+
+function parseLicenseCode(input) {
+  const code = String(input || '').toUpperCase().replace(/\s+/g, '');
+  const parts = code.split('-');
+  if (parts.length !== 5 || parts[0] !== 'PM') return null;
+  const tier = licenseTierFromLetter(parts[1]);
+  if (!tier) return null;
+  const serial = `${parts[2]}${parts[3]}`;
+  if (!/^[A-Z2-9]{8}$/.test(serial)) return null;
+  if (!/^[A-F0-9]{12}$/.test(parts[4])) return null;
+  const expected = licenseSignature(tier, serial);
+  if (parts[4] !== expected) return null;
+  return { code, tier, serial };
+}
+
+function licensesFile() {
+  return path.join(dataDir(), 'licenses.json');
+}
+
+async function readLicenseDb() {
+  try {
+    const raw = await fs.readFile(licensesFile(), 'utf8');
+    const parsed = JSON.parse(raw);
+    return { codes: Array.isArray(parsed?.codes) ? parsed.codes : [] };
+  } catch (error) {
+    if (error?.code !== 'ENOENT') throw error;
+    return { codes: [] };
+  }
+}
+
+async function writeLicenseDb(db) {
+  const file = licensesFile();
+  const tmp = `${file}.${process.pid}.tmp`;
+  await fs.mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+  await fs.writeFile(tmp, JSON.stringify({ codes: db.codes }, null, 2), { mode: 0o600 });
+  await fs.rename(tmp, file);
+}
+
+function tierMeta(tier) {
+  return LICENSE_TIERS[tier] || LICENSE_TIERS.year;
+}
+
+function maskCode(code) {
+  const value = String(code || '');
+  return value.length > 4 ? `••••${value.slice(-4)}` : '••••';
+}
+
+function licenseView(license) {
+  const now = Date.now();
+  const expires = license?.expiresAt ? new Date(license.expiresAt).getTime() : 0;
+  const active = Boolean(expires && expires > now);
+  return {
+    status: active ? 'active' : 'inactive',
+    plan: license?.plan || '',
+    tier: license?.tier || license?.plan || '',
+    tierLabel: tierMeta(license?.tier || license?.plan).label || '',
+    expiresAt: license?.expiresAt || null,
+    activatedAt: license?.activatedAt || null,
+    daysLeft: active ? Math.max(0, Math.ceil((expires - now) / 86400000)) : 0,
+    maskedCode: license?.maskedCode || '',
+  };
+}
+
+function licenseServers() {
+  const configured = String(process.env.POMELO_LICENSE_SERVER || '').trim();
+  const defaults = ['https://bosshuoke.com/pomelo-admin', 'http://121.43.127.148'];
+  return [...new Set([...(configured ? [configured] : []), ...defaults].map((item) => item.replace(/\/$/, '')))];
+}
+
+async function licenseRequest(path, body, timeout = 12000) {
+  let lastError = null;
+  for (const server of licenseServers()) {
+    try {
+      const response = await fetch(`${server}${path}`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', accept: 'application/json' },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(timeout),
+      });
+      return { response, server };
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  throw lastError || new Error('license server unavailable');
+}
+
+function cleanText(value, max = 4000) {
+  return String(value ?? '').replace(/\u0000/g, '').trim().slice(0, max);
+}
+
+function emptyState() {
+  return {
+    schemaVersion: 1,
+    installId: '',
+    profile: {
+      answers: { q1: '', q2: '', q3: '', q4: '', q5: '', q6: '' },
+      version: 0,
+      updatedAt: null,
+    },
+    archives: [],
+    scripts: {},
+    peerHistory: [],
+    account: null,
+    topics: {
+      date: '',
+      items: [],
+      generatedAt: null,
+      profileVersion: 0,
+      stale: false,
+    },
+    license: {
+      status: 'inactive',
+      plan: '',
+      expiresAt: null,
+      activatedAt: null,
+    },
+    settings: {},
+  };
+}
+
+function mergeState(raw) {
+  const base = emptyState();
+  if (!raw || typeof raw !== 'object') return base;
+  return {
+    ...base,
+    ...raw,
+    profile: {
+      ...base.profile,
+      ...(raw.profile || {}),
+      answers: { ...base.profile.answers, ...(raw.profile?.answers || {}) },
+    },
+    topics: { ...base.topics, ...(raw.topics || {}) },
+    license: { ...base.license, ...(raw.license || {}) },
+    settings: { ...base.settings, ...(raw.settings || {}) },
+    archives: Array.isArray(raw.archives) ? raw.archives : [],
+    scripts: raw.scripts && typeof raw.scripts === 'object' ? raw.scripts : {},
+    peerHistory: Array.isArray(raw.peerHistory) ? raw.peerHistory : [],
+    account: raw.account && typeof raw.account === 'object' ? raw.account : null,
+  };
+}
+
+function profileText(profile) {
+  const answers = profile?.answers || {};
+  return PROFILE_FIELDS.map(([key, label]) => `${label}\n${cleanText(answers[key], 2000) || '（未填写）'}`).join('\n\n');
+}
+
+function parseJson(text) {
+  const raw = String(text || '').trim();
+  const unfenced = raw.replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/i, '').trim();
+  for (const candidate of [unfenced, raw]) {
+    try {
+      return JSON.parse(candidate);
+    } catch {
+      /* scan balanced JSON blocks below */
+    }
+  }
+  for (const candidate of [unfenced, raw]) {
+    const starts = [];
+    for (let index = 0; index < candidate.length; index += 1) {
+      if (candidate[index] === '{' || candidate[index] === '[') starts.push(index);
+    }
+    for (const start of starts.slice(0, 12)) {
+      const stack = [];
+      let inString = false;
+      let escaped = false;
+      for (let index = start; index < candidate.length; index += 1) {
+        const char = candidate[index];
+        if (inString) {
+          if (escaped) escaped = false;
+          else if (char === '\\') escaped = true;
+          else if (char === '"') inString = false;
+          continue;
+        }
+        if (char === '"') { inString = true; continue; }
+        if (char === '{' || char === '[') stack.push(char === '{' ? '}' : ']');
+        else if (char === '}' || char === ']') {
+          if (stack.pop() !== char) break;
+          if (stack.length === 0) {
+            try {
+              return JSON.parse(candidate.slice(start, index + 1));
+            } catch {
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+  throw new Error('模型返回的内容不是有效 JSON');
+}
+
+function asStringList(value, max = 10) {
+  if (!Array.isArray(value)) return [];
+  return value.map((item) => cleanText(item, 400)).filter(Boolean).slice(0, max);
+}
+
+function normalizeTopics(value) {
+  const list = Array.isArray(value) ? value : value?.topics;
+  if (!Array.isArray(list) || list.length === 0) throw new Error('模型没有返回选题数组');
+  return list.slice(0, 10).map((item, index) => ({
+    id: `topic-${Date.now()}-${index}`,
+    title: cleanText(item?.title || item?.topic, 120) || `选题 ${index + 1}`,
+    platform: item?.platform === '抖音' ? '抖音' : '小红书',
+    format: item?.format === '视频' ? '视频' : '图文',
+    reason: cleanText(item?.reason || item?.why, 320),
+    source: cleanText(item?.source || item?.basis, 200),
+    tag: cleanText(item?.tag, 20),
+  }));
+}
+
+function normalizeScript(value, format) {
+  const obj = Array.isArray(value) ? value[0] : value;
+  if (!obj || typeof obj !== 'object') throw new Error('模型没有返回脚本对象');
+  if (format === 'image') {
+    return {
+      kind: 'image',
+      title: cleanText(obj.title, 80),
+      body: cleanText(obj.body, 4000),
+      images: (Array.isArray(obj.images) ? obj.images : []).slice(0, 8).map((item, i) => ({
+        no: cleanText(typeof item === 'object' ? item?.no : '', 4) || String(i + 1).padStart(2, '0'),
+        text: cleanText(typeof item === 'string' ? item : item?.text || item?.desc || item?.content, 600),
+      })).filter((item) => item.text),
+      tags: asStringList(obj.tags, 10),
+    };
+  }
+  const shots = Array.isArray(obj.shots) ? obj.shots.slice(0, 10).map((shot, i) => ({
+    no: cleanText(shot?.no, 4) || String(i + 1).padStart(2, '0'),
+    scene: cleanText(shot?.scene || shot?.shot, 300),
+    line: cleanText(shot?.line || shot?.dialogue, 500),
+    dur: cleanText(shot?.dur || shot?.duration, 20),
+  })) : [];
+  return {
+    kind: 'video',
+    title: cleanText(obj.title, 80),
+    body: cleanText(obj.body, 4000),
+    shots,
+    tags: asStringList(obj.tags, 10),
+  };
+}
+
+function normalizePlan(value) {
+  const obj = Array.isArray(value) ? value[0] : value;
+  const sections = Array.isArray(obj?.sections) ? obj.sections : Array.isArray(obj) ? obj : [];
+  if (!sections.length) throw new Error('模型没有返回方案模块');
+  return sections.slice(0, 4).map((section, i) => ({
+    no: cleanText(section?.no, 4) || String(i + 1).padStart(2, '0'),
+    title: cleanText(section?.title, 80) || ['账号定位与人设打造', '内容方向与选题规划', '拍摄与表达建议', '获客路径与转化策略'][i],
+    lead: cleanText(section?.lead || section?.intro, 300),
+    bullets: asStringList(section?.bullets || section?.items, 8),
+  }));
+}
+
+function archiveFingerprint(archive) {
+  const content = {
+    type: archive?.type || '',
+    title: archive?.title || '',
+    platform: archive?.platform || '',
+    sections: (archive?.sections || []).map((section) => ({
+      h: section?.h || '',
+      p: section?.p || '',
+      list: section?.list || [],
+    })),
+  };
+  return crypto.createHash('sha256').update(JSON.stringify(content)).digest('hex');
+}
+
+function toArchive(input) {
+  const type = ['peer', 'search', 'topics', 'script', 'plan', 'account'].includes(input?.type) ? input.type : 'script';
+  return {
+    id: crypto.randomUUID(),
+    type,
+    scriptFormat: input?.scriptFormat === 'video' ? 'video' : input?.scriptFormat === 'image' ? 'image' : '',
+    title: cleanText(input?.title, 180) || '未命名归档',
+    platform: cleanText(input?.platform, 40) || '小红书',
+    summary: cleanText(input?.summary, 400),
+    time: nowISO(),
+    profileVersion: Number(input?.profileVersion) || 1,
+    sections: Array.isArray(input?.sections)
+      ? input.sections.slice(0, 12).map((section) => ({
+          h: cleanText(section?.h, 80),
+          p: cleanText(section?.p, 4000),
+          list: asStringList(section?.list, 20),
+        }))
+      : [],
+  };
+}
+
+class Store {
+  constructor(dir) {
+    this.dir = dir;
+    this.file = path.join(dir, 'pomelo.json');
+    this.state = emptyState();
+    this.queue = Promise.resolve();
+    this.logFile = path.join(dir, 'logs', 'host.log');
+  }
+
+  async init() {
+    await fs.mkdir(this.dir, { recursive: true, mode: 0o700 });
+    await fs.mkdir(path.dirname(this.logFile), { recursive: true, mode: 0o700 });
+    try {
+      const raw = await fs.readFile(this.file, 'utf8');
+      this.state = mergeState(JSON.parse(raw));
+    } catch (error) {
+      if (error?.code !== 'ENOENT') await this.log(`读取数据失败：${String(error?.message || error)}`);
+      await this.persist();
+    }
+    return this;
+  }
+
+  async log(message) {
+    try {
+      await fs.appendFile(this.logFile, `[${nowISO()}] ${message}\n`, { mode: 0o600 });
+    } catch {
+      /* logging must never break a request */
+    }
+  }
+
+  async persist() {
+    const tmp = `${this.file}.${process.pid}.tmp`;
+    const body = JSON.stringify(this.state, null, 2);
+    await fs.writeFile(tmp, body, { mode: 0o600 });
+    await fs.rename(tmp, this.file);
+  }
+
+  update(mutator) {
+    this.queue = this.queue
+      .catch(() => {})
+      .then(async () => {
+        const result = await mutator(this.state);
+        await this.persist();
+        return result;
+      });
+    return this.queue;
+  }
+
+  snapshot() {
+    return JSON.parse(JSON.stringify(this.state));
+  }
+}
+
+function rpcError(code, message) {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
+
+async function readBody(req) {
+  let size = 0;
+  const chunks = [];
+  for await (const chunk of req) {
+    size += chunk.length;
+    if (size > MAX_BODY) throw rpcError('BODY_TOO_LARGE', '请求体过大');
+    chunks.push(chunk);
+  }
+  const raw = Buffer.concat(chunks).toString('utf8');
+  if (!raw) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw rpcError('BAD_JSON', '请求体不是 JSON');
+  }
+}
+
+function sendJson(res, status, body, origin) {
+  const headers = {
+    'content-type': 'application/json; charset=utf-8',
+    'cache-control': 'no-store',
+  };
+  if (origin) {
+    headers['access-control-allow-origin'] = '*';
+    headers['access-control-allow-methods'] = 'POST, OPTIONS';
+    headers['access-control-allow-headers'] = 'content-type, x-pomelo-token';
+    headers.vary = 'origin';
+  }
+  res.writeHead(status, headers);
+  res.end(JSON.stringify(body));
+}
+
+export const inject = ['webServer', 'llm', 'agentDefaultModel'];
+
+export async function apply(ctx) {
+  const webServer = ctx.webServer || ctx.get?.('webServer');
+  const getLlm = () => ctx.llm || ctx.get?.('llm');
+  const getDefaultModel = () => ctx.agentDefaultModel || ctx.get?.('agentDefaultModel');
+  const store = await new Store(dataDir()).init();
+  const token = crypto.randomBytes(24).toString('base64url');
+  const rpcUrl = () => {
+    const webBase = String(process.env.DSH_WEB_URL || '').replace(/\/$/, '');
+    if (webBase) return `${webBase}${RPC_PATH}`;
+    try {
+      const origin = webServer.getOrigin();
+      return `${origin}${RPC_PATH}`;
+    } catch {
+      return RPC_PATH;
+    }
+  };
+
+  await store.log(`Host 启动；数据目录 ${dataDir()}；模型服务 ${getLlm() ? '可用' : '启动时未就绪'}；web=${process.env.DSH_WEB_URL || 'n/a'}`);
+
+  if (!webServer) {
+    await store.log('webServer 不可用，无法为浏览器半区提供 RPC');
+    return;
+  }
+
+  if (typeof ctx.on === 'function') {
+    ctx.on('webserver/index-inject', (table) => {
+      if (!Array.isArray(table)) return;
+      table.push({ kind: 'global', name: '__POMELO_TOKEN__', value: token });
+      table.push({ kind: 'global', name: '__POMELO_RPC__', value: rpcUrl() });
+      table.push({ kind: 'global', name: '__POMELO_LICENSE__', value: licenseView(store.snapshot().license) });
+    });
+  }
+
+  // A raw index tap is a second, independent injection path. It keeps the
+  // browser half working even when a composition renders index.html without
+  // the structured injection table.
+  if (typeof webServer.tapIndex === 'function') {
+    webServer.tapIndex((html) =>
+      String(html).replace(
+        '</head>',
+        `<script>window.__POMELO_TOKEN__=${JSON.stringify(token)};window.__POMELO_RPC__=${JSON.stringify(rpcUrl())};window.__POMELO_LICENSE__=${JSON.stringify(licenseView(store.snapshot().license))};</script></head>`,
+      ),
+    );
+  }
+
+  function postsForPrompt(posts) {
+    return (posts || []).slice(0, 12).map((post) => ({
+      title: cleanText(post.title, 180),
+      author: cleanText(post.author, 80),
+      likes: cleanText(post.likes, 20),
+      platform: cleanText(post.platform, 20),
+    }));
+  }
+
+  async function analyzeSearch(posts, keyword, platform) {
+    const prompt = `下面是刚从${platform}公开搜索「${keyword}」读到的真实结果（不是示例数据）：
+${JSON.stringify(postsForPrompt(posts), null, 2)}
+请基于这些标题、作者和互动数据，分析：
+1. themes：这批内容在反复讨论的 3-5 个需求/痛点；
+2. gaps：用户还没被满足、你可以切入的 2-4 个空位；
+3. angles：5 个具体、今天就能拍的内容角度。
+只输出 JSON，不要 Markdown：{"themes":["..."],"gaps":["..."],"angles":["..."]}
+不要编造结果里没有出现的品牌、数字或客户。`;
+    const text = await complete(prompt, { temperature: 0.45, maxTokens: 1800 });
+    const parsed = parseJson(text);
+    return {
+      themes: asStringList(parsed?.themes, 5),
+      gaps: asStringList(parsed?.gaps, 4),
+      angles: asStringList(parsed?.angles, 5),
+    };
+  }
+
+  function parseFollower(value) {
+    const text = String(value || '').replace(/[^\d.万亿wWkK]/g, '');
+    if (!text) return null;
+    const unit = /[万亿]/.test(String(value)) ? 100000000 : /[wWkK]/.test(String(value)) ? 10000 : 1;
+    const number = Number.parseFloat(text);
+    return Number.isFinite(number) ? Math.round(number * unit) : null;
+  }
+
+  function comparePeer(previous, result) {
+    if (!previous) return null;
+    const previousUrls = new Set((previous.posts || []).map((post) => post.url).filter(Boolean));
+    const newPosts = (result.posts || []).filter((post) => post.url && !previousUrls.has(post.url));
+    const before = parseFollower(previous.followers);
+    const after = parseFollower(result.followers);
+    return {
+      previousAt: previous.collectedAt || null,
+      previousPostCount: (previous.posts || []).length,
+      newCount: newPosts.length,
+      newPosts: newPosts.slice(0, 12),
+      followerDelta: before !== null && after !== null ? after - before : null,
+      previousFollowers: previous.followers || '—',
+      currentFollowers: result.followers || '—',
+    };
+  }
+
+  async function analyzePeer(posts, account, platform, comparison = null) {
+    const comparisonText = comparison
+      ? `\n【与上次对比】上次采集 ${comparison.previousPostCount} 条，这次新增 ${comparison.newCount} 条；粉丝变化 ${comparison.followerDelta === null ? '未知' : comparison.followerDelta}。新增内容：${comparison.newPosts.map((post) => post.title).slice(0, 6).join('；') || '无'}。\n`
+      : '';
+    const prompt = `下面是${platform}上「${account}」的真实公开作品结果：
+${JSON.stringify(postsForPrompt(posts), null, 2)}
+${comparisonText}
+请拆解这个同行最近的内容打法，输出 JSON：{"summary":["3-5 条具体观察"],"tags":["3 个可复用标签"]}
+只输出 JSON，不要 Markdown。不要编造结果里没有的数据。`;
+    const text = await complete(prompt, { temperature: 0.45, maxTokens: 1400 });
+    const parsed = parseJson(text);
+    return {
+      summary: asStringList(parsed?.summary, 5),
+      tags: asStringList(parsed?.tags, 4),
+    };
+  }
+
+  async function installBrowser() {
+    const first = await browserStatus();
+    if (first.installed) return first;
+    const pluginRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..');
+    await store.log('开始安装 Chromium（puppeteer）');
+    try {
+      await execFileAsync('npx', ['puppeteer', 'browsers', 'install', 'chrome'], {
+        cwd: pluginRoot,
+        timeout: 15 * 60 * 1000,
+        maxBuffer: 4 * 1024 * 1024,
+        env: process.env,
+      });
+    } catch (error) {
+      await store.log(`Chromium 安装失败：${error?.message || error}`);
+      throw rpcError('BROWSER_INSTALL_FAILED', 'Chromium 安装失败，请在项目目录运行 npm run browser:install 后重试');
+    }
+    const next = await browserStatus();
+    await store.log(`Chromium 安装完成：${next.executable || '未找到路径'}`);
+    return next;
+  }
+
+  async function complete(prompt, options = {}) {
+    const llm = getLlm();
+    const defaultModel = getDefaultModel();
+    if (!llm || !defaultModel) throw rpcError('MODEL_UNAVAILABLE', 'DSH 模型服务未就绪');
+    const selection = defaultModel.currentSelection?.();
+    if (!selection?.provider || !selection?.model) throw rpcError('MODEL_UNAVAILABLE', '没有读取到 DSH 默认模型');
+
+    let reasoningEffort = selection.reasoningEffort;
+    try {
+      const info = await llm.resolveModelInfo?.(selection.provider, selection.model);
+      const efforts = info?.reasoning?.efforts?.map((item) => String(item.id)) || [];
+      const minimal = ['none', 'minimal', 'low', 'off'].find((item) => efforts.includes(item));
+      if (minimal) reasoningEffort = minimal;
+    } catch {
+      /* adapter may not expose reasoning metadata */
+    }
+
+    async function once(maxTokens, effort) {
+      const input = {
+        provider: selection.provider,
+        model: selection.model,
+        system: SYSTEM_PROMPT,
+        messages: [{ role: 'user', content: [{ type: 'text', text: prompt }] }],
+        temperature: options.temperature ?? 0.7,
+        maxTokens,
+      };
+      if (effort) input.reasoningEffort = effort;
+      let text = '';
+      let blockText = '';
+      let reasoning = '';
+      let failure = null;
+      let finishReason = '';
+      let usage = null;
+      const seen = new Set();
+      for await (const chunk of llm.stream(input)) {
+        if (chunk?.type) seen.add(chunk.type);
+        if (chunk?.type === 'text-delta') text += chunk.text || '';
+        if (chunk?.type === 'reasoning-delta') reasoning += chunk.text || '';
+        if (chunk?.type === 'block-end' && chunk.block?.type === 'text') blockText += chunk.block.text || '';
+        if (chunk?.type === 'usage') usage = chunk.usage || null;
+        if (chunk?.type === 'finish') {
+          finishReason = chunk.reason?.kind || '';
+          if (chunk.reason?.kind === 'error' || chunk.reason?.kind === 'aborted') {
+            failure = chunk.reason.failure || { message: '模型调用中断' };
+          }
+        }
+      }
+      if (!text && blockText) text = blockText;
+      return { text: text.trim(), reasoning: reasoning.trim(), failure, seen: [...seen], finishReason, usage };
+    }
+
+    const firstMax = options.maxTokens ?? 6000;
+    let result = await once(firstMax, reasoningEffort);
+    if (result.failure) {
+      await store.log(`模型失败：${result.failure.message || '未知失败'}（finish=${result.finishReason}；chunks: ${result.seen.join(',')}）`);
+      throw rpcError('MODEL_FAILED', result.failure.message || '模型调用失败');
+    }
+    // Reasoning models can spend the whole output budget before emitting the
+    // answer. Retry empty or reasoning-only replies with a larger budget.
+    if (!result.text) {
+      const retryMax = Math.max(9000, firstMax * 2);
+      await store.log(`模型只返回了思考内容，使用 ${retryMax} tokens 重试（chunks: ${result.seen.join(',')}；reasoning=${result.reasoning.length}；finish=${result.finishReason}）`);
+      result = await once(retryMax, reasoningEffort);
+      if (result.failure) {
+        await store.log(`模型重试失败：${result.failure.message || '未知失败'}（finish=${result.finishReason}）`);
+        throw rpcError('MODEL_FAILED', result.failure.message || '模型调用失败');
+      }
+    }
+    if (!result.text.trim()) {
+      await store.log(`模型空响应（chunks: ${result.seen.join(',') || 'none'}；reasoning=${result.reasoning.length}；finish=${result.finishReason}；usage=${JSON.stringify(result.usage)}；provider=${selection.provider}；model=${selection.model}）`);
+      throw rpcError('MODEL_EMPTY', '模型没有返回正文，请重试或换一个非推理模型');
+    }
+    return result.text.trim();
+  }
+
+  async function completeJson(prompt, options = {}) {
+    let lastError = null;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      const retryPrompt = attempt === 0
+        ? prompt
+        : `${prompt}\n\n上一次输出无法解析为 JSON。请只返回严格 JSON，不要解释，不要 Markdown 代码块，不要遗漏括号。`;
+      const raw = await complete(retryPrompt, {
+        ...options,
+        maxTokens: attempt === 0 ? options.maxTokens : Math.max(6000, (options.maxTokens || 3000) * 2),
+      });
+      try {
+        return parseJson(raw);
+      } catch (error) {
+        lastError = error;
+        await store.log(`JSON 解析失败（第 ${attempt + 1} 次）：${String(error?.message || error)}`);
+      }
+    }
+    throw rpcError('MODEL_BAD_JSON', lastError?.message || '模型返回的内容不是有效 JSON，请重试');
+  }
+
+  async function generateTopics() {
+    const state = store.snapshot();
+    const answers = state.profile.answers;
+    if (!answers.q1?.trim() || !answers.q3?.trim() || !answers.q5?.trim()) {
+      throw rpcError('PROFILE_REQUIRED', '请先完成第 1、3、5 个问题');
+    }
+    const recent = state.archives.slice(0, 8).map((item) => `- ${item.title}`).join('\n') || '暂无';
+    const prompt = `今天是 ${todayKey()}。请为下面这位创作者生成 10 个今天可以拍的内容选题。
+
+【创作者资料】
+${profileText(state.profile)}
+
+【最近生成过的内容，尽量避开重复】
+${recent}
+
+只返回一个 JSON 数组，不要 Markdown 代码块。数组每一项：
+{
+  "title": "选题标题，具体、有钩子，不超过 26 字",
+  "platform": "小红书" 或 "抖音",
+  "format": "图文" 或 "视频",
+  "reason": "为什么适合这个创作者，一句话",
+  "source": "来自哪段资料或什么判断，一句话",
+  "tag": "适合马上拍 / 收藏向 / 涨粉 / 转化 / 建立信任 / 人设 / 观点 六选一"
+}
+
+要求：
+1. 10 条，至少覆盖 3 个不同的内容方向；干货、故事、观点、转化都要有。
+2. 必须结合资料里的城市、客户、产品特点、个人经历，不要写通用鸡汤。
+3. 标题要像真人会点开的标题，不要用“揭秘”“干货满满”这类空词。`;
+
+    const items = normalizeTopics(await completeJson(prompt, { maxTokens: 3000, temperature: 0.85 }));
+    const updated = await store.update((state) => {
+      state.topics = {
+        date: todayKey(),
+        items,
+        generatedAt: nowISO(),
+        profileVersion: state.profile.version,
+        stale: false,
+      };
+      return state.topics;
+    });
+    return updated;
+  }
+
+  async function replaceTopic(payload) {
+    const state = store.snapshot();
+    if (!state.profile.answers.q1?.trim()) throw rpcError('PROFILE_REQUIRED', '请先填写资料，再换选题');
+    const topicId = cleanText(payload?.id, 120);
+    const title = cleanText(payload?.title, 160);
+    const current = (state.topics.items || []).find((item) => (topicId && item.id === topicId) || (!topicId && item.title === title));
+    if (!current) throw rpcError('TOPIC_NOT_FOUND', '找不到这条选题，请重新生成今日选题');
+    const avoid = (state.topics.items || []).map((item) => item.title).filter(Boolean).join('；');
+    const prompt = `为下面这位创作者换一个新的内容选题。
+【创作者资料】
+${profileText(state.profile)}
+
+【已有选题，必须避开】
+${avoid}
+
+【要替换的选题】
+${current.title}（${current.platform} · ${current.format}）
+
+只返回一个 JSON 对象，不要 Markdown：
+{"title":"具体标题，不超过26字","platform":"小红书"或"抖音","format":"图文"或"视频","reason":"为什么适合这个创作者，一句话","source":"依据哪段资料，一句话","tag":"适合马上拍/收藏向/涨粉/转化/建立信任/人设/观点 六选一"}
+要求：角度、客户场景、标题钩子都要和已有选题不同；必须结合城市、客户和业务。`;
+    const parsed = await completeJson(prompt, { maxTokens: 1200, temperature: 0.85 });
+    const next = normalizeTopics([parsed])[0];
+    next.id = current.id || next.id;
+    const items = (state.topics.items || []).map((item) => (item.id === current.id ? next : item));
+    await store.update((currentState) => {
+      currentState.topics.items = items;
+      return true;
+    });
+    return { items, replaced: next };
+  }
+
+  async function analyzeAccount(payload) {
+    const platform = payload?.platform === '抖音' ? '抖音' : '小红书';
+    const account = cleanText(payload?.account, 160);
+    if (!account) throw rpcError('EMPTY_ACCOUNT', '先粘贴你的主页链接或 ID');
+    let result;
+    try {
+      result = await searchPeerProfile({ platform, account });
+    } catch (error) {
+      await store.log(`账号分析采集失败：${platform} / ${account} / ${error?.message || error}`);
+      throw rpcError(error?.code || 'BROWSER_FAILED', error?.message || '本地浏览器采集失败');
+    }
+    const state = store.snapshot();
+    const prompt = `下面是创作者自己的${platform}账号公开主页和作品。请做账号诊断。
+【创作者资料】
+${profileText(state.profile)}
+
+【账号】
+昵称：${result.name}
+粉丝：${result.followers}
+公开作品：${result.postCount}
+作品列表：
+${JSON.stringify(postsForPrompt(result.posts), null, 2)}
+
+只输出 JSON 对象，不要 Markdown：
+{"positioning":"一句话账号定位判断","summary":["3-4 条具体诊断，必须引用作品或数据"],"match":["2-3 条与目标客户的匹配/不匹配判断"]}
+不要编造作品里没有的数据。`;
+    let insight = { positioning: '', summary: [], match: [] };
+    try {
+      const parsed = await completeJson(prompt, { maxTokens: 1600, temperature: 0.5 });
+      insight = {
+        positioning: cleanText(parsed?.positioning, 300),
+        summary: asStringList(parsed?.summary, 5),
+        match: asStringList(parsed?.match, 4),
+      };
+    } catch (error) {
+      await store.log(`账号分析失败：${error?.message || error}`);
+    }
+    const record = {
+      platform,
+      account: account.replace(/^@/, ''),
+      name: result.name,
+      avatar: result.avatar,
+      followers: result.followers,
+      postCount: result.postCount,
+      profileUrl: result.profileUrl,
+      positioning: insight.positioning,
+      summary: insight.summary,
+      match: insight.match,
+      analyzedAt: nowISO(),
+    };
+    await store.update((current) => {
+      current.account = record;
+      return true;
+    });
+    return record;
+  }
+
+  async function generateScript(payload) {
+    const topic = payload?.topic || {};
+    const format = payload?.format === 'video' ? 'video' : 'image';
+    const state = store.snapshot();
+    if (!state.profile.answers.q1?.trim()) throw rpcError('PROFILE_REQUIRED', '请先填写资料，再生成脚本');
+    const cacheKey = `${format}:${cleanText(topic.id || topic.title, 160)}`;
+    const cached = state.scripts?.[cacheKey];
+    if (cached?.script && !payload?.force) {
+      return { ...cached.script, cached: true, cachedAt: cached.createdAt || null };
+    }
+    const prompt = `请为下面这个选题写一份${format === 'image' ? '图文' : '视频'}脚本。
+
+【创作者资料】
+${profileText(state.profile)}
+
+【选题】
+标题：${cleanText(topic.title, 120)}
+平台：${topic.platform === '抖音' ? '抖音' : '小红书'}
+形式：${format === 'image' ? '图文' : '视频'}
+推荐理由：${cleanText(topic.reason, 300)}
+
+只返回一个 JSON 对象，不要 Markdown 代码块。
+${format === 'image'
+  ? `{
+  "title": "标题，不超过 20 字",
+  "body": "正文，300-600 字，分 2-4 段，口语化",
+  "images": ["第 1 张：封面画面和封面字；第 2 张：……", "……"],
+  "tags": ["#标签1", "#标签2", "5-8 个"]
+}`
+  : `{
+  "title": "标题，不超过 20 字",
+  "body": "口播文案，150-300 字，开头 3 秒先给结论或冲突",
+  "shots": [
+    {"no": "01", "scene": "画面/景别", "line": "台词或字幕", "dur": "0-3s"}
+  ],
+  "tags": ["#标签1", "#标签2", "5-8 个"]
+}`}
+
+要求：所有内容都要和资料里的业务、客户、产品特点有关；不要编造数据；图片建议/拍摄脚本要能直接执行。`;
+
+    const raw = await complete(prompt, { maxTokens: 2600, temperature: 0.75 });
+    const script = normalizeScript(parseJson(raw), format);
+    const createdAt = nowISO();
+    await store.update((current) => {
+      if (!current.scripts || typeof current.scripts !== 'object') current.scripts = {};
+      current.scripts[cacheKey] = {
+        script,
+        format,
+        topicTitle: cleanText(topic.title, 180),
+        createdAt,
+      };
+      return true;
+    });
+    return { ...script, cached: false, cachedAt: createdAt };
+  }
+
+  async function generatePlan() {
+    const state = store.snapshot();
+    if (!state.profile.answers.q1?.trim() || !state.profile.answers.q3?.trim() || !state.profile.answers.q5?.trim()) {
+      throw rpcError('PROFILE_REQUIRED', '请先完成第 1、3、5 个问题');
+    }
+    const prompt = `请为下面这位创作者生成一份内容获客方案。
+
+【创作者资料】
+${profileText(state.profile)}
+
+${state.account ? `【账号诊断】\n定位：${state.account.positioning || ''}\n${(state.account.summary || []).map((item) => `- ${item}`).join('\n')}\n${(state.account.match || []).map((item) => `- ${item}`).join('\n')}` : ''}
+
+只返回一个 JSON 对象，不要 Markdown 代码块：
+{
+  "sections": [
+    {
+      "no": "01",
+      "title": "账号定位与人设打造",
+      "lead": "一句话说明这一节要解决什么",
+      "bullets": ["具体建议 1", "具体建议 2", "具体建议 3", "具体建议 4"]
+    },
+    {"no":"02","title":"内容方向与选题规划","lead":"...","bullets":["..."]},
+    {"no":"03","title":"拍摄与表达建议","lead":"...","bullets":["..."]},
+    {"no":"04","title":"获客路径与转化策略","lead":"...","bullets":["..."]}
+  ]
+}
+
+要求：
+1. 四个模块标题固定，顺序固定。
+2. 每条建议都要结合资料里的城市、客户、产品、经历，不要通用模板。
+3. 内容方向要给出比例和发布节奏；获客路径要具体到用户动作和承接方式。
+4. 不要编造资料里没有的数据。`;
+
+    const sections = normalizePlan(await completeJson(prompt, { maxTokens: 3000, temperature: 0.7 }));
+    const archive = toArchive({
+      type: 'plan',
+      title: `${cleanText(state.profile.answers.q1, 30) || '我的'} · 内容获客方案`,
+      platform: '小红书 / 抖音',
+      summary: '账号定位、内容方向、拍摄表达、获客路径 4 个模块',
+      profileVersion: state.profile.version || 1,
+      sections: sections.map((section) => ({ h: section.title, p: section.lead, list: section.bullets })),
+    });
+    await store.update((state) => {
+      state.archives.unshift(archive);
+      state.archives = state.archives.slice(0, 500);
+      return archive;
+    });
+    return { sections, archive };
+  }
+
+  async function reviewAsk(payload) {
+    const archive = payload?.archive;
+    const question = cleanText(payload?.question, 2000);
+    if (!question) throw rpcError('BAD_REQUEST', '问题不能为空');
+    if (!archive || !Array.isArray(archive.sections)) throw rpcError('BAD_REQUEST', '归档内容不完整');
+    const state = store.snapshot();
+    const history = Array.isArray(payload?.history) ? payload.history.slice(-8) : [];
+    const archiveText = [
+      `标题：${cleanText(archive.title, 200)}`,
+      `类型：${cleanText(archive.type, 30)}`,
+      `摘要：${cleanText(archive.summary, 400)}`,
+      ...archive.sections.flatMap((section) => [
+        `## ${cleanText(section.h, 80)}`,
+        cleanText(section.p, 4000),
+        ...(Array.isArray(section.list) ? section.list.map((item) => `- ${cleanText(item, 500)}`) : []),
+      ]),
+    ].join('\n');
+    const historyText = history.map((m) => `${m.role === 'user' ? '用户' : '助手'}：${cleanText(m.text, 1200)}`).join('\n');
+    const prompt = `下面是创作者的一条归档内容，以及我们的复盘对话。请基于归档和创作者资料回答用户的新问题。
+
+【创作者资料】
+${profileText(state.profile)}
+
+【归档内容】
+${archiveText}
+
+【之前的对话】
+${historyText || '（还没有）'}
+
+【用户的新问题】
+${question}
+
+要求：中文，具体、可执行；结合归档里的细节；不要编造数据；如果信息不足，直接说明需要补什么。只输出回答正文。`;
+    const text = await complete(prompt, { maxTokens: 1600, temperature: 0.7 });
+    let savedChat = null;
+    await store.update((current) => {
+      const item = (current.archives || []).find((entry) => entry.id === archive.id);
+      if (!item) return false;
+      const now = nowISO();
+      item.chat = [
+        ...(Array.isArray(item.chat) ? item.chat : []),
+        { role: 'user', text: question, time: now },
+        { role: 'ai', text, time: now },
+      ].slice(-60);
+      savedChat = item.chat;
+      return true;
+    });
+    return { text, chat: savedChat };
+  }
+
+  async function openDataFolder() {
+    const target = dataDir();
+    if (process.platform === 'darwin') await execFileAsync('open', [target]);
+    else if (process.platform === 'win32') await execFileAsync('explorer', [target]);
+    else await execFileAsync('xdg-open', [target]);
+    return { path: target };
+  }
+
+  async function exportData() {
+    const state = store.snapshot();
+    const lines = [
+      '# 柚客 Pomelo 本地导出',
+      '',
+      `导出时间：${new Date().toISOString()}`,
+      '',
+      '## 创作者资料',
+      '',
+      ...PROFILE_FIELDS.map(([key, label]) => `### ${label}
+${state.profile.answers[key] || '（未填写）'}
+`),
+      '',
+      '## 今日选题',
+      '',
+      ...(state.topics.items || []).map((topic, index) => `${index + 1}. ${topic.title}（${topic.platform} · ${topic.format}）
+   ${topic.reason || ''}`),
+      '',
+      '## 获客方案',
+      '',
+      ...(state.archives.find((item) => item.type === 'plan')?.sections || []).flatMap((section) => [`### ${section.h}`, section.p || '', ...(section.list || []).map((item) => `- ${item}`), '']),
+      '',
+      '## 复盘归档',
+      '',
+      ...state.archives.map((archive) => `- [${archive.type}] ${archive.title} · ${archive.time}`),
+      '',
+    ];
+    const folder = path.join(os.homedir(), 'Downloads');
+    let target = dataDir();
+    try {
+      await fs.access(folder);
+      target = folder;
+    } catch {
+      /* use data dir */
+    }
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const file = path.join(target, `pomelo-export-${stamp}.md`);
+    await fs.writeFile(file, lines.join('\n'), 'utf8');
+    return { path: file, archives: state.archives.length };
+  }
+
+  async function dispatch(action, payload) {
+    switch (action) {
+      case 'state': {
+        const state = store.snapshot();
+        let model = null;
+        try {
+          model = getDefaultModel()?.currentSelection?.() || null;
+        } catch {
+          model = null;
+        }
+        return { ...state, license: licenseView(state.license), model };
+      }
+      case 'profile.save': {
+        const answers = {};
+        for (const [key] of PROFILE_FIELDS) answers[key] = cleanText(payload?.profile?.[key], 4000);
+        const profile = await store.update((state) => {
+          state.profile = {
+            answers,
+            version: (state.profile.version || 0) + 1,
+            updatedAt: nowISO(),
+          };
+          state.topics.stale = true;
+          return state.profile;
+        });
+        return profile;
+      }
+      case 'model.check': {
+        const text = await complete('只回复 OK 两个字母，不要标点，不要解释。', { maxTokens: 24, temperature: 0 });
+        let selection = null;
+        try {
+          selection = getDefaultModel()?.currentSelection?.() || null;
+        } catch {
+          selection = null;
+        }
+        return { text, model: selection };
+      }
+      case 'topics.generate':
+        return generateTopics();
+      case 'topic.replace':
+        return replaceTopic(payload);
+      case 'account.analyze':
+        return analyzeAccount(payload);
+      case 'script.generate':
+        return generateScript(payload);
+      case 'plan.generate':
+        return generatePlan();
+      case 'review.ask':
+        return reviewAsk(payload);
+      case 'archive.add': {
+        const archive = toArchive(payload?.archive || {});
+        const fingerprint = archiveFingerprint(archive);
+        const existing = store.snapshot().archives.find((item) => archiveFingerprint(item) === fingerprint);
+        if (existing) return { ...existing, duplicate: true };
+        const saved = await store.update((state) => {
+          state.archives.unshift(archive);
+          state.archives = state.archives.slice(0, 500);
+          return archive;
+        });
+        return { ...saved, duplicate: false };
+      }
+      case 'archive.delete': {
+        const id = cleanText(payload?.id, 80);
+        const removed = await store.update((state) => {
+          const before = state.archives.length;
+          state.archives = state.archives.filter((item) => item.id !== id);
+          return state.archives.length !== before;
+        });
+        return { removed };
+      }
+      case 'state.clear': {
+        await store.update((state) => {
+          const license = state.license;
+          Object.assign(state, emptyState());
+          state.license = license;
+          return true;
+        });
+        return true;
+      }
+      case 'model.list': {
+        const llm = getLlm();
+        const defaultModel = getDefaultModel();
+        const selection = defaultModel?.currentSelection?.() || null;
+        if (!llm) throw rpcError('MODEL_UNAVAILABLE', 'DSH 模型服务未就绪');
+        const providers = typeof llm.listProviders === 'function' ? llm.listProviders() : [];
+        const result = [];
+        for (const provider of providers) {
+          try {
+            const models = typeof llm.listModels === 'function' ? await llm.listModels(provider.id) : [];
+            result.push({
+              id: provider.id,
+              name: provider.name || provider.id,
+              models: (models || []).map((model) => ({
+                id: model.id,
+                name: model.name || model.id,
+                description: model.description || '',
+              })),
+            });
+          } catch (error) {
+            result.push({ id: provider.id, name: provider.name || provider.id, models: [], error: String(error?.message || error) });
+          }
+        }
+        return { selection, providers: result };
+      }
+      case 'model.select': {
+        const llm = getLlm();
+        const defaultModel = getDefaultModel();
+        const provider = cleanText(payload?.provider, 120);
+        const model = cleanText(payload?.model, 240);
+        if (!llm || !defaultModel) throw rpcError('MODEL_UNAVAILABLE', 'DSH 模型服务未就绪');
+        if (!provider || !model) throw rpcError('MODEL_EMPTY', '请选择模型');
+        let models = [];
+        try {
+          models = await llm.listModels(provider);
+        } catch (error) {
+          throw rpcError('MODEL_LIST_FAILED', `读取 ${provider} 模型失败：${error?.message || error}`);
+        }
+        if (!models.some((item) => item.id === model)) {
+          throw rpcError('MODEL_INVALID', '这个模型不在当前 DSH 可选列表中');
+        }
+        try {
+          await defaultModel.saveSelection({ provider, model });
+        } catch (error) {
+          throw rpcError('MODEL_SAVE_FAILED', `切换模型失败：${error?.message || error}`);
+        }
+        const selection = defaultModel.currentSelection?.() || { provider, model };
+        await store.log(`模型切换：${provider} / ${model}`);
+        return { selection };
+      }
+      case 'license.status':
+        return licenseView(store.snapshot().license);
+      case 'license.validate': {
+        const state = store.snapshot();
+        const current = state.license;
+        if (!current?.codeId || !state.installId) return licenseView(current);
+        try {
+          const { response } = await licenseRequest('/api/license/validate', { installId: state.installId }, 8000);
+          if (response.status === 404 || response.status === 403) {
+            await store.update((next) => { next.license = null; return true; });
+            return { status: 'inactive' };
+          }
+          const data = await response.json().catch(() => ({}));
+          if (response.ok && data?.ok && data.license) {
+            const remote = data.license;
+            const license = {
+              status: 'active', plan: remote.plan || remote.tier || current.plan,
+              tier: remote.tier || remote.plan || current.tier,
+              expiresAt: remote.expiresAt || current.expiresAt,
+              activatedAt: remote.activatedAt || current.activatedAt,
+              codeId: remote.codeId || current.codeId,
+              maskedCode: remote.maskedCode || current.maskedCode,
+            };
+            return store.update((next) => { next.license = license; return licenseView(license); });
+          }
+        } catch {
+          /* offline: keep the last known local license */
+        }
+        return licenseView(current);
+      }
+      case 'license.activate': {
+        const code = cleanText(payload?.code, 64).toUpperCase().replace(/\s+/g, '');
+        if (!code) throw rpcError('LICENSE_EMPTY', '请先粘贴授权码');
+        const state = store.snapshot();
+        const installId = state.installId || crypto.randomUUID();
+        let response;
+        try {
+          ({ response } = await licenseRequest('/api/activate', { code, installId }, 12000));
+        } catch (error) {
+          await store.log(`授权服务不可达：${error?.message || error}`);
+          throw rpcError('LICENSE_SERVER_UNAVAILABLE', '授权服务器暂时无法连接，请稍后重试');
+        }
+        const data = await response.json().catch(() => ({}));
+        if (!response.ok || !data?.ok) {
+          throw rpcError(data?.error?.code || 'LICENSE_FAILED', data?.error?.message || `授权失败（${response.status}）`);
+        }
+        const remote = data.license || {};
+        const license = {
+          status: 'active',
+          plan: remote.plan || remote.tier || 'year',
+          tier: remote.tier || remote.plan || 'year',
+          expiresAt: remote.expiresAt || null,
+          activatedAt: remote.activatedAt || nowISO(),
+          codeId: remote.codeId || null,
+          maskedCode: remote.maskedCode || '',
+        };
+        const next = await store.update((currentState) => {
+          currentState.installId = installId;
+          currentState.license = license;
+          return licenseView(license);
+        });
+        await store.log(`云端授权激活：${license.maskedCode || '••••'} · ${license.tier} · 到期 ${license.expiresAt}`);
+        return next;
+      }
+      case 'data.openFolder':
+        return openDataFolder();
+      case 'data.export':
+        return exportData();
+      case 'browser.status':
+        return browserStatus();
+      case 'browser.login':
+        return openLogin(payload?.platform || '小红书');
+      case 'browser.install':
+        return installBrowser();
+      case 'browser.open':
+        return openLink(payload?.url);
+      case 'search.run': {
+        const platform = payload?.platform === '抖音' ? '抖音' : '小红书';
+        const keyword = cleanText(payload?.keyword, 80);
+        if (!keyword) throw rpcError('EMPTY_KEYWORD', '请输入关键词');
+        let result;
+        try {
+          result = await searchPublic({ platform, keyword });
+        } catch (error) {
+          await store.log(`搜索失败：${platform} / ${keyword} / ${error?.message || error}`);
+          throw rpcError(error?.code || 'BROWSER_FAILED', error?.message || '本地浏览器采集失败');
+        }
+        let report = null;
+        try {
+          report = await analyzeSearch(result.posts, keyword, platform);
+        } catch (error) {
+          await store.log(`搜索结果分析失败：${error?.message || error}`);
+        }
+        return { ...result, report };
+      }
+      case 'peer.history':
+        return store.snapshot().peerHistory || [];
+      case 'peer.run': {
+        const platform = payload?.platform === '抖音' ? '抖音' : '小红书';
+        const account = cleanText(payload?.account, 120);
+        if (!account) throw rpcError('EMPTY_ACCOUNT', '先粘贴同行账号或 ID');
+        let result;
+        try {
+          result = await searchPeerProfile({ platform, account });
+        } catch (error) {
+          await store.log(`同行搜索失败：${platform} / ${account} / ${error?.message || error}`);
+          throw rpcError(error?.code || 'BROWSER_FAILED', error?.message || '本地浏览器采集失败');
+        }
+        const state = store.snapshot();
+        const previous = (state.peerHistory || []).find((item) => item.platform === platform
+          && ((result.profileUrl && item.profileUrl === result.profileUrl)
+            || item.account === account.replace(/^@/, '')));
+        const comparison = comparePeer(previous, result);
+        let insight = { summary: [], tags: [] };
+        try {
+          insight = await analyzePeer(result.posts, account, platform, comparison);
+        } catch (error) {
+          await store.log(`同行分析失败：${error?.message || error}`);
+        }
+        const report = {
+          id: `peer_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 7)}`,
+          account: account.replace(/^@/, ''),
+          name: result.name,
+          avatar: result.avatar,
+          platform,
+          followers: result.followers,
+          postCount: result.postCount,
+          profileUrl: result.profileUrl,
+          posts: result.posts,
+          summary: insight.summary,
+          tags: insight.tags,
+          comparison,
+          collectedAt: result.collectedAt,
+        };
+        await store.update((current) => {
+          current.peerHistory = [report, ...(current.peerHistory || [])].slice(0, 30);
+          return true;
+        });
+        return report;
+      }
+      default:
+        throw rpcError('UNKNOWN_ACTION', `未知操作：${action}`);
+    }
+  }
+
+  const dispose = webServer.register({
+    kind: 'prefix',
+    path: RPC_PATH,
+    handler: async (req, res) => {
+      const origin = typeof req.headers.origin === 'string' ? req.headers.origin : '';
+      const requestUrl = new URL(String(req.url || '/'), 'http://127.0.0.1');
+      const pathname = requestUrl.pathname;
+      await store.log(`HTTP ${req.method} ${requestUrl.pathname}${requestUrl.search ? '?…' : ''}`);
+      if (req.method === 'GET' && pathname === `${RPC_PATH}/token`) {
+        sendJson(res, 200, { token });
+        return;
+      }
+      if (req.method === 'GET' && pathname === RPC_PATH) {
+        const action = String(requestUrl.searchParams.get('action') || '');
+        let payload = {};
+        try {
+          payload = JSON.parse(requestUrl.searchParams.get('payload') || '{}');
+        } catch {
+          sendJson(res, 400, { ok: false, error: { code: 'BAD_JSON', message: 'payload 不是 JSON' } }, origin);
+          return;
+        }
+        if (String(requestUrl.searchParams.get('t') || req.headers['x-pomelo-token'] || '') !== token) {
+          sendJson(res, 403, { ok: false, error: { code: 'AUTH', message: 'RPC token 无效' } }, origin);
+          return;
+        }
+        try {
+          const data = await dispatch(action, payload);
+          sendJson(res, 200, { ok: true, data }, origin);
+        } catch (error) {
+          await store.log(`RPC GET 失败：${String(error?.message || error)}`);
+          sendJson(res, 200, { ok: false, error: { code: error?.code || 'INTERNAL', message: error?.message || '请求失败' } }, origin);
+        }
+        return;
+      }
+      if (req.method === 'OPTIONS') {
+        sendJson(res, 204, {}, origin);
+        return;
+      }
+      if (req.method !== 'POST') {
+        sendJson(res, 405, { ok: false, error: { code: 'METHOD', message: '只支持 POST' } }, origin);
+        return;
+      }
+      if (String(req.headers['x-pomelo-token'] || '') !== token) {
+        sendJson(res, 403, { ok: false, error: { code: 'AUTH', message: 'RPC token 无效' } }, origin);
+        return;
+      }
+      try {
+        const body = await readBody(req);
+        const data = await dispatch(String(body.action || ''), body.payload || {});
+        sendJson(res, 200, { ok: true, data }, origin);
+      } catch (error) {
+        await store.log(`RPC ${String(req.url)} 失败：${String(error?.message || error)}`);
+        sendJson(res, 200, {
+          ok: false,
+          error: {
+            code: error?.code || 'INTERNAL',
+            message: error?.message || '请求失败',
+          },
+        }, origin);
+      }
+    },
+  });
+
+  await store.log(`RPC 已注册：${RPC_PATH}`);
+
+  await store.log(`连接探针已注册：${RPC_PATH}/token`);
+
+  if (typeof ctx.effect === 'function') {
+    ctx.effect(() => dispose);
+  }
+}