@lightcone-ai/daemon 0.10.3 → 0.12.0

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

@@ -3,12 +3,15 @@
  * Uses deterministic CDP operations — no AI vision required.
  */
 import { formatTextWithTags } from '../text.js';
+import { PublisherAdapter } from './publisher-adapter.js';
 
 function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
 function randomInt(min, max) { return Math.floor(min + Math.random() * (max - min + 1)); }
 
 const PACE_SCALE = Math.max(0.2, Number(process.env.PUBLISHER_PACE_SCALE ?? '1') || 1);
 const DRY_RUN = process.env.XHS_PUBLISH_DRY_RUN !== '0';
+const TITLE_MIN_LENGTH = 2;
+const TITLE_MAX_LENGTH = 20;
 async function humanPause(minMs, maxMs, label = '') {
   const ms = Math.round(randomInt(minMs, maxMs) * PACE_SCALE);
   if (label) console.error(`[XhsAdapter] pause ${label}: ${ms}ms`);
@@ -17,22 +20,74 @@ async function humanPause(minMs, maxMs, label = '') {
 
 const REQUIREMENTS = {
   image_text: {
+    platform: 'xhs',
+    content_type: 'image_text',
     max_text_length: 1000,
     max_images: 9,
     image_formats: ['jpg', 'jpeg', 'png', 'webp'],
-    required_fields: ['text', 'images'],
-    notes: '当前自动化支持上传图文，必须提供至少 1 张本地图片；标题建议 2-20 字；图片建议 3:4 竖版；话题标签写在正文末尾如 #话题名',
+    required_fields: ['title', 'text', 'images'],
+    optional_fields: ['tags'],
+    notes: [
+      '标题需 2-20 字',
+      '必须提供至少 1 张本地图片；图片建议 3:4 竖版',
+      '话题标签以 tags 数组传入，系统会自动拼接到正文',
+      '广告/合作内容必须带平台广告标识；命中策略会在 precheck 阻断',
+    ],
   },
   short_video: {
+    platform: 'xhs',
+    content_type: 'short_video',
     max_text_length: 1000,
-    max_images: 1,
-    video_max_duration: 600,
+    video_max_duration_sec: 600,
     video_formats: ['mp4', 'mov'],
-    required_fields: ['text', 'video'],
-    notes: '封面图建议 3:4；视频时长不超过 10 分钟',
+    required_fields: ['title', 'text', 'video'],
+    optional_fields: ['tags', 'cover'],
+    notes: [
+      '标题需 2-20 字',
+      '视频时长不超过 10 分钟',
+      '封面图建议 3:4；当前封面上传依赖页面能力',
+      '广告/合作内容必须带平台广告标识；命中策略会在 precheck 阻断',
+    ],
   },
 };
 
+const XHS_CAPABILITIES = Object.freeze({
+  platform: 'xhs',
+  display_name: '小红书',
+  spec_version: '0.1.0',
+  supportedDrivers: ['cdp'],
+  supportedContentTypes: ['image_text', 'short_video'],
+  max_image: 9,
+  max_duration: 600,
+  short_video_max_duration: 600,
+  image_formats: ['jpg', 'jpeg', 'png', 'webp'],
+  video_formats: ['mp4', 'mov'],
+  ai_label_required: true,
+  ad_disclosure_required: true,
+  sensitive_word_db_ref: {
+    skill: 'platform-policy-db',
+    platform: 'xhs',
+    version: 'xhs-2026.04',
+  },
+  cover_required_for_short_video: false,
+  cover_required_for_long_video: false,
+  dry_run_supported: true,
+  schedule_supported: false,
+  default_publish_rate: {
+    per_account_per_day_max: 4,
+    notes: '建议保持保守发布频率，避免触发平台风控',
+  },
+  platform_extras: {
+    platform: 'xhs',
+    topics_max: 10,
+    hashtag_max: 10,
+    poi_supported: true,
+    brand_partnership_required_for_ads: true,
+    cover_aspect_ratios: ['3:4', '1:1'],
+  },
+  evidence: 'verified',
+});
+
 const PUBLISH_URL = 'https://creator.xiaohongshu.com/publish/publish';
 const IMAGE_PUBLISH_URL = 'https://creator.xiaohongshu.com/publish/publish?target=image';
 const VIDEO_PUBLISH_URL = 'https://creator.xiaohongshu.com/publish/publish?source=video';
@@ -55,9 +110,13 @@ const ERROR_SELECTORS = [
   '[role="alert"]',
 ];
 
-export class XhsAdapter {
+export class XhsAdapter extends PublisherAdapter {
   constructor(cdp) {
-    this._cdp = cdp;
+    super(cdp);
+  }
+
+  getCapabilities() {
+    return XHS_CAPABILITIES;
   }
 
   getRequirements(contentType) {
@@ -74,10 +133,23 @@ export class XhsAdapter {
     const url = state.url;
     const loggedIn = state.isCreatorLoggedIn && !state.hasLoginHint;
     console.error(`[XhsAdapter] checkLoginStatus: loggedIn=${loggedIn} url=${url}`);
-    return { loggedIn, url, profileDir, userId: null, nickname: null };
+    return {
+      loggedIn,
+      url,
+      profileDir,
+      userId: null,
+      nickname: null,
+      authMode: 'cdp',
+      lastVerifiedAt: new Date().toISOString(),
+    };
   }
 
   async publishImageText({ title, text, tags = [], images = [] }) {
+    const normalizedTitle = this._normalizeAndValidateTitle(title);
+    if (images.length > XHS_CAPABILITIES.max_image) {
+      throw new Error(`INPUT_MEDIA_REJECTED: 小红书图文最多 ${XHS_CAPABILITIES.max_image} 张图`);
+    }
+
     await this._openPublishComposer('image');
     await this._assertReadyForPublish();
     await humanPause(2500, 5500, 'composer-ready');
@@ -93,10 +165,8 @@ export class XhsAdapter {
     }
 
     // Fill title
-    if (title) {
-      await this._fillField(TITLE_SELECTOR, title);
-      await humanPause(1200, 2800, 'after-title');
-    }
+    await this._fillField(TITLE_SELECTOR, normalizedTitle);
+    await humanPause(1200, 2800, 'after-title');
 
     // Fill content text and only append tags that are not already present.
     const fullText = formatTextWithTags(text, tags);
@@ -119,6 +189,8 @@ export class XhsAdapter {
   }
 
   async publishShortVideo({ title, text, tags = [], video, cover }) {
+    const normalizedTitle = this._normalizeAndValidateTitle(title);
+
     await this._openPublishComposer('video');
     await this._assertReadyForPublish();
     await humanPause(2500, 5500, 'composer-ready');
@@ -138,10 +210,8 @@ export class XhsAdapter {
       await humanPause(1800, 4200, 'after-cover-upload');
     }
 
-    if (title) {
-      await this._fillField(TITLE_SELECTOR, title);
-      await humanPause(1200, 2800, 'after-title');
-    }
+    await this._fillField(TITLE_SELECTOR, normalizedTitle);
+    await humanPause(1200, 2800, 'after-title');
 
     const fullText = formatTextWithTags(text, tags);
     await this._fillField(CONTENT_SELECTOR, fullText);
@@ -162,6 +232,22 @@ export class XhsAdapter {
     return { success: true, post_url: result.postUrl || result.url };
   }
 
+  async withdrawPost() {
+    throw new Error('PUBLISH_UNSUPPORTED_FEATURE: 小红书当前自动化未提供撤稿能力');
+  }
+
+  _normalizeAndValidateTitle(title) {
+    const normalized = String(title ?? '').trim();
+    if (!normalized) {
+      throw new Error(`INPUT_REQUIRED_FIELD_MISSING: 小红书标题不能为空（${TITLE_MIN_LENGTH}-${TITLE_MAX_LENGTH} 字）`);
+    }
+    const length = [...normalized].length;
+    if (length < TITLE_MIN_LENGTH || length > TITLE_MAX_LENGTH) {
+      throw new Error(`INPUT_TEXT_TOO_LONG: 小红书标题需 ${TITLE_MIN_LENGTH}-${TITLE_MAX_LENGTH} 字，当前 ${length} 字`);
+    }
+    return normalized;
+  }
+
   // ── CDP helpers ─────────────────────────────────────────────────────────────
 
   async _openPublishComposer(kind) {

package/mcp-servers/publisher/index.js

@@ -18,6 +18,8 @@ import { getSession, closeSession } from './chrome-pool.js';
 import { XhsAdapter } from './adapters/xhs.js';
 import { DouyinAdapter } from './adapters/douyin.js';
 import { KuaishouAdapter } from './adapters/kuaishou.js';
+import { callOfficialTool } from './official-tool-client.js';
+import { runPublishPrecheck } from './precheck.js';
 import { withProfileLock } from '../../src/profile-lock.js';
 
 const SERVER_URL      = process.env.SERVER_URL ?? '';
@@ -41,24 +43,40 @@ const PLATFORM_LABELS = {
   kuaishou: '快手',
 };
 
+const ADAPTER_REGISTRY = Object.freeze({
+  xhs: XhsAdapter,
+  douyin: DouyinAdapter,
+  kuaishou: KuaishouAdapter,
+});
+
 function getProfileDir(platform) {
   const key = PLATFORM_ENV_KEYS[platform];
   if (!key) return null;
   return process.env[key] ?? null;
 }
 
+function getAdapterClass(platform) {
+  const AdapterClass = ADAPTER_REGISTRY[platform];
+  if (!AdapterClass) throw new Error(`Unknown platform: ${platform}`);
+  return AdapterClass;
+}
+
+function createAdapter(platform, cdp) {
+  const AdapterClass = getAdapterClass(platform);
+  return new AdapterClass(cdp);
+}
+
+function createStaticAdapter(platform) {
+  return createAdapter(platform, null);
+}
+
 async function getAdapter(platform) {
   const profileDir = getProfileDir(platform);
   if (!profileDir) {
     throw new Error(`No profile dir for platform="${platform}". Has the user logged in and authorized this agent?`);
   }
   const cdp = await getSession(platform, profileDir);
-  switch (platform) {
-    case 'xhs':      return new XhsAdapter(cdp);
-    case 'douyin':   return new DouyinAdapter(cdp);
-    case 'kuaishou': return new KuaishouAdapter(cdp);
-    default: throw new Error(`Unknown platform: ${platform}`);
-  }
+  return createAdapter(platform, cdp);
 }
 
 async function withPublisherProfile(platform, fn) {
@@ -111,7 +129,7 @@ async function completeApproval(actionId, ok, result, error) {
   }
 }
 
-const MEDIA_LIMITS = {
+const DEFAULT_MEDIA_LIMITS = {
   xhs:      { maxImages: 9,  imageExts: ['.jpg', '.jpeg', '.png', '.webp'], videoExts: ['.mp4', '.mov'] },
   douyin:   { maxImages: 35, imageExts: ['.jpg', '.jpeg', '.png', '.webp'], videoExts: ['.mp4', '.mov', '.webm'] },
   kuaishou: { maxImages: 12, imageExts: ['.jpg', '.jpeg', '.png'],         videoExts: ['.mp4', '.mov'] },
@@ -218,8 +236,37 @@ function validateLocalFile(filePath, { kind, required = false, allowedExts = []
   return realFile;
 }
 
+function normalizeFormatExts(formats = [], fallback = []) {
+  if (!Array.isArray(formats) || formats.length === 0) return fallback;
+  return formats
+    .map(item => String(item ?? '').trim().toLowerCase())
+    .filter(Boolean)
+    .map(item => (item.startsWith('.') ? item : `.${item}`));
+}
+
+function resolveMediaLimits(platform, contentType) {
+  const fallback = DEFAULT_MEDIA_LIMITS[platform] ?? DEFAULT_MEDIA_LIMITS.xhs;
+  const adapter = createStaticAdapter(platform);
+  const requirements = adapter.getRequirements(contentType) ?? {};
+  const capabilities = typeof adapter.getCapabilities === 'function'
+    ? (adapter.getCapabilities() ?? {})
+    : {};
+
+  return {
+    maxImages: Number(requirements.max_images ?? capabilities.max_image ?? fallback.maxImages),
+    imageExts: normalizeFormatExts(
+      requirements.image_formats ?? capabilities.image_formats,
+      fallback.imageExts
+    ),
+    videoExts: normalizeFormatExts(
+      requirements.video_formats ?? capabilities.video_formats,
+      fallback.videoExts
+    ),
+  };
+}
+
 function validateMedia({ platform, contentType, images = [], video, cover }) {
-  const limits = MEDIA_LIMITS[platform] ?? MEDIA_LIMITS.xhs;
+  const limits = resolveMediaLimits(platform, contentType);
   if (contentType === 'image_text') {
     if (images.length === 0) {
       throw new Error(`image_text requires at least 1 image on ${platform}. Provide absolute image paths inside the agent workspace artifacts directory.`);
@@ -267,28 +314,77 @@ images/video 字段填写本地绝对路径（在 agent workspace 目录下）
     const label = PLATFORM_LABELS[platform] ?? platform;
     try {
       const approvalData = await validateApproval(approval_action_id, platform);
+      const approvalPayload = approvalData?.payload && typeof approvalData.payload === 'object' && !Array.isArray(approvalData.payload)
+        ? approvalData.payload
+        : {};
+      const precheck = await runPublishPrecheck({
+        platform,
+        title,
+        text,
+        tags: tags ?? [],
+        payload: approvalPayload,
+        callTool: callOfficialTool,
+      });
+      if (!precheck.ok) {
+        const blockerSummary = precheck.blockers.map(item => `${item.code}: ${item.message}`).join(' | ');
+        throw new Error(`PUBLISH_PRECHECK_BLOCKED:${blockerSummary || 'precheck failed'}`);
+      }
+
       const localMedia = await materializeMedia({ images: images ?? [], video, cover }, approvalData);
+      const staticAdapter = createStaticAdapter(platform);
+      const req = staticAdapter.getRequirements(content_type);
+      if (!req) throw new Error(`INPUT_UNSUPPORTED_CONTENT_TYPE: ${platform} does not support ${content_type}`);
       const media = validateMedia({ platform, contentType: content_type, ...localMedia });
-      const result = await withPublisherProfile(platform, async () => {
+      const { publishResult, healthCheck } = await withPublisherProfile(platform, async () => {
         const adapter = await getAdapter(platform);
+        let publishResult = null;
         if (content_type === 'image_text') {
-          return adapter.publishImageText({ title, text, tags: tags ?? [], images: media.images });
+          publishResult = await adapter.publishImageText({ title, text, tags: tags ?? [], images: media.images });
+        } else if (content_type === 'short_video') {
+          publishResult = await adapter.publishShortVideo({ title, text, tags: tags ?? [], video: media.video, cover: media.cover });
+        } else {
+          throw new Error(`Unsupported content_type: ${content_type}`);
         }
-        if (content_type === 'short_video') {
-          return adapter.publishShortVideo({ title, text, tags: tags ?? [], video: media.video, cover: media.cover });
+
+        let healthCheck = null;
+        try {
+          healthCheck = await adapter.checkLoginStatus();
+        } catch (error) {
+          healthCheck = {
+            loggedIn: null,
+            error: error.message,
+          };
         }
-        throw new Error(`Unsupported content_type: ${content_type}`);
+        return { publishResult, healthCheck };
       });
 
-      await completeApproval(approval_action_id, true, result, null);
-      if (result?.dry_run) {
+      const completionResult = {
+        precheck: {
+          blockers: precheck.blockers,
+          warnings: precheck.warnings,
+          policy_version: precheck?.policyScan?.policy_version ?? null,
+          advisory: precheck?.advisory?.advisory ?? null,
+        },
+        publish_result: publishResult,
+        post_publish_health: healthCheck,
+      };
+      await completeApproval(approval_action_id, true, completionResult, null);
+
+      const advisoryMessage = precheck?.advisory?.advisory?.level === 'suggest_delay'
+        ? `\n发布建议：${precheck.advisory.advisory.message}`
+        : '';
+      const healthMessage = healthCheck?.loggedIn === false
+        ? '\n发布后巡检：账号登录状态异常，请尽快复核凭据。'
+        : '';
+
+      if (publishResult?.dry_run) {
         return {
-          content: [{ type: 'text', text: `✓ ${label}发布流程已完成到发布前一步，已跳过最终“发布”点击。` }],
+          content: [{ type: 'text', text: `✓ ${label}发布流程已完成到发布前一步，已跳过最终“发布”点击。${advisoryMessage}${healthMessage}` }],
         };
       }
-      const postUrl = result.post_url ? `\n发布链接: ${result.post_url}` : '';
+      const postUrl = publishResult?.post_url ? `\n发布链接: ${publishResult.post_url}` : '';
       return {
-        content: [{ type: 'text', text: `✓ 已成功发布到${label}。${postUrl}` }],
+        content: [{ type: 'text', text: `✓ 已成功发布到${label}。${postUrl}${advisoryMessage}${healthMessage}` }],
       };
     } catch (err) {
       if (err.message?.startsWith('LOGIN_EXPIRED')) {
@@ -299,6 +395,14 @@ images/video 字段填写本地绝对路径（在 agent workspace 目录下）
           isError: true,
         };
       }
+      if (err.message?.startsWith('PUBLISH_PRECHECK_BLOCKED:')) {
+        const message = err.message.replace('PUBLISH_PRECHECK_BLOCKED:', '').trim();
+        if (approval_action_id) await completeApproval(approval_action_id, false, null, err.message);
+        return {
+          content: [{ type: 'text', text: `发布前预检未通过：${message}` }],
+          isError: true,
+        };
+      }
       if (approval_action_id) await completeApproval(approval_action_id, false, null, err.message);
       return {
         content: [{ type: 'text', text: `发布失败: ${err.message}` }],
@@ -319,13 +423,7 @@ server.tool(
   },
   async ({ platform, content_type }) => {
     try {
-      let adapter;
-      switch (platform) {
-        case 'xhs':      adapter = new XhsAdapter(null); break;
-        case 'douyin':   adapter = new DouyinAdapter(null); break;
-        case 'kuaishou': adapter = new KuaishouAdapter(null); break;
-        default: throw new Error(`Unknown platform: ${platform}`);
-      }
+      const adapter = createStaticAdapter(platform);
       const req = adapter.getRequirements(content_type);
       if (!req) return { content: [{ type: 'text', text: `该平台不支持 ${content_type} 类型` }] };
       return { content: [{ type: 'text', text: JSON.stringify(req, null, 2) }] };

package/mcp-servers/publisher/official-tool-client.js

@@ -0,0 +1,171 @@
+import { spawn } from 'child_process';
+import { resolveMcpServerEntrypoint } from '../../../src/mcp/registry.js';
+
+function extractErrorText(result) {
+  const chunks = Array.isArray(result?.content) ? result.content : [];
+  const texts = chunks
+    .map(chunk => (typeof chunk?.text === 'string' ? chunk.text.trim() : ''))
+    .filter(Boolean);
+  if (texts.length > 0) return texts.join('\n');
+  return 'unknown_mcp_error';
+}
+
+function parseJsonContent(result) {
+  const chunks = Array.isArray(result?.content) ? result.content : [];
+  const text = chunks
+    .map(chunk => (typeof chunk?.text === 'string' ? chunk.text : ''))
+    .join('\n')
+    .trim();
+  if (!text) return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { raw_text: text };
+  }
+}
+
+class StdioJsonRpcClient {
+  constructor(command, args = [], env = {}) {
+    this.command = command;
+    this.args = args;
+    this.env = env;
+    this.proc = null;
+    this.stdoutBuffer = '';
+    this.nextId = 1;
+    this.pending = new Map();
+  }
+
+  async start() {
+    if (this.proc) return;
+    this.proc = spawn(this.command, this.args, {
+      cwd: process.cwd(),
+      env: {
+        ...process.env,
+        ...this.env,
+      },
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    this.proc.stdout.setEncoding('utf8');
+    this.proc.stdout.on('data', chunk => this._handleStdout(chunk));
+    this.proc.on('exit', (code) => {
+      const error = new Error(`process_exited:${code}`);
+      for (const pending of this.pending.values()) {
+        clearTimeout(pending.timer);
+        pending.reject(error);
+      }
+      this.pending.clear();
+    });
+  }
+
+  _handleStdout(chunk) {
+    this.stdoutBuffer += chunk;
+    const lines = this.stdoutBuffer.split('\n');
+    this.stdoutBuffer = lines.pop() ?? '';
+
+    for (const line of lines) {
+      const text = line.trim();
+      if (!text) continue;
+
+      let payload;
+      try {
+        payload = JSON.parse(text);
+      } catch {
+        continue;
+      }
+      if (payload?.id == null) continue;
+
+      const pending = this.pending.get(payload.id);
+      if (!pending) continue;
+
+      clearTimeout(pending.timer);
+      this.pending.delete(payload.id);
+
+      if (payload.error) {
+        pending.reject(new Error(payload.error.message ?? 'jsonrpc_error'));
+      } else {
+        pending.resolve(payload.result);
+      }
+    }
+  }
+
+  request(method, params = {}, timeoutMs = 10000) {
+    if (!this.proc) {
+      return Promise.reject(new Error('client_not_started'));
+    }
+    const id = this.nextId++;
+    const payload = {
+      jsonrpc: '2.0',
+      id,
+      method,
+      params,
+    };
+
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`timeout:${method}`));
+      }, timeoutMs);
+
+      this.pending.set(id, { resolve, reject, timer });
+      this.proc.stdin.write(`${JSON.stringify(payload)}\n`);
+    });
+  }
+
+  notify(method, params = {}) {
+    if (!this.proc) return;
+    const payload = {
+      jsonrpc: '2.0',
+      method,
+      params,
+    };
+    this.proc.stdin.write(`${JSON.stringify(payload)}\n`);
+  }
+
+  async close() {
+    if (!this.proc) return;
+    if (!this.proc.killed) {
+      this.proc.kill('SIGTERM');
+      await new Promise(resolve => setTimeout(resolve, 100));
+      if (!this.proc.killed) this.proc.kill('SIGKILL');
+    }
+    this.proc = null;
+  }
+}
+
+export async function callOfficialTool({
+  serverId,
+  toolName,
+  argumentsPayload = {},
+  timeoutMs = 10000,
+}) {
+  const entrypointPath = resolveMcpServerEntrypoint(serverId, { strict: true });
+  if (!entrypointPath) {
+    throw new Error(`official_server_not_found:${serverId}`);
+  }
+
+  const client = new StdioJsonRpcClient(process.execPath, [entrypointPath]);
+  try {
+    await client.start();
+    await client.request('initialize', {
+      protocolVersion: '2024-11-05',
+      capabilities: {},
+      clientInfo: {
+        name: 'publisher-official-tool-client',
+        version: '0.1.0',
+      },
+    }, timeoutMs);
+    client.notify('notifications/initialized', {});
+
+    const result = await client.request('tools/call', {
+      name: toolName,
+      arguments: argumentsPayload ?? {},
+    }, timeoutMs);
+    if (result?.isError === true) {
+      throw new Error(extractErrorText(result));
+    }
+    return parseJsonContent(result);
+  } finally {
+    await client.close();
+  }
+}