@lightcone-ai/daemon 0.11.0 → 0.12.0

package/mcp-servers/official/platform-policy-db/index.js

@@ -0,0 +1,316 @@
+#!/usr/bin/env node
+import { z } from 'zod';
+import { startFixtureServer } from '../../official-common/server.js';
+
+const FIXTURE_META = Object.freeze({
+  mode: 'fixture',
+  as_of: '2026-04-29',
+  capability: 'platform-policy-db',
+  disclaimer: 'Policy fixtures are static snapshots; always verify against latest platform notices.',
+});
+
+const PLATFORM_POLICY_DATA = Object.freeze({
+  xhs: Object.freeze({
+    platform: 'xhs',
+    display_name: '小红书',
+    policy_version: 'xhs-2026.04',
+    updated_at: '2026-04-22',
+    ai_label_required: true,
+    ad_disclosure_required: true,
+    policy_window_days: 7,
+    required_labels: {
+      ad: '赞助',
+      ai: 'AI 生成内容标识',
+    },
+    sensitive_terms: Object.freeze([
+      {
+        id: 'xhs-external-redirect-wechat',
+        term: '微信',
+        severity: 'blocker',
+        reason: '站外导流词，易触发限流或违规。',
+        action: 'remove_redirect_hint',
+      },
+      {
+        id: 'xhs-external-redirect-qr',
+        term: '二维码',
+        severity: 'blocker',
+        reason: '站外导流相关词，发布前需清理。',
+        action: 'remove_redirect_hint',
+      },
+      {
+        id: 'xhs-fake-luxury',
+        term: '高仿',
+        severity: 'blocker',
+        reason: '涉嫌仿冒交易，政策高风险。',
+        action: 'reject_publish',
+      },
+      {
+        id: 'xhs-medical-guarantee',
+        term: '疗效保证',
+        severity: 'warn',
+        reason: '医疗功效承诺需附免责声明并谨慎表述。',
+        action: 'add_disclaimer',
+      },
+      {
+        id: 'xhs-finance-guarantee',
+        term: '稳赚不赔',
+        severity: 'blocker',
+        reason: '金融收益承诺违规风险高。',
+        action: 'remove_claim',
+      },
+    ]),
+  }),
+  douyin: Object.freeze({
+    platform: 'douyin',
+    display_name: '抖音',
+    policy_version: 'douyin-2026.04',
+    updated_at: '2026-04-20',
+    ai_label_required: true,
+    ad_disclosure_required: true,
+    policy_window_days: 7,
+    required_labels: {
+      ad: '广告',
+      ai: 'AI 生成声明',
+    },
+    sensitive_terms: Object.freeze([
+      {
+        id: 'douyin-fake-news',
+        term: '内幕消息',
+        severity: 'blocker',
+        reason: '未经证实信息易触发平台处罚。',
+        action: 'remove_unverified_claim',
+      },
+      {
+        id: 'douyin-disaster-clickbait',
+        term: '震惊全国',
+        severity: 'warn',
+        reason: '标题党表达可能降低推荐稳定性。',
+        action: 'tone_down_title',
+      },
+      {
+        id: 'douyin-finance-guarantee',
+        term: '保本保收益',
+        severity: 'blocker',
+        reason: '金融收益保障承诺违规。',
+        action: 'remove_claim',
+      },
+      {
+        id: 'douyin-medical-cure',
+        term: '包治百病',
+        severity: 'blocker',
+        reason: '医疗夸大宣传高风险。',
+        action: 'remove_claim',
+      },
+      {
+        id: 'douyin-traffic-manipulation',
+        term: '互赞互粉',
+        severity: 'warn',
+        reason: '可被识别为异常增长操作。',
+        action: 'remove_growth_hack',
+      },
+    ]),
+  }),
+  'wechat-mp': Object.freeze({
+    platform: 'wechat-mp',
+    display_name: '公众号',
+    policy_version: 'wechat-mp-2026.04',
+    updated_at: '2026-04-19',
+    ai_label_required: false,
+    ad_disclosure_required: true,
+    policy_window_days: 7,
+    required_labels: {
+      ad: '广告/合作声明',
+      ai: '建议标注 AI 生成来源',
+    },
+    sensitive_terms: Object.freeze([
+      {
+        id: 'wechatmp-clickbait-share',
+        term: '不转不是中国人',
+        severity: 'blocker',
+        reason: '诱导分享属于明确违规。',
+        action: 'remove_manipulative_phrase',
+      },
+      {
+        id: 'wechatmp-political-rumor',
+        term: '内部通知',
+        severity: 'warn',
+        reason: '疑似无来源权威口径，需补证据。',
+        action: 'add_citation_or_remove',
+      },
+      {
+        id: 'wechatmp-medical-guarantee',
+        term: '根治',
+        severity: 'warn',
+        reason: '医疗强承诺需免责声明并谨慎表达。',
+        action: 'add_disclaimer',
+      },
+      {
+        id: 'wechatmp-finance-guarantee',
+        term: '稳赚',
+        severity: 'blocker',
+        reason: '金融收益承诺违规。',
+        action: 'remove_claim',
+      },
+      {
+        id: 'wechatmp-fake-scarcity',
+        term: '最后一天',
+        severity: 'warn',
+        reason: '虚假稀缺文案易触发风控。',
+        action: 'verify_or_tone_down',
+      },
+    ]),
+  }),
+});
+
+function normalizePlatform(value) {
+  const raw = String(value ?? '').trim().toLowerCase();
+  if (!raw) return '';
+  if (raw === 'xiaohongshu' || raw === 'redbook') return 'xhs';
+  if (raw === 'wechat' || raw === 'wechatmp' || raw === 'wechat_mp' || raw === 'gzh' || raw === '公众号') {
+    return 'wechat-mp';
+  }
+  if (raw === 'tiktok_cn') return 'douyin';
+  return raw;
+}
+
+function findSnippet(text, term) {
+  const source = String(text ?? '');
+  const target = String(term ?? '');
+  if (!source || !target) return '';
+
+  const index = source.toLowerCase().indexOf(target.toLowerCase());
+  if (index < 0) return '';
+
+  const start = Math.max(0, index - 10);
+  const end = Math.min(source.length, index + target.length + 10);
+  return source.slice(start, end);
+}
+
+function listPlatformsSummary() {
+  return Object.values(PLATFORM_POLICY_DATA).map((entry) => ({
+    platform: entry.platform,
+    display_name: entry.display_name,
+    policy_version: entry.policy_version,
+    updated_at: entry.updated_at,
+    ai_label_required: entry.ai_label_required,
+    ad_disclosure_required: entry.ad_disclosure_required,
+    sensitive_term_count: entry.sensitive_terms.length,
+  }));
+}
+
+await startFixtureServer({
+  serverId: 'platform-policy-db',
+  serverName: 'official-platform-policy-db',
+  toolName: 'platform_policy_db',
+  toolDescription: 'Return policy fixtures and sensitive-term scan results for publishing precheck.',
+  inputSchema: {
+    operation: z.enum(['list_platforms', 'get_rules', 'scan_text']).optional()
+      .describe('Operation: list platforms, get platform rules, or scan draft text.'),
+    platform: z.string().optional()
+      .describe('Target platform id or alias, e.g. xhs, douyin, wechat-mp.'),
+    text: z.string().optional()
+      .describe('Draft text for sensitive-term scan when operation=scan_text.'),
+    include_terms: z.boolean().optional()
+      .describe('Whether full term list is included in get_rules result (default true).'),
+    max_matches: z.number().int().min(1).max(100).optional()
+      .describe('Max returned violations for scan_text (default 20).'),
+    policy_version: z.string().optional()
+      .describe('Optional expected policy version; mismatch is returned as warning.'),
+  },
+  handler: ({
+    operation = 'get_rules',
+    platform,
+    text,
+    include_terms = true,
+    max_matches = 20,
+    policy_version,
+  }) => {
+    if (operation === 'list_platforms') {
+      return {
+        ...FIXTURE_META,
+        operation,
+        count: Object.keys(PLATFORM_POLICY_DATA).length,
+        platforms: listPlatformsSummary(),
+      };
+    }
+
+    const normalizedPlatform = normalizePlatform(platform);
+    if (!normalizedPlatform || !Object.hasOwn(PLATFORM_POLICY_DATA, normalizedPlatform)) {
+      throw new Error(`unsupported_platform:${platform}`);
+    }
+
+    const policy = PLATFORM_POLICY_DATA[normalizedPlatform];
+    const versionMismatch = policy_version && policy_version !== policy.policy_version;
+
+    if (operation === 'get_rules') {
+      return {
+        ...FIXTURE_META,
+        operation,
+        platform: policy.platform,
+        display_name: policy.display_name,
+        policy_version: policy.policy_version,
+        updated_at: policy.updated_at,
+        ai_label_required: policy.ai_label_required,
+        ad_disclosure_required: policy.ad_disclosure_required,
+        policy_window_days: policy.policy_window_days,
+        required_labels: policy.required_labels,
+        sensitive_term_count: policy.sensitive_terms.length,
+        sensitive_terms: include_terms ? policy.sensitive_terms : undefined,
+        warnings: versionMismatch ? [{
+          code: 'policy_version_mismatch',
+          expected: policy.policy_version,
+          received: policy_version,
+        }] : [],
+      };
+    }
+
+    const draftText = String(text ?? '').trim();
+    if (!draftText) {
+      throw new Error('scan_text_requires_text');
+    }
+
+    const limitedMaxMatches = Math.max(1, Math.min(100, Math.trunc(Number(max_matches) || 20)));
+    const lowerText = draftText.toLowerCase();
+
+    const violations = [];
+    for (const rule of policy.sensitive_terms) {
+      if (!lowerText.includes(rule.term.toLowerCase())) continue;
+      violations.push({
+        rule_id: rule.id,
+        term: rule.term,
+        severity: rule.severity,
+        reason: rule.reason,
+        action: rule.action,
+        snippet: findSnippet(draftText, rule.term),
+      });
+      if (violations.length >= limitedMaxMatches) break;
+    }
+
+    const severityStats = violations.reduce((acc, item) => {
+      acc[item.severity] = (acc[item.severity] ?? 0) + 1;
+      return acc;
+    }, {});
+    const blockerCount = severityStats.blocker ?? 0;
+
+    return {
+      ...FIXTURE_META,
+      operation,
+      platform: policy.platform,
+      policy_version: policy.policy_version,
+      scanned_length: draftText.length,
+      match_count: violations.length,
+      blocker_count: blockerCount,
+      has_blocker: blockerCount > 0,
+      severity_stats: severityStats,
+      violations,
+      warnings: versionMismatch ? [{
+        code: 'policy_version_mismatch',
+        expected: policy.policy_version,
+        received: policy_version,
+      }] : [],
+      required_labels: policy.required_labels,
+      ai_label_required: policy.ai_label_required,
+      ad_disclosure_required: policy.ad_disclosure_required,
+    };
+  },
+});

package/mcp-servers/official/platform-policy-db/manifest.json

@@ -0,0 +1,18 @@
+{
+  "id": "platform-policy-db",
+  "name": "Official Platform Policy DB MCP",
+  "version": "0.1.0",
+  "runtime": "node",
+  "entrypoint": "index.js",
+  "tool_declarations": [
+    { "name": "platform_policy_db", "classification": "mandatory" }
+  ],
+  "smoke_test": {
+    "tool": "platform_policy_db",
+    "arguments": {
+      "operation": "scan_text",
+      "platform": "xhs",
+      "text": "本内容仅分享经验，不含微信或二维码导流。"
+    }
+  }
+}

package/mcp-servers/official/publish-window-optimizer/index.js

@@ -0,0 +1,296 @@
+#!/usr/bin/env node
+import { z } from 'zod';
+import { startFixtureServer } from '../../official-common/server.js';
+
+const FIXTURE_META = Object.freeze({
+  mode: 'fixture',
+  as_of: '2026-04-29',
+  capability: 'publish-window-optimizer',
+  disclaimer: 'Recommendations are heuristic and should be validated against real account telemetry.',
+});
+
+const BASELINE_HOUR_SCORES = Object.freeze({
+  xhs: Object.freeze({
+    7: 45, 8: 62, 11: 66, 12: 72, 13: 60, 18: 76, 19: 85, 20: 91, 21: 87, 22: 74,
+  }),
+  douyin: Object.freeze({
+    8: 54, 12: 64, 13: 58, 17: 74, 18: 82, 19: 91, 20: 95, 21: 88, 22: 80, 23: 70,
+  }),
+  'wechat-mp': Object.freeze({
+    7: 68, 8: 84, 9: 76, 12: 79, 18: 58, 20: 73, 21: 80, 22: 71,
+  }),
+});
+
+function normalizePlatform(value) {
+  const raw = String(value ?? '').trim().toLowerCase();
+  if (!raw) return 'xhs';
+  if (raw === 'xiaohongshu' || raw === 'redbook') return 'xhs';
+  if (raw === 'wechat' || raw === 'wechat_mp' || raw === 'wechatmp' || raw === 'gzh' || raw === '公众号') {
+    return 'wechat-mp';
+  }
+  if (raw === 'tiktok_cn') return 'douyin';
+  if (!Object.hasOwn(BASELINE_HOUR_SCORES, raw)) return 'xhs';
+  return raw;
+}
+
+function safeTimeZone(timeZone) {
+  const zone = String(timeZone ?? '').trim();
+  if (!zone) return 'Asia/Shanghai';
+  try {
+    new Intl.DateTimeFormat('en-US', { timeZone: zone }).format(new Date());
+    return zone;
+  } catch {
+    return 'Asia/Shanghai';
+  }
+}
+
+function extractHour(dateLike, timeZone) {
+  const date = new Date(dateLike);
+  if (Number.isNaN(date.getTime())) return null;
+  const hourText = new Intl.DateTimeFormat('en-US', {
+    hour: '2-digit',
+    hour12: false,
+    timeZone,
+  }).format(date);
+  const hour = Number(hourText);
+  return Number.isInteger(hour) ? hour : null;
+}
+
+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)));
+}
+
+function toFiniteNumber(value) {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+
+function metricScore(sample, primaryMetric) {
+  const metric = String(primaryMetric ?? '').trim().toLowerCase();
+
+  if (metric === 'engagement_rate') {
+    const v = toFiniteNumber(sample.engagement_rate);
+    return v == null ? null : v * 100;
+  }
+  if (metric === 'conversion_rate') {
+    const v = toFiniteNumber(sample.conversion_rate);
+    return v == null ? null : v * 120;
+  }
+  if (metric === 'views') {
+    const v = toFiniteNumber(sample.views);
+    return v == null ? null : v / 120;
+  }
+  if (metric === 'clicks') {
+    const v = toFiniteNumber(sample.clicks);
+    return v == null ? null : v * 1.2;
+  }
+
+  const engagementRate = toFiniteNumber(sample.engagement_rate);
+  const conversionRate = toFiniteNumber(sample.conversion_rate);
+  const views = toFiniteNumber(sample.views);
+  const clicks = toFiniteNumber(sample.clicks);
+
+  let score = 0;
+  let used = 0;
+  if (engagementRate != null) {
+    score += engagementRate * 80;
+    used += 1;
+  }
+  if (conversionRate != null) {
+    score += conversionRate * 120;
+    used += 1;
+  }
+  if (views != null) {
+    score += views / 150;
+    used += 1;
+  }
+  if (clicks != null) {
+    score += clicks;
+    used += 1;
+  }
+
+  if (used === 0) return null;
+  return score / used;
+}
+
+function buildHourScoring({
+  platform,
+  history,
+  primaryMetric,
+  timeZone,
+}) {
+  const baseline = BASELINE_HOUR_SCORES[platform] ?? {};
+  const hourState = new Map();
+  for (let hour = 0; hour < 24; hour += 1) {
+    hourState.set(hour, {
+      hour,
+      baseline_score: Number(baseline[hour] ?? 35),
+      observed_sum: 0,
+      observed_count: 0,
+      observed_avg: null,
+      score: Number(baseline[hour] ?? 35),
+    });
+  }
+
+  for (const sample of history) {
+    const publishedAt = String(sample?.published_at ?? sample?.publishedAt ?? '').trim();
+    if (!publishedAt) continue;
+    const hour = extractHour(publishedAt, timeZone);
+    if (hour == null) continue;
+    const sampleScore = metricScore(sample, primaryMetric);
+    if (sampleScore == null) continue;
+
+    const entry = hourState.get(hour);
+    if (!entry) continue;
+    entry.observed_sum += sampleScore;
+    entry.observed_count += 1;
+  }
+
+  for (const entry of hourState.values()) {
+    if (entry.observed_count > 0) {
+      entry.observed_avg = entry.observed_sum / entry.observed_count;
+      const blended = entry.baseline_score * 0.35 + entry.observed_avg * 0.65;
+      entry.score = Number(blended.toFixed(2));
+    } else {
+      entry.score = Number(entry.baseline_score.toFixed(2));
+    }
+  }
+
+  return [...hourState.values()];
+}
+
+function circularHourGap(fromHour, toHour) {
+  const raw = Math.abs(fromHour - toHour);
+  return Math.min(raw, 24 - raw);
+}
+
+function formatHourRange(hour) {
+  const start = String(hour).padStart(2, '0');
+  const end = String((hour + 1) % 24).padStart(2, '0');
+  return `${start}:00-${end}:00`;
+}
+
+await startFixtureServer({
+  serverId: 'publish-window-optimizer',
+  serverName: 'official-publish-window-optimizer',
+  toolName: 'publish_window_optimizer',
+  toolDescription: 'Suggest best publish windows by platform and account history heuristics.',
+  inputSchema: {
+    platform: z.enum(['xhs', 'douyin', 'wechat-mp']).optional()
+      .describe('Target platform identifier.'),
+    account_id: z.string().optional().describe('Account identifier for reporting only.'),
+    timezone: z.string().optional().describe('IANA time zone, default Asia/Shanghai.'),
+    primary_metric: z.enum(['engagement_rate', 'conversion_rate', 'views', 'clicks']).optional()
+      .describe('Metric used for score aggregation; default is blended score.'),
+    history: z.array(z.object({
+      published_at: z.string(),
+      engagement_rate: z.number().optional(),
+      conversion_rate: z.number().optional(),
+      views: z.number().optional(),
+      clicks: z.number().optional(),
+    })).optional().describe('Historical publish samples for the account.'),
+    current_time: z.string().optional().describe('Override current timestamp for advisory output.'),
+    limit: z.number().int().min(1).max(6).optional().describe('Top-N windows for best/secondary lists.'),
+  },
+  handler: ({
+    platform,
+    account_id,
+    timezone,
+    primary_metric,
+    history = [],
+    current_time,
+    limit = 3,
+  }) => {
+    const normalizedPlatform = normalizePlatform(platform);
+    const normalizedTimeZone = safeTimeZone(timezone);
+    const safeLimit = clampInt(limit, 1, 6, 3);
+    const scoreRows = buildHourScoring({
+      platform: normalizedPlatform,
+      history: Array.isArray(history) ? history : [],
+      primaryMetric: primary_metric,
+      timeZone: normalizedTimeZone,
+    });
+
+    const ranked = [...scoreRows]
+      .sort((a, b) => {
+        if (b.score !== a.score) return b.score - a.score;
+        return a.hour - b.hour;
+      });
+
+    const bestWindows = ranked.slice(0, safeLimit).map((item) => ({
+      hour: item.hour,
+      window: formatHourRange(item.hour),
+      score: item.score,
+      evidence_count: item.observed_count,
+    }));
+
+    const secondaryWindows = ranked.slice(safeLimit, safeLimit * 2).map((item) => ({
+      hour: item.hour,
+      window: formatHourRange(item.hour),
+      score: item.score,
+      evidence_count: item.observed_count,
+    }));
+
+    const avoidWindows = [...ranked]
+      .reverse()
+      .slice(0, safeLimit)
+      .map((item) => ({
+        hour: item.hour,
+        window: formatHourRange(item.hour),
+        score: item.score,
+      }));
+
+    const now = current_time ? new Date(current_time) : new Date();
+    const currentHour = Number.isNaN(now.getTime())
+      ? null
+      : extractHour(now.toISOString(), normalizedTimeZone);
+
+    const topHour = bestWindows[0]?.hour ?? null;
+    const gap = (currentHour != null && topHour != null)
+      ? circularHourGap(currentHour, topHour)
+      : null;
+
+    const advisory = (() => {
+      if (currentHour == null || topHour == null || gap == null) {
+        return {
+          level: 'neutral',
+          message: 'Insufficient timing context for real-time advisory.',
+          delay_recommended: false,
+          suggested_window: bestWindows[0]?.window ?? null,
+        };
+      }
+      if (gap > 2) {
+        return {
+          level: 'suggest_delay',
+          message: `Current hour is ${gap}h away from top window; consider delaying to ${formatHourRange(topHour)}.`,
+          delay_recommended: true,
+          suggested_window: formatHourRange(topHour),
+          current_hour_window: formatHourRange(currentHour),
+        };
+      }
+      return {
+        level: 'ok_to_publish',
+        message: `Current hour is close to recommended window (${formatHourRange(topHour)}).`,
+        delay_recommended: false,
+        suggested_window: formatHourRange(topHour),
+        current_hour_window: formatHourRange(currentHour),
+      };
+    })();
+
+    return {
+      ...FIXTURE_META,
+      platform: normalizedPlatform,
+      account_id: account_id ?? null,
+      timezone: normalizedTimeZone,
+      primary_metric: primary_metric ?? 'blended',
+      history_sample_count: Array.isArray(history) ? history.length : 0,
+      best_windows: bestWindows,
+      secondary_windows: secondaryWindows,
+      avoid_windows: avoidWindows,
+      advisory,
+      generated_at: new Date().toISOString(),
+    };
+  },
+});

package/mcp-servers/official/publish-window-optimizer/manifest.json

@@ -0,0 +1,17 @@
+{
+  "id": "publish-window-optimizer",
+  "name": "Official Publish Window Optimizer MCP",
+  "version": "0.1.0",
+  "runtime": "node",
+  "entrypoint": "index.js",
+  "tool_declarations": [
+    { "name": "publish_window_optimizer", "classification": "cacheable" }
+  ],
+  "smoke_test": {
+    "tool": "publish_window_optimizer",
+    "arguments": {
+      "platform": "douyin",
+      "limit": 2
+    }
+  }
+}

package/mcp-servers/publisher/adapters/publisher-adapter.js

@@ -0,0 +1,37 @@
+export class PublisherAdapter {
+  constructor(cdp) {
+    this._cdp = cdp;
+  }
+
+  getCapabilities() {
+    throw new Error(`${this.constructor.name} must implement getCapabilities()`);
+  }
+
+  getRequirements(_contentType) {
+    throw new Error(`${this.constructor.name} must implement getRequirements(contentType)`);
+  }
+
+  async checkLoginStatus() {
+    throw new Error(`${this.constructor.name} must implement checkLoginStatus()`);
+  }
+
+  async publishImageText(_input) {
+    throw new Error(`${this.constructor.name} must implement publishImageText(input)`);
+  }
+
+  async publishShortVideo(_input) {
+    throw new Error(`${this.constructor.name} must implement publishShortVideo(input)`);
+  }
+
+  async publishLongVideo(_input) {
+    throw new Error('PUBLISH_UNSUPPORTED_CONTENT_TYPE: long_video is not supported by this adapter');
+  }
+
+  async publishLongText(_input) {
+    throw new Error('PUBLISH_UNSUPPORTED_CONTENT_TYPE: long_text is not supported by this adapter');
+  }
+
+  async withdrawPost(_input) {
+    throw new Error('PUBLISH_UNSUPPORTED_FEATURE: withdraw_post is not supported by this adapter');
+  }
+}