@lightcone-ai/daemon 0.15.17 → 0.15.18

package/mcp-servers/wechat-mp-fetch/index.js

@@ -0,0 +1,470 @@
+#!/usr/bin/env node
+import { randomUUID } from 'crypto';
+import { spawn } from 'child_process';
+import { accessSync, constants as fsConstants } from 'fs';
+import http from 'http';
+import net from 'net';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { WebSocket } from 'ws';
+import {
+  WECHAT_MP_ORIGIN,
+  assertWechatArticleUrl,
+  clampInt,
+  normalizeAppmsgPublishResponse,
+  normalizeSearchbizResponse,
+  parseArticleHtml,
+  parseJsonMaybe,
+} from './lib/core.js';
+
+const WECHAT_MP_PROFILE_DIR = process.env.WECHAT_MP_PROFILE_DIR ?? '';
+const SERVER_URL = process.env.SERVER_URL ?? '';
+const MACHINE_API_KEY = process.env.MACHINE_API_KEY ?? '';
+const AGENT_ID = process.env.AGENT_ID ?? '';
+const GOVERNANCE_SPAWN_BUNDLE_ID = process.env.GOVERNANCE_SPAWN_BUNDLE_ID ?? '';
+const GOVERNANCE_POLICY_VERSION = process.env.GOVERNANCE_POLICY_VERSION ?? '';
+const GOVERNANCE_POLICY_LEASE = parseJsonMaybe(process.env.GOVERNANCE_POLICY_LEASE ?? '');
+const REQUEST_TIMEOUT_MS = clampInt(process.env.WECHAT_MP_FETCH_TIMEOUT_MS, 3000, 60000, 12000);
+const MIN_REQUEST_INTERVAL_MS = clampInt(process.env.WECHAT_MP_MIN_INTERVAL_MS, 1000, 60000, 5000);
+const CACHE_TTL_MS = clampInt(process.env.WECHAT_MP_CACHE_TTL_MS, 5000, 3600000, 300000);
+const FINGERPRINT = String(process.env.WECHAT_MP_FINGERPRINT ?? '').trim();
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const cache = new Map();
+let lastRequestAt = 0;
+let session = null;
+
+function detectChrome() {
+  if (process.env.CHROME_BIN) return process.env.CHROME_BIN;
+  const candidates = [
+    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+    '/Applications/Chromium.app/Contents/MacOS/Chromium',
+    '/usr/bin/google-chrome',
+    '/usr/bin/google-chrome-stable',
+    '/usr/bin/chromium-browser',
+    '/usr/bin/chromium',
+    '/snap/bin/chromium',
+  ];
+  for (const p of candidates) {
+    try { accessSync(p, fsConstants.X_OK); return p; } catch {}
+  }
+  return candidates[0];
+}
+
+function getFreePort() {
+  return new Promise((resolve, reject) => {
+    const srv = net.createServer();
+    srv.listen(0, () => {
+      const port = srv.address().port;
+      srv.close(() => resolve(port));
+    });
+    srv.on('error', reject);
+  });
+}
+
+function httpGet(url) {
+  return new Promise((resolve, reject) => {
+    http.get(url, (res) => {
+      let body = '';
+      res.on('data', (d) => { body += d; });
+      res.on('end', () => resolve(body));
+    }).on('error', reject);
+  });
+}
+
+class CdpSession {
+  constructor() {
+    this._proc = null;
+    this._ws = null;
+    this._nextId = 1;
+    this._pending = new Map();
+    this._port = null;
+  }
+
+  async launch(profileDir) {
+    if (!profileDir) throw new Error('LOGIN_REQUIRED:WECHAT_MP_PROFILE_DIR is not configured');
+    const chrome = detectChrome();
+    this._port = await getFreePort();
+    this._proc = spawn(chrome, [
+      `--remote-debugging-port=${this._port}`,
+      '--no-sandbox',
+      '--disable-dev-shm-usage',
+      '--headless=new',
+      '--disable-blink-features=AutomationControlled',
+      '--disable-infobars',
+      '--user-agent=Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+      `--user-data-dir=${profileDir}`,
+      '--window-size=1280,900',
+      `${WECHAT_MP_ORIGIN}/cgi-bin/home?t=home/index&lang=zh_CN`,
+    ], { stdio: 'ignore' });
+
+    for (let i = 0; i < 50; i += 1) {
+      await sleep(300);
+      try { await httpGet(`http://localhost:${this._port}/json/version`); break; } catch {}
+      if (i === 49) throw new Error('LOGIN_REQUIRED:Chrome did not start');
+    }
+
+    const pages = JSON.parse(await httpGet(`http://localhost:${this._port}/json`));
+    const page = pages.find((p) => p.type === 'page') ?? pages[0];
+    if (!page?.webSocketDebuggerUrl) throw new Error('LOGIN_REQUIRED:no Chrome page found');
+    await this._connectWs(page.webSocketDebuggerUrl);
+    await this.cdp('Page.enable');
+    await this.cdp('Network.enable');
+    await this.cdp('Runtime.enable');
+  }
+
+  _connectWs(wsUrl) {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(wsUrl);
+      ws.on('open', () => { this._ws = ws; resolve(); });
+      ws.on('message', (data) => {
+        let msg = null;
+        try { msg = JSON.parse(data.toString()); } catch { return; }
+        if (msg.id == null) return;
+        const pending = this._pending.get(msg.id);
+        if (!pending) return;
+        clearTimeout(pending.timer);
+        this._pending.delete(msg.id);
+        if (msg.error) pending.reject(new Error(msg.error.message ?? 'CDP error'));
+        else pending.resolve(msg.result);
+      });
+      ws.on('error', reject);
+      ws.on('close', () => {
+        for (const [, pending] of this._pending) {
+          clearTimeout(pending.timer);
+          pending.reject(new Error('CDP websocket closed'));
+        }
+        this._pending.clear();
+        this._ws = null;
+      });
+    });
+  }
+
+  cdp(method, params = {}, timeoutMs = 30000) {
+    return new Promise((resolve, reject) => {
+      if (!this._ws) return reject(new Error('CDP session is not connected'));
+      const id = this._nextId;
+      this._nextId += 1;
+      const timer = setTimeout(() => {
+        this._pending.delete(id);
+        reject(new Error(`CDP timeout:${method}`));
+      }, timeoutMs);
+      this._pending.set(id, { resolve, reject, timer });
+      this._ws.send(JSON.stringify({ id, method, params }));
+    });
+  }
+
+  async navigate(url) {
+    await this.cdp('Page.navigate', { url });
+    await sleep(1500);
+  }
+
+  async evalValue(expression) {
+    const result = await this.cdp('Runtime.evaluate', {
+      expression,
+      awaitPromise: true,
+      returnByValue: true,
+    }, REQUEST_TIMEOUT_MS + 5000);
+    if (result?.exceptionDetails) {
+      throw new Error(result.exceptionDetails.text ?? 'Runtime.evaluate failed');
+    }
+    return result?.result?.value;
+  }
+
+  async currentUrl() {
+    return this.evalValue('location.href');
+  }
+}
+
+async function getSession() {
+  if (session) return session;
+  session = new CdpSession();
+  await session.launch(WECHAT_MP_PROFILE_DIR);
+  return session;
+}
+
+async function ensureLoggedIn() {
+  const cdp = await getSession();
+  let href = await cdp.currentUrl().catch(() => '');
+  if (!String(href).startsWith(WECHAT_MP_ORIGIN)) {
+    await cdp.navigate(`${WECHAT_MP_ORIGIN}/cgi-bin/home?t=home/index&lang=zh_CN`);
+    href = await cdp.currentUrl();
+  }
+  const token = new URL(String(href)).searchParams.get('token') ?? '';
+  if (!token) {
+    throw new Error('LOGIN_REQUIRED:WeChat MP backend login is required');
+  }
+  return { cdp, token };
+}
+
+async function throttle() {
+  const elapsed = Date.now() - lastRequestAt;
+  if (elapsed < MIN_REQUEST_INTERVAL_MS) {
+    await sleep(MIN_REQUEST_INTERVAL_MS - elapsed);
+  }
+  lastRequestAt = Date.now();
+}
+
+function cacheGet(key) {
+  const hit = cache.get(key);
+  if (!hit || hit.expiresAt < Date.now()) {
+    cache.delete(key);
+    return null;
+  }
+  return hit.value;
+}
+
+function cacheSet(key, value) {
+  cache.set(key, { value, expiresAt: Date.now() + CACHE_TTL_MS });
+}
+
+async function browserFetchJson(cdp, url) {
+  await throttle();
+  const payload = await cdp.evalValue(`(async () => {
+    const response = await fetch(${JSON.stringify(url)}, {
+      method: 'GET',
+      credentials: 'include',
+      headers: {
+        'Accept': 'application/json, text/javascript, */*; q=0.01',
+        'X-Requested-With': 'XMLHttpRequest'
+      }
+    });
+    const text = await response.text();
+    return JSON.stringify({ ok: response.ok, status: response.status, text });
+  })()`);
+  const envelope = parseJsonMaybe(payload);
+  if (!envelope) throw new Error('PARSE_FAILED:invalid browser fetch envelope');
+  const parsed = parseJsonMaybe(envelope.text);
+  if (!envelope.ok) throw new Error(`WECHAT_HTTP_${envelope.status}:${String(envelope.text).slice(0, 160)}`);
+  if (!parsed) throw new Error(`PARSE_FAILED:invalid JSON response:${String(envelope.text).slice(0, 160)}`);
+  const ret = parsed?.base_resp?.ret;
+  if (ret != null && Number(ret) !== 0) {
+    const errMsg = parsed?.base_resp?.err_msg ?? parsed?.base_resp?.errmsg ?? 'wechat_base_resp_error';
+    if (String(errMsg).toLowerCase().includes('freq')) throw new Error(`RATE_LIMITED:${errMsg}`);
+    throw new Error(`WECHAT_RISK_CONTROL:${ret}:${errMsg}`);
+  }
+  return parsed;
+}
+
+async function fetchText(url) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  try {
+    const res = await fetch(url, {
+      headers: {
+        'User-Agent': 'Mozilla/5.0 (wechat-mp-fetch-mcp)',
+        'Accept': 'text/html,*/*',
+      },
+      signal: controller.signal,
+    });
+    const text = await res.text();
+    if (!res.ok) throw new Error(`WECHAT_HTTP_${res.status}:${text.slice(0, 160)}`);
+    return text;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function checkGovernance(toolName, toolInput) {
+  if (!GOVERNANCE_SPAWN_BUNDLE_ID || !GOVERNANCE_POLICY_VERSION) return toolInput;
+  if (!SERVER_URL || !MACHINE_API_KEY || !AGENT_ID) throw new Error('governance_env_incomplete');
+  const response = await fetch(`${SERVER_URL}/governance/mcp-call`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${MACHINE_API_KEY}`,
+    },
+    body: JSON.stringify({
+      spawn_bundle_id: GOVERNANCE_SPAWN_BUNDLE_ID,
+      policy_version: GOVERNANCE_POLICY_VERSION,
+      tool_name: toolName,
+      tool_input: toolInput,
+      tool_classification: 'mandatory',
+      agent_id: AGENT_ID,
+      idempotency_key: randomUUID(),
+      lease_id: GOVERNANCE_POLICY_LEASE?.lease_id ?? null,
+    }),
+  });
+  const text = await response.text();
+  const body = parseJsonMaybe(text) ?? {};
+  if (!response.ok) throw new Error(`governance_http_${response.status}:${text.slice(0, 120)}`);
+  if (body.verdict === 'reject' || body.verdict === 'defer_human') {
+    throw new Error(`${body?.reason?.code ?? 'governance_blocked'}:${body?.reason?.message ?? 'governance rejected request'}`);
+  }
+  if (body.verdict === 'modify' && body.modified_input && typeof body.modified_input === 'object') {
+    return { ...toolInput, ...body.modified_input };
+  }
+  return toolInput;
+}
+
+async function searchAccounts(input) {
+  const query = String(input.query ?? '').trim();
+  if (!query) throw new Error('INVALID_INPUT:query is required');
+  const count = clampInt(input.count, 1, 10, 5);
+  const cacheKey = `search:${query}:${count}`;
+  const cached = cacheGet(cacheKey);
+  if (cached) return { ...cached, cache_hit: true };
+
+  const { cdp, token } = await ensureLoggedIn();
+  const url = new URL(`${WECHAT_MP_ORIGIN}/cgi-bin/searchbiz`);
+  url.searchParams.set('action', 'search_biz');
+  url.searchParams.set('begin', '0');
+  url.searchParams.set('count', String(count));
+  url.searchParams.set('query', query);
+  if (FINGERPRINT) url.searchParams.set('fingerprint', FINGERPRINT);
+  url.searchParams.set('token', token);
+  url.searchParams.set('lang', 'zh_CN');
+  url.searchParams.set('f', 'json');
+  url.searchParams.set('ajax', '1');
+  const payload = await browserFetchJson(cdp, url.toString());
+  const result = {
+    query,
+    accounts: normalizeSearchbizResponse(payload),
+    fetched_at: new Date().toISOString(),
+    source_type: 'wechat_mp',
+  };
+  cacheSet(cacheKey, result);
+  return result;
+}
+
+async function listRecentArticles(input) {
+  const limit = clampInt(input.limit, 1, 10, 5);
+  let fakeid = String(input.fakeid ?? '').trim();
+  let account = null;
+  if (!fakeid) {
+    const accountQuery = String(input.account_query ?? '').trim();
+    if (!accountQuery) throw new Error('INVALID_INPUT:fakeid or account_query is required');
+    const search = await searchAccounts({ query: accountQuery, count: 1 });
+    account = search.accounts[0] ?? null;
+    fakeid = account?.fakeid ?? '';
+  }
+  if (!fakeid) throw new Error('NOT_FOUND:no matching WeChat MP account');
+  const cacheKey = `articles:${fakeid}:${limit}`;
+  const cached = cacheGet(cacheKey);
+  if (cached) return { ...cached, cache_hit: true };
+
+  const { cdp, token } = await ensureLoggedIn();
+  const url = new URL(`${WECHAT_MP_ORIGIN}/cgi-bin/appmsgpublish`);
+  url.searchParams.set('sub', 'list');
+  url.searchParams.set('search_field', 'null');
+  url.searchParams.set('begin', '0');
+  url.searchParams.set('count', String(limit));
+  url.searchParams.set('query', '');
+  url.searchParams.set('fakeid', fakeid);
+  url.searchParams.set('type', '101_1');
+  url.searchParams.set('free_publish_type', '1');
+  url.searchParams.set('sub_action', 'list_ex');
+  if (FINGERPRINT) url.searchParams.set('fingerprint', FINGERPRINT);
+  url.searchParams.set('token', token);
+  url.searchParams.set('lang', 'zh_CN');
+  url.searchParams.set('f', 'json');
+  url.searchParams.set('ajax', '1');
+  const payload = await browserFetchJson(cdp, url.toString());
+  const normalized = normalizeAppmsgPublishResponse(payload);
+  const result = {
+    fakeid,
+    account,
+    articles: normalized.articles.slice(0, limit),
+    total_count: normalized.total_count,
+    fetched_at: new Date().toISOString(),
+    source_type: 'wechat_mp',
+  };
+  cacheSet(cacheKey, result);
+  return result;
+}
+
+async function fetchArticle(input) {
+  const url = assertWechatArticleUrl(input.url);
+  const cacheKey = `article:${url}`;
+  const cached = cacheGet(cacheKey);
+  if (cached) return { ...cached, cache_hit: true };
+  const html = await fetchText(url);
+  const result = {
+    ...parseArticleHtml(html, url),
+    fetched_at: new Date().toISOString(),
+  };
+  if (!result.content_text) throw new Error('PARSE_FAILED:article body #js_content not found');
+  cacheSet(cacheKey, result);
+  return result;
+}
+
+function toolResult(value) {
+  return { content: [{ type: 'text', text: JSON.stringify(value, null, 2) }] };
+}
+
+function toolError(error) {
+  const message = error instanceof Error ? error.message : String(error ?? 'unknown_error');
+  return { isError: true, content: [{ type: 'text', text: message }] };
+}
+
+const server = new McpServer({ name: 'wechat-mp-fetch', version: '0.1.0' });
+
+server.tool(
+  'wechat_mp_check_login',
+  'Check whether the injected WeChat MP browser profile is logged in.',
+  {},
+  async () => {
+    try {
+      const { token } = await ensureLoggedIn();
+      return toolResult({ ok: true, logged_in: true, token_present: Boolean(token), source_type: 'wechat_mp' });
+    } catch (error) {
+      return toolError(error);
+    }
+  }
+);
+
+server.tool(
+  'wechat_mp_search_accounts',
+  'Search WeChat Official Accounts by name or alias using the logged-in MP backend session.',
+  {
+    query: z.string().describe('Official account name or WeChat alias'),
+    count: z.number().optional().describe('Max candidates, default 5, range 1-10'),
+  },
+  async (input) => {
+    try {
+      const checked = await checkGovernance('wechat_mp_search_accounts', { ...input, source_risk: 'private_backend_session' });
+      return toolResult(await searchAccounts(checked));
+    } catch (error) {
+      return toolError(error);
+    }
+  }
+);
+
+server.tool(
+  'wechat_mp_list_recent_articles',
+  'Fetch latest public articles for a WeChat Official Account fakeid or query.',
+  {
+    fakeid: z.string().optional().describe('WeChat MP fakeid from search results'),
+    account_query: z.string().optional().describe('Account name or alias; used only when fakeid is absent'),
+    limit: z.number().optional().describe('Max recent articles, default 5, range 1-10'),
+  },
+  async (input) => {
+    try {
+      const checked = await checkGovernance('wechat_mp_list_recent_articles', { ...input, source_risk: 'private_backend_session' });
+      return toolResult(await listRecentArticles(checked));
+    } catch (error) {
+      return toolError(error);
+    }
+  }
+);
+
+server.tool(
+  'wechat_mp_fetch_article',
+  'Fetch and parse one WeChat MP article body from a public mp.weixin.qq.com URL.',
+  {
+    url: z.string().describe('https://mp.weixin.qq.com article URL'),
+  },
+  async (input) => {
+    try {
+      const checked = await checkGovernance('wechat_mp_fetch_article', { ...input, source_risk: 'public_web_article' });
+      return toolResult(await fetchArticle(checked));
+    } catch (error) {
+      return toolError(error);
+    }
+  }
+);
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+console.error('[wechat-mp-fetch] MCP Server started');

package/mcp-servers/wechat-mp-fetch/lib/core.js

@@ -0,0 +1,166 @@
+export const WECHAT_MP_ORIGIN = 'https://mp.weixin.qq.com';
+
+export function clampInt(value, min, max, fallback) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return fallback;
+  return Math.max(min, Math.min(max, Math.trunc(n)));
+}
+
+export function parseJsonMaybe(value) {
+  if (!value || typeof value !== 'string') return null;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+
+export function normalizeAccount(raw = {}) {
+  return {
+    fakeid: String(raw.fakeid ?? '').trim(),
+    nickname: String(raw.nickname ?? '').trim(),
+    alias: String(raw.alias ?? raw.username ?? '').trim(),
+    avatar_url: String(raw.round_head_img ?? raw.head_img ?? raw.avatar_url ?? '').trim(),
+    signature: String(raw.signature ?? '').trim(),
+    service_type: Number.isFinite(Number(raw.service_type)) ? Number(raw.service_type) : null,
+    verify_status: Number.isFinite(Number(raw.verify_status)) ? Number(raw.verify_status) : null,
+    source_type: 'wechat_mp',
+  };
+}
+
+export function normalizeSearchbizResponse(payload = {}) {
+  const list = Array.isArray(payload.list)
+    ? payload.list
+    : Array.isArray(payload.data?.list)
+      ? payload.data.list
+      : [];
+  return list
+    .map(normalizeAccount)
+    .filter((item) => item.fakeid && item.nickname);
+}
+
+function unixToIso(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return '';
+  return new Date(n * 1000).toISOString();
+}
+
+function normalizeArticle(raw = {}, sentInfo = {}) {
+  const appmsgid = raw.appmsgid ?? raw.appmsg_id ?? raw.mid ?? null;
+  const itemidx = raw.itemidx ?? raw.item_idx ?? raw.idx ?? null;
+  const publishedAt = unixToIso(sentInfo.time)
+    || unixToIso(raw.update_time)
+    || unixToIso(raw.create_time);
+  return {
+    title: String(raw.title ?? '').trim(),
+    digest: String(raw.digest ?? '').trim(),
+    url: String(raw.link ?? raw.url ?? '').trim(),
+    cover_url: String(raw.cover ?? raw.cover_url ?? '').trim(),
+    published_at: publishedAt,
+    appmsgid: appmsgid == null ? null : Number(appmsgid),
+    itemidx: itemidx == null ? null : Number(itemidx),
+    source_type: 'wechat_mp',
+  };
+}
+
+export function normalizeAppmsgPublishResponse(payload = {}) {
+  const publishPage = typeof payload.publish_page === 'string'
+    ? parseJsonMaybe(payload.publish_page)
+    : payload.publish_page;
+  const publishList = Array.isArray(publishPage?.publish_list) ? publishPage.publish_list : [];
+  const articles = [];
+
+  for (const item of publishList) {
+    const publishInfo = typeof item?.publish_info === 'string'
+      ? parseJsonMaybe(item.publish_info)
+      : item?.publish_info;
+    if (!publishInfo) continue;
+    const sentInfo = publishInfo.sent_info && typeof publishInfo.sent_info === 'object'
+      ? publishInfo.sent_info
+      : {};
+    const primary = publishInfo.appmsg_info && typeof publishInfo.appmsg_info === 'object'
+      ? publishInfo.appmsg_info
+      : null;
+    const extras = Array.isArray(publishInfo.appmsgex) ? publishInfo.appmsgex : [];
+    const rows = primary ? [primary, ...extras] : extras;
+    for (const row of rows) {
+      const normalized = normalizeArticle(row, sentInfo);
+      if (normalized.title && normalized.url) articles.push(normalized);
+    }
+  }
+
+  return {
+    total_count: Number(publishPage?.total_count ?? articles.length),
+    articles,
+  };
+}
+
+export function assertWechatArticleUrl(rawUrl) {
+  let url;
+  try {
+    url = new URL(String(rawUrl ?? ''));
+  } catch {
+    throw new Error('INVALID_URL:article url is invalid');
+  }
+  if (url.protocol !== 'https:' || url.hostname !== 'mp.weixin.qq.com') {
+    throw new Error('INVALID_URL:only https://mp.weixin.qq.com article urls are allowed');
+  }
+  return url.toString();
+}
+
+export function decodeHtmlEntities(value) {
+  return String(value ?? '')
+    .replace(/&nbsp;/g, ' ')
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&#x([0-9a-f]+);/gi, (_, hex) => String.fromCodePoint(Number.parseInt(hex, 16)))
+    .replace(/&#(\d+);/g, (_, dec) => String.fromCodePoint(Number.parseInt(dec, 10)));
+}
+
+export function stripHtml(html) {
+  return decodeHtmlEntities(String(html ?? '')
+    .replace(/<script[\s\S]*?<\/script>/gi, ' ')
+    .replace(/<style[\s\S]*?<\/style>/gi, ' ')
+    .replace(/<br\s*\/?>/gi, '\n')
+    .replace(/<\/p>/gi, '\n')
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/[ \t\r\f\v]+/g, ' ')
+    .replace(/\n\s+/g, '\n')
+    .replace(/\n{3,}/g, '\n\n'))
+    .trim();
+}
+
+function metaContent(html, propertyOrName) {
+  const escaped = propertyOrName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const re = new RegExp(`<meta[^>]+(?:property|name)=["']${escaped}["'][^>]+content=["']([^"']*)["'][^>]*>`, 'i');
+  const reverse = new RegExp(`<meta[^>]+content=["']([^"']*)["'][^>]+(?:property|name)=["']${escaped}["'][^>]*>`, 'i');
+  return decodeHtmlEntities(re.exec(html)?.[1] ?? reverse.exec(html)?.[1] ?? '').trim();
+}
+
+export function parseArticleHtml(html, url = '') {
+  const raw = String(html ?? '');
+  const contentMatch = raw.match(/<div[^>]+id=["']js_content["'][^>]*>([\s\S]*?)<\/div>\s*(?:<script|<style|<div|<\/body>|$)/i);
+  const contentHtml = (contentMatch?.[1] ?? '').trim();
+  const title = metaContent(raw, 'og:title')
+    || decodeHtmlEntities(raw.match(/var\s+msg_title\s*=\s*["']([^"']*)["']/)?.[1] ?? '')
+    || decodeHtmlEntities(raw.match(/<title[^>]*>([\s\S]*?)<\/title>/i)?.[1] ?? '').trim();
+  const author = decodeHtmlEntities(raw.match(/var\s+nickname\s*=\s*["']([^"']*)["']/)?.[1] ?? '')
+    || metaContent(raw, 'og:article:author')
+    || '';
+  const images = [...contentHtml.matchAll(/<img[^>]+(?:data-src|src)=["']([^"']+)["'][^>]*>/gi)]
+    .map((match) => decodeHtmlEntities(match[1]).trim())
+    .filter(Boolean);
+
+  return {
+    title,
+    author,
+    url,
+    content_text: stripHtml(contentHtml),
+    content_html: contentHtml,
+    images,
+    source_type: 'wechat_mp',
+  };
+}

package/mcp-servers/wechat-mp-fetch/manifest.json

@@ -0,0 +1,17 @@
+{
+  "id": "wechat-mp-fetch",
+  "name": "WeChat MP Fetch MCP Server",
+  "version": "0.1.0",
+  "runtime": "node",
+  "entrypoint": "index.js",
+  "tool_declarations": [
+    { "name": "wechat_mp_check_login", "classification": "mandatory" },
+    { "name": "wechat_mp_search_accounts", "classification": "mandatory" },
+    { "name": "wechat_mp_list_recent_articles", "classification": "mandatory" },
+    { "name": "wechat_mp_fetch_article", "classification": "mandatory" }
+  ],
+  "smoke_test": {
+    "tool": "wechat_mp_check_login",
+    "arguments": {}
+  }
+}

package/mcp-servers/wechat-mp-fetch/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "wechat-mp-fetch-mcp-server",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "index.js",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "ws": "^8.20.0",
+    "zod": "^3.25.76"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightcone-ai/daemon",
-  "version": "0.15.17",
+  "version": "0.15.18",
   "type": "module",
   "main": "src/index.js",
   "bin": {

package/src/agent-manager.js

@@ -689,6 +689,7 @@ export class AgentManager {
       '${DOUYIN_PROFILE_DIR}': path.join(profileRoot, `douyin-${userId}`),
       '${KUAISHOU_PROFILE_DIR}': path.join(profileRoot, `kuaishou-${userId}`),
       '${BILIBILI_PROFILE_DIR}': path.join(profileRoot, `bilibili-${userId}`),
+      '${WECHAT_MP_PROFILE_DIR}': path.join(profileRoot, `wechat_mp-${userId}`),
     };
     const mcpServers = this._resolveDirectiveMcpServers(directive, baseReplacements);
 

package/src/mcp-config.js

@@ -7,6 +7,7 @@ const LEGACY_MCP_PATH_TOKENS = Object.freeze({
   '{platform_mcp_path}': 'platform',
   '{publisher_mcp_path}': 'publisher',
   '{research_fetch_mcp_path}': 'research-fetch',
+  '{wechat_mp_fetch_mcp_path}': 'wechat-mp-fetch',
   '{market_data_query_mcp_path}': 'market-data-query',
   '{company_fundamentals_mcp_path}': 'company-fundamentals',
   '{industry_report_mcp_path}': 'industry-report',
@@ -70,6 +71,7 @@ function baseEnvForServer(serverKey, { serverUrl, authToken, agentId, workspaceI
     || serverKey === 'publisher'
     || serverKey === 'platform'
     || serverKey === 'research-fetch'
+    || serverKey === 'wechat-mp-fetch'
     || serverKey === 'market-data-query'
     || serverKey === 'company-fundamentals'
     || serverKey === 'industry-report'