@zenalexa/unicli 0.207.1

package/src/adapters/xiaohongshu/notifications.yaml

@@ -0,0 +1,37 @@
+site: xiaohongshu
+name: notifications
+description: "Xiaohongshu notifications (mentions/likes/connections)"
+domain: www.xiaohongshu.com
+strategy: intercept
+browser: true
+
+args:
+  type:
+    type: str
+    default: mentions
+    description: "Notification type: mentions, likes, or connections"
+  limit:
+    type: int
+    default: 20
+    description: Number of notifications to return
+
+columns: [rank, user, action, content, note, time]
+
+pipeline:
+  - navigate: https://www.xiaohongshu.com/notification
+  - tap:
+      store: notification
+      action: getNotification
+      args:
+        - ${{ args.type | default('mentions') }}
+      capture: /you/
+      select: data.message_list
+      timeout: 8
+  - map:
+      rank: ${{ index + 1 }}
+      user: ${{ item.user_info.nickname }}
+      action: ${{ item.title }}
+      content: ${{ item.comment_info.content }}
+      note: ${{ item.item_info.content }}
+      time: ${{ item.time }}
+  - limit: ${{ args.limit | default(20) }}

package/src/adapters/xiaohongshu/publish.ts

@@ -0,0 +1,317 @@
+/**
+ * Xiaohongshu publish — creator center UI automation for image+text notes.
+ *
+ * Flow:
+ *   1. Navigate to creator publish page
+ *   2. Upload images via CDP setFileInput
+ *   3. Fill title and body text
+ *   4. Add topic hashtags
+ *   5. Publish (or save as draft)
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+import { cli, Strategy } from "../../registry.js";
+import type { IPage } from "../../types.js";
+
+const PUBLISH_URL =
+  "https://creator.xiaohongshu.com/publish/publish?from=menu_left";
+const MAX_IMAGES = 9;
+const MAX_TITLE_LEN = 20;
+
+const TITLE_SELECTORS = [
+  '[contenteditable="true"][placeholder*="标题"]',
+  '[contenteditable="true"][placeholder*="赞"]',
+  '[contenteditable="true"][class*="title"]',
+  'input[maxlength="20"]',
+  'input[class*="title"]',
+  'input[placeholder*="标题"]',
+  ".title-input input",
+  ".note-title input",
+  "input[maxlength]",
+];
+
+const SUPPORTED_EXTENSIONS: Record<string, string> = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+};
+
+function validateImagePaths(filePaths: string[]): string[] {
+  return filePaths.map((filePath) => {
+    const absPath = path.resolve(filePath);
+    if (!fs.existsSync(absPath))
+      throw new Error(`Image file not found: ${absPath}`);
+    const ext = path.extname(absPath).toLowerCase();
+    if (!SUPPORTED_EXTENSIONS[ext]) {
+      throw new Error(
+        `Unsupported image format "${ext}". Supported: jpg, png, gif, webp`,
+      );
+    }
+    return absPath;
+  });
+}
+
+async function fillField(
+  page: IPage,
+  selectors: string[],
+  text: string,
+  fieldName: string,
+): Promise<void> {
+  const result: { ok: boolean } = (await page.evaluate(`
+    (function(selectors, text) {
+      for (const sel of selectors) {
+        const candidates = document.querySelectorAll(sel);
+        for (const el of candidates) {
+          if (!el || el.offsetParent === null) continue;
+          el.focus();
+          if (el.tagName === 'INPUT' || el.tagName === 'TEXTAREA') {
+            el.value = '';
+            document.execCommand('selectAll', false);
+            document.execCommand('insertText', false, text);
+            el.dispatchEvent(new Event('input', { bubbles: true }));
+            el.dispatchEvent(new Event('change', { bubbles: true }));
+          } else {
+            el.textContent = '';
+            document.execCommand('selectAll', false);
+            document.execCommand('insertText', false, text);
+            el.dispatchEvent(new Event('input', { bubbles: true }));
+          }
+          return { ok: true };
+        }
+      }
+      return { ok: false };
+    })(${JSON.stringify(selectors)}, ${JSON.stringify(text)})
+  `)) as { ok: boolean };
+  if (!result.ok) {
+    throw new Error(`Could not find ${fieldName} input on the page.`);
+  }
+}
+
+cli({
+  site: "xiaohongshu",
+  name: "publish",
+  description:
+    "Publish an image+text note via Xiaohongshu creator center (UI automation)",
+  domain: "creator.xiaohongshu.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    { name: "title", required: true, description: "Note title (max 20 chars)" },
+    {
+      name: "content",
+      required: true,
+      positional: true,
+      description: "Note body text",
+    },
+    {
+      name: "images",
+      required: true,
+      description: "Image paths, comma-separated, max 9 (jpg/png/gif/webp)",
+    },
+    {
+      name: "topics",
+      description: "Topic hashtags, comma-separated, without # symbol",
+    },
+    {
+      name: "draft",
+      type: "bool",
+      default: false,
+      description: "Save as draft instead of publishing",
+    },
+  ],
+  columns: ["status", "detail"],
+  func: async (page, kwargs) => {
+    const p = page as IPage;
+
+    const title = String(kwargs.title ?? "").trim();
+    const content = String(kwargs.content ?? "").trim();
+    const imagePaths: string[] = kwargs.images
+      ? String(kwargs.images)
+          .split(",")
+          .map((s: string) => s.trim())
+          .filter(Boolean)
+      : [];
+    const topics: string[] = kwargs.topics
+      ? String(kwargs.topics)
+          .split(",")
+          .map((s: string) => s.trim())
+          .filter(Boolean)
+      : [];
+    const isDraft = Boolean(kwargs.draft);
+
+    // Validate inputs
+    if (!title) throw new Error("--title is required");
+    if (title.length > MAX_TITLE_LEN)
+      throw new Error(
+        `Title is ${title.length} chars — must be <= ${MAX_TITLE_LEN}`,
+      );
+    if (!content) throw new Error("Positional argument <content> is required");
+    if (imagePaths.length === 0)
+      throw new Error("At least one --images path is required.");
+    if (imagePaths.length > MAX_IMAGES)
+      throw new Error(
+        `Too many images: ${imagePaths.length} (max ${MAX_IMAGES})`,
+      );
+
+    const absImagePaths = validateImagePaths(imagePaths);
+
+    // Step 1: Navigate to publish page
+    await p.goto(PUBLISH_URL);
+    await p.wait(3);
+
+    // Step 2: Select image+text tab if present
+    await p.evaluate(`
+      () => {
+        const targets = ['上传图文', '图文', '图片'];
+        const nodes = Array.from(document.querySelectorAll('button, [role="tab"], [role="button"], a, label, div, span, li'));
+        for (const target of targets) {
+          for (const node of nodes) {
+            if (!node || node.offsetParent === null) continue;
+            const text = (node.innerText || node.textContent || '').replace(/\\s+/g, ' ').trim();
+            if (!text || text.includes('视频')) continue;
+            if (text === target || text.startsWith(target) || text.includes(target)) {
+              const clickable = node.closest('button, [role="tab"], [role="button"], a, label') || node;
+              clickable.click();
+              return true;
+            }
+          }
+        }
+        return false;
+      }
+    `);
+    await p.wait(1);
+
+    // Step 3: Upload images via setFileInput
+    const selector =
+      'input[type="file"][accept*="image"], input[type="file"][accept*=".jpg"]';
+    await p.setFileInput(selector, absImagePaths);
+    await p.wait(3);
+
+    // Step 4: Wait for edit form to appear
+    for (let i = 0; i < 10; i++) {
+      const found = (await p.evaluate(`
+        (() => {
+          const sels = ${JSON.stringify(TITLE_SELECTORS)};
+          for (const sel of sels) {
+            const el = document.querySelector(sel);
+            if (el && el.offsetParent !== null) return true;
+          }
+          return false;
+        })()
+      `)) as boolean;
+      if (found) break;
+      await p.wait(1);
+    }
+
+    // Step 5: Fill title
+    await fillField(p, TITLE_SELECTORS, title, "title");
+    await p.wait(0.5);
+
+    // Step 6: Fill content
+    await fillField(
+      p,
+      [
+        '[contenteditable="true"][class*="content"]',
+        '[contenteditable="true"][class*="editor"]',
+        '[contenteditable="true"][placeholder*="描述"]',
+        '[contenteditable="true"][placeholder*="正文"]',
+        '[contenteditable="true"][placeholder*="内容"]',
+        '.note-content [contenteditable="true"]',
+        '.editor-content [contenteditable="true"]',
+        '[contenteditable="true"]:not([placeholder*="标题"]):not([placeholder*="赞"])',
+      ],
+      content,
+      "content",
+    );
+    await p.wait(0.5);
+
+    // Step 7: Add topic hashtags
+    for (const topic of topics) {
+      await p.evaluate(`
+        () => {
+          const candidates = document.querySelectorAll('*');
+          for (const el of candidates) {
+            const text = (el.innerText || el.textContent || '').trim();
+            if (
+              (text === '添加话题' || text === '# 话题' || text.startsWith('添加话题')) &&
+              el.offsetParent !== null && el.children.length === 0
+            ) {
+              el.click();
+              return true;
+            }
+          }
+          return false;
+        }
+      `);
+      await p.wait(1);
+
+      await p.evaluate(`
+        (topicName => {
+          const input = document.querySelector('[class*="topic"] input, [class*="hashtag"] input, input[placeholder*="搜索话题"]');
+          if (!input || input.offsetParent === null) return false;
+          input.focus();
+          document.execCommand('insertText', false, topicName);
+          input.dispatchEvent(new Event('input', { bubbles: true }));
+          return true;
+        })(${JSON.stringify(topic)})
+      `);
+      await p.wait(1.5);
+
+      await p.evaluate(`
+        () => {
+          const item = document.querySelector('[class*="topic-item"], [class*="hashtag-item"], [class*="suggest-item"]');
+          if (item) item.click();
+        }
+      `);
+      await p.wait(0.5);
+    }
+
+    // Step 8: Publish or save draft
+    const actionLabels = isDraft
+      ? ["暂存离开", "存草稿"]
+      : ["发布", "发布笔记"];
+    const btnClicked = (await p.evaluate(`
+      (labels => {
+        const buttons = document.querySelectorAll('button, [role="button"]');
+        for (const btn of buttons) {
+          const text = (btn.innerText || btn.textContent || '').trim();
+          if (
+            labels.some(l => text === l || text.includes(l)) &&
+            btn.offsetParent !== null && !btn.disabled
+          ) {
+            btn.click();
+            return true;
+          }
+        }
+        return false;
+      })(${JSON.stringify(actionLabels)})
+    `)) as boolean;
+
+    if (!btnClicked) {
+      throw new Error(`Could not find "${actionLabels[0]}" button.`);
+    }
+
+    await p.wait(4);
+
+    const finalUrl = (await p.evaluate("() => location.href")) as string;
+    const navigatedAway = !finalUrl.includes("/publish/publish");
+    const verb = isDraft ? "Draft saved" : "Published";
+
+    return [
+      {
+        status: navigatedAway ? `ok: ${verb}` : `pending: verify in browser`,
+        detail: [
+          `"${title}"`,
+          `${absImagePaths.length} images`,
+          topics.length ? `topics: ${topics.join(" ")}` : "",
+        ]
+          .filter(Boolean)
+          .join(" | "),
+      },
+    ];
+  },
+});

package/src/adapters/xiaohongshu/search.ts

@@ -0,0 +1,137 @@
+/**
+ * Xiaohongshu search — DOM-based extraction from search results page.
+ *
+ * Navigates to the search results page and extracts data from rendered
+ * DOM elements.  Uses MutationObserver to wait for content or login wall.
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import type { IPage } from "../../types.js";
+
+/**
+ * Wait for search results or login wall using MutationObserver (max 5 s).
+ */
+const WAIT_FOR_CONTENT_JS = `
+  new Promise((resolve) => {
+    const detect = () => {
+      if (document.querySelector('section.note-item')) return 'content';
+      if (/登录后查看搜索结果/.test(document.body?.innerText || '')) return 'login_wall';
+      return null;
+    };
+    const found = detect();
+    if (found) return resolve(found);
+    const observer = new MutationObserver(() => {
+      const result = detect();
+      if (result) { observer.disconnect(); resolve(result); }
+    });
+    observer.observe(document.body, { childList: true, subtree: true });
+    setTimeout(() => { observer.disconnect(); resolve('timeout'); }, 5000);
+  })
+`;
+
+/**
+ * Extract approximate publish date from a Xiaohongshu note URL.
+ * XHS note IDs follow MongoDB ObjectID format where the first 8 hex
+ * characters encode a Unix timestamp.
+ */
+export function noteIdToDate(url: string): string {
+  const match = url.match(
+    /\/(?:search_result|explore|note)\/([0-9a-f]{24})(?=[?#/]|$)/i,
+  );
+  if (!match) return "";
+  const hex = match[1].substring(0, 8);
+  const ts = parseInt(hex, 16);
+  if (!ts || ts < 1_000_000_000 || ts > 4_000_000_000) return "";
+  return new Date((ts + 8 * 3600) * 1000).toISOString().slice(0, 10);
+}
+
+cli({
+  site: "xiaohongshu",
+  name: "search",
+  description: "Search notes on Xiaohongshu",
+  domain: "www.xiaohongshu.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    {
+      name: "query",
+      required: true,
+      positional: true,
+      description: "Search keyword",
+    },
+    {
+      name: "limit",
+      type: "int",
+      default: 20,
+      description: "Number of results",
+    },
+  ],
+  columns: ["rank", "title", "author", "likes", "published_at", "url"],
+  func: async (page, kwargs) => {
+    const p = page as IPage;
+    const keyword = encodeURIComponent(String(kwargs.query));
+    await p.goto(
+      `https://www.xiaohongshu.com/search_result?keyword=${keyword}&source=web_search_result_notes`,
+    );
+
+    const waitResult = await p.evaluate(WAIT_FOR_CONTENT_JS);
+
+    if (waitResult === "login_wall") {
+      throw new Error(
+        "Xiaohongshu search results are blocked behind a login wall",
+      );
+    }
+
+    // Scroll a couple of times to load more results
+    await p.autoScroll({ maxScrolls: 2, delay: 1500 });
+
+    const payload = await p.evaluate(`
+      (() => {
+        const normalizeUrl = (href) => {
+          if (!href) return '';
+          if (href.startsWith('http://') || href.startsWith('https://')) return href;
+          if (href.startsWith('/')) return 'https://www.xiaohongshu.com' + href;
+          return '';
+        };
+        const cleanText = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+        const results = [];
+        const seen = new Set();
+        document.querySelectorAll('section.note-item').forEach(el => {
+          if (el.classList.contains('query-note-item')) return;
+          const titleEl = el.querySelector('.title, .note-title, a.title, .footer .title span');
+          const nameEl = el.querySelector('a.author .name, .name, .author-name, .nick-name, a.author');
+          const likesEl = el.querySelector('.count, .like-count, .like-wrapper .count');
+          const detailLinkEl =
+            el.querySelector('a.cover.mask') ||
+            el.querySelector('a[href*="/search_result/"]') ||
+            el.querySelector('a[href*="/explore/"]') ||
+            el.querySelector('a[href*="/note/"]');
+          const url = normalizeUrl(detailLinkEl?.getAttribute('href') || '');
+          if (!url) return;
+          if (seen.has(url)) return;
+          seen.add(url);
+          results.push({
+            title: cleanText(titleEl?.textContent || ''),
+            author: cleanText(nameEl?.textContent || ''),
+            likes: cleanText(likesEl?.textContent || '0'),
+            url,
+          });
+        });
+        return results;
+      })()
+    `);
+
+    const limit = Number(kwargs.limit) || 20;
+    const data: Record<string, unknown>[] = Array.isArray(payload)
+      ? (payload as Record<string, unknown>[])
+      : [];
+    return data
+      .filter((item) => item.title)
+      .slice(0, limit)
+      .map((item, i) => ({
+        rank: i + 1,
+        ...item,
+        published_at: noteIdToDate(String(item.url ?? "")),
+      }));
+  },
+});

package/src/adapters/xiaohongshu/user-helpers.ts

@@ -0,0 +1,126 @@
+export interface XhsUserPageSnapshot {
+  noteGroups?: unknown;
+  pageData?: unknown;
+}
+
+export interface XhsUserNoteRow {
+  id: string;
+  title: string;
+  type: string;
+  likes: string;
+  cover: string;
+  url: string;
+}
+
+function toCleanString(value: unknown): string {
+  return typeof value === "string"
+    ? value.trim()
+    : value == null
+      ? ""
+      : String(value).trim();
+}
+
+export function normalizeXhsUserId(input: string): string {
+  const trimmed = toCleanString(input);
+  const withoutQuery = trimmed.replace(/[?#].*$/, "");
+  const matched = withoutQuery.match(/\/user\/profile\/([a-zA-Z0-9]+)/);
+  if (matched?.[1]) return matched[1];
+  return withoutQuery.replace(/\/+$/, "").split("/").pop() ?? withoutQuery;
+}
+
+export function flattenXhsNoteGroups(noteGroups: unknown): unknown[] {
+  if (!Array.isArray(noteGroups)) return [];
+
+  const notes: unknown[] = [];
+  for (const group of noteGroups) {
+    if (!group) continue;
+    if (Array.isArray(group)) {
+      for (const item of group) {
+        if (item) notes.push(item);
+      }
+      continue;
+    }
+    notes.push(group);
+  }
+
+  return notes;
+}
+
+export function buildXhsNoteUrl(
+  userId: string,
+  noteId: string,
+  xsecToken?: string,
+): string {
+  const cleanUserId = toCleanString(userId);
+  const cleanNoteId = toCleanString(noteId);
+  if (!cleanUserId || !cleanNoteId) return "";
+
+  const url = new URL(
+    `https://www.xiaohongshu.com/user/profile/${cleanUserId}/${cleanNoteId}`,
+  );
+  const cleanToken = toCleanString(xsecToken);
+  if (cleanToken) {
+    url.searchParams.set("xsec_token", cleanToken);
+    url.searchParams.set("xsec_source", "pc_user");
+  }
+  return url.toString();
+}
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export function extractXhsUserNotes(
+  snapshot: XhsUserPageSnapshot,
+  fallbackUserId: string,
+): XhsUserNoteRow[] {
+  const notes = flattenXhsNoteGroups(snapshot.noteGroups);
+  const rows: XhsUserNoteRow[] = [];
+  const seen = new Set<string>();
+
+  for (const entry of notes) {
+    const e = entry as Record<string, any>;
+    const noteCard = e?.noteCard ?? e?.note_card ?? e;
+    if (!noteCard || typeof noteCard !== "object") continue;
+
+    const noteId = toCleanString(
+      noteCard.noteId ?? noteCard.note_id ?? e?.noteId ?? e?.note_id ?? e?.id,
+    );
+    if (!noteId || seen.has(noteId)) continue;
+    seen.add(noteId);
+
+    const userId = toCleanString(
+      noteCard.user?.userId ?? noteCard.user?.user_id ?? fallbackUserId,
+    );
+    const xsecToken = toCleanString(
+      e?.xsecToken ??
+        e?.xsec_token ??
+        noteCard.xsecToken ??
+        noteCard.xsec_token,
+    );
+    const likes =
+      toCleanString(
+        noteCard.interactInfo?.likedCount ??
+          noteCard.interact_info?.liked_count ??
+          0,
+      ) || "0";
+
+    const cover = toCleanString(
+      noteCard.cover?.urlDefault ??
+        noteCard.cover?.urlPre ??
+        noteCard.cover?.url ??
+        "",
+    );
+
+    rows.push({
+      id: noteId,
+      title: toCleanString(
+        noteCard.displayTitle ?? noteCard.display_title ?? noteCard.title,
+      ),
+      type: toCleanString(noteCard.type),
+      likes,
+      cover,
+      url: buildXhsNoteUrl(userId || fallbackUserId, noteId, xsecToken),
+    });
+  }
+
+  return rows;
+}
+/* eslint-enable @typescript-eslint/no-explicit-any */

package/src/adapters/xiaohongshu/user.ts

@@ -0,0 +1,79 @@
+/**
+ * Xiaohongshu user — public notes from a user profile page.
+ *
+ * Navigates to the profile, reads __INITIAL_STATE__ for note data,
+ * and scrolls to load more if needed.
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import type { IPage } from "../../types.js";
+import { extractXhsUserNotes, normalizeXhsUserId } from "./user-helpers.js";
+
+async function readUserSnapshot(
+  page: IPage,
+): Promise<{ noteGroups: unknown; pageData: unknown }> {
+  return (await page.evaluate(`
+    (() => {
+      const safeClone = (value) => {
+        try {
+          return JSON.parse(JSON.stringify(value ?? null));
+        } catch {
+          return null;
+        }
+      };
+      const userStore = window.__INITIAL_STATE__?.user || {};
+      return {
+        noteGroups: safeClone(userStore.notes?._value || userStore.notes || []),
+        pageData: safeClone(userStore.userPageData?._value || userStore.userPageData || {}),
+      };
+    })()
+  `)) as { noteGroups: unknown; pageData: unknown };
+}
+
+cli({
+  site: "xiaohongshu",
+  name: "user",
+  description: "Get public notes from a Xiaohongshu user profile",
+  domain: "www.xiaohongshu.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    {
+      name: "id",
+      required: true,
+      positional: true,
+      description: "User id or profile URL",
+    },
+    { name: "limit", type: "int", default: 15, description: "Number of notes" },
+  ],
+  columns: ["id", "title", "type", "likes", "url"],
+  func: async (page, kwargs) => {
+    const p = page as IPage;
+    const userId = normalizeXhsUserId(String(kwargs.id));
+    const limit = Math.max(1, Number(kwargs.limit ?? 15));
+
+    await p.goto(`https://www.xiaohongshu.com/user/profile/${userId}`);
+
+    let snapshot = await readUserSnapshot(p);
+    let results = extractXhsUserNotes(snapshot ?? {}, userId);
+    let previousCount = results.length;
+
+    for (let i = 0; results.length < limit && i < 4; i += 1) {
+      await p.autoScroll({ maxScrolls: 1, delay: 1500 });
+      await p.wait(1);
+
+      snapshot = await readUserSnapshot(p);
+      const nextResults = extractXhsUserNotes(snapshot ?? {}, userId);
+      if (nextResults.length <= previousCount) break;
+
+      results = nextResults;
+      previousCount = nextResults.length;
+    }
+
+    if (results.length === 0) {
+      throw new Error("No public notes found for this Xiaohongshu user.");
+    }
+
+    return results.slice(0, limit);
+  },
+});