@skills-store/rednote 0.1.0

package/scripts/index.ts

@@ -0,0 +1,54 @@
+#!/usr/bin/env -S node --experimental-strip-types
+
+import { runCli } from './utils/browser-cli.ts';
+
+function printRootHelp() {
+  process.stdout.write(`rednote
+
+Usage:
+  npx -y @skills-store/rednote browser <command> [...args]
+  npx -y @skills-store/rednote <command> [...args]
+
+Commands:
+  browser <list|create|remove|connect>
+  env [--format md|json]
+  status [--instance NAME]
+  check-login [--instance NAME]
+  login [--instance NAME]
+  home [--instance NAME] [--format md|json] [--save [PATH]]
+  search [--instance NAME] --keyword TEXT [--format md|json] [--save [PATH]]
+  get-feed-detail [--instance NAME] --url URL [--format md|json]
+  get-profile [--instance NAME] --id USER_ID [--format md|json]
+
+Examples:
+  npx -y @skills-store/rednote browser list
+  npx -y @skills-store/rednote browser create --name seller-main --browser chrome
+  npx -y @skills-store/rednote browser connect --instance seller-main
+  npx -y @skills-store/rednote env
+  npx -y @skills-store/rednote search --instance seller-main --keyword 护肤
+`);
+}
+
+export async function runRootCli(argv: string[] = process.argv.slice(2)) {
+  const [command, ...restArgv] = argv;
+
+  if (!command || command === 'help' || command === '--help' || command === '-h') {
+    printRootHelp();
+    return;
+  }
+
+  if (command === 'browser') {
+    const { runBrowserCli } = await import('./browser/index.ts');
+    await runBrowserCli(restArgv);
+    return;
+  }
+
+  const { runRednoteCli } = await import('./rednote/index.ts');
+  await runRednoteCli(argv);
+}
+
+async function main() {
+  await runRootCli();
+}
+
+runCli(import.meta.url, main);

package/scripts/rednote/checkLogin.ts

@@ -0,0 +1,171 @@
+#!/usr/bin/env -S node --experimental-strip-types
+
+import { parseArgs } from 'node:util';
+import type { Browser, BrowserContext, Page } from 'playwright-core';
+import { initBrowser, resolveConnectOptions } from '../browser/connect-browser.ts';
+import { connectOverCdp, updateLastConnect } from '../utils/browser-core.ts';
+import { debugLog, printJson, runCli } from '../utils/browser-cli.ts';
+import { resolveStatusTarget, type RednoteAccountStatus, type RednoteStatusTarget } from './status.ts';
+
+export type CheckLoginCliValues = {
+  instance?: string;
+  help?: boolean;
+};
+
+export type CheckLoginResult = {
+  ok: true;
+  rednote: RednoteAccountStatus & {
+    needLogin: boolean;
+    checkedAt: string;
+  };
+};
+
+export type RednoteSession = {
+  browser: Browser;
+  browserContext: BrowserContext;
+  page: Page;
+};
+
+function printCheckLoginHelp() {
+  process.stdout.write(`rednote check-login
+
+Usage:
+  npx -y @skills-store/rednote check-login [--instance NAME]
+  node --experimental-strip-types ./scripts/rednote/checkLogin.ts --instance NAME
+  bun ./scripts/rednote/checkLogin.ts --instance NAME
+
+Options:
+  --instance NAME   Optional. Defaults to the saved lastConnect instance
+  -h, --help        Show this help
+`);
+}
+
+export async function createRednoteSession(target: RednoteStatusTarget): Promise<RednoteSession> {
+  debugLog('checkLogin', 'create session start', { target });
+  const resolved = await resolveConnectOptions(
+    target.scope === 'custom'
+      ? { instanceName: target.instanceName }
+      : { browser: target.browser },
+  );
+  const launched = await initBrowser(resolved.connectOptions);
+  debugLog('checkLogin', 'initBrowser resolved', {
+    target,
+    connectOptions: resolved.connectOptions,
+    launched,
+  });
+
+  if (resolved.lastConnect) {
+    updateLastConnect(resolved.lastConnect);
+  }
+
+  const browser = await connectOverCdp(launched.wsUrl);
+  debugLog('checkLogin', 'connected over cdp', { wsUrl: launched.wsUrl, remoteDebuggingPort: launched.remoteDebuggingPort });
+  const browserContext = browser.contexts()[0];
+
+  if (!browserContext) {
+    throw new Error(`No browser context found for instance: ${target.instanceName}`);
+  }
+
+  const page = browserContext.pages().find((candidate) => candidate.url().startsWith('https://www.xiaohongshu.com/')) ?? await browserContext.newPage();
+  debugLog('checkLogin', 'session page resolved', { pageUrl: page.url(), totalPages: browserContext.pages().length });
+
+  return {
+    browser,
+    browserContext,
+    page,
+  };
+}
+
+export function disconnectRednoteSession(session: RednoteSession) {
+  try {
+    (session.browser as Browser & { _connection?: { close: () => void } })._connection?.close();
+  } catch {
+  }
+}
+
+export async function checkRednoteLogin(
+  target: RednoteStatusTarget,
+  session?: RednoteSession,
+): Promise<RednoteAccountStatus & {
+  needLogin: boolean;
+  checkedAt: string;
+}> {
+  const ownsSession = !session;
+  const activeSession = session ?? await createRednoteSession(target);
+
+  try {
+    debugLog('checkLogin', 'check login start', { target, reusedSession: Boolean(session) });
+    const page = activeSession.page;
+
+    if (!page.url().startsWith('https://www.xiaohongshu.com/')) {
+      debugLog('checkLogin', 'page is not on xiaohongshu, navigating', { currentUrl: page.url() });
+      await page.goto('https://www.xiaohongshu.com/explore', {
+        waitUntil: 'domcontentloaded',
+      });
+    }
+
+    await page.waitForTimeout(2_000);
+    const needLogin = (await page.locator('#login-btn').count()) > 0;
+    debugLog('checkLogin', 'login state checked', { pageUrl: page.url(), needLogin });
+
+    return {
+      loginStatus: needLogin ? 'logged-out' : 'logged-in',
+      lastLoginAt: null,
+      needLogin,
+      checkedAt: new Date().toISOString(),
+    };
+  } finally {
+    if (ownsSession) {
+      disconnectRednoteSession(activeSession);
+    }
+  }
+}
+
+export async function ensureRednoteLoggedIn(target: RednoteStatusTarget, action = 'continue', session?: RednoteSession) {
+  const rednote = await checkRednoteLogin(target, session);
+
+  if (rednote.needLogin) {
+    throw new Error(`Xiaohongshu login is required before ${action}. Run \`rednote login --instance ${target.instanceName}\` first.`);
+  }
+
+  return rednote;
+}
+
+export async function runCheckLoginCommand(values: CheckLoginCliValues = {}) {
+  if (values.help) {
+    printCheckLoginHelp();
+    return;
+  }
+
+
+  const target = resolveStatusTarget(values.instance);
+  const rednote = await checkRednoteLogin(target);
+
+  const result: CheckLoginResult = {
+    ok: true,
+    rednote,
+  };
+
+  printJson(result);
+}
+
+async function main() {
+  const { values } = parseArgs({
+    args: process.argv.slice(2),
+    allowPositionals: true,
+    strict: false,
+    options: {
+      instance: { type: 'string' },
+      help: { type: 'boolean', short: 'h' },
+    },
+  });
+
+  if (values.help) {
+    printCheckLoginHelp();
+    return;
+  }
+
+  await runCheckLoginCommand(values);
+}
+
+runCli(import.meta.url, main);

package/scripts/rednote/env.ts

@@ -0,0 +1,79 @@
+#!/usr/bin/env -S node --experimental-strip-types
+
+import { parseArgs } from 'node:util';
+import { printJson, runCli } from '../utils/browser-cli.ts';
+import { getRednoteEnvironmentInfo } from '../utils/browser-core.ts';
+
+export type EnvCliValues = {
+  format?: 'md' | 'json';
+  help?: boolean;
+};
+
+function printEnvHelp() {
+  process.stdout.write(`rednote env
+
+Usage:
+  npx -y @skills-store/rednote env [--format md|json]
+  node --experimental-strip-types ./scripts/rednote/env.ts [--format md|json]
+  bun ./scripts/rednote/env.ts [--format md|json]
+
+Options:
+  --format FORMAT   Output format: md | json. Default: md
+  -h, --help        Show this help
+`);
+}
+
+function renderEnvironmentMarkdown() {
+  const info = getRednoteEnvironmentInfo();
+  return [
+    '## Environment',
+    '',
+    `- Platform: ${info.platform}`,
+    `- Node: ${info.nodeVersion}`,
+    `- Home: ${info.homeDir}`,
+    `- Package Root: ${info.packageRoot}`,
+    `- Storage Home: ${info.storageHome}`,
+    `- Storage Root: ${info.storageRoot}`,
+    `- Instances Dir: ${info.instancesDir}`,
+    `- Instance Store: ${info.instanceStorePath}`,
+    `- Legacy Package Instances: ${info.legacyPackageInstancesDir}`,
+    '',
+    'Custom browser instances and metadata are stored under `~/.skills-router/rednote/instances`.',
+    '',
+  ].join('\n');
+}
+
+export async function runEnvCommand(values: EnvCliValues = {}) {
+  if (values.help) {
+    printEnvHelp();
+    return;
+  }
+
+  const format = values.format ?? 'md';
+  if (format === 'json') {
+    printJson(getRednoteEnvironmentInfo());
+    return;
+  }
+
+  process.stdout.write(renderEnvironmentMarkdown());
+}
+
+async function main() {
+  const { values } = parseArgs({
+    args: process.argv.slice(2),
+    allowPositionals: true,
+    strict: false,
+    options: {
+      format: { type: 'string' },
+      help: { type: 'boolean', short: 'h' },
+    },
+  });
+
+  if (values.format && values.format !== 'md' && values.format !== 'json') {
+    throw new Error(`Invalid --format value: ${String(values.format)}`);
+  }
+
+  await runEnvCommand(values as EnvCliValues);
+}
+
+runCli(import.meta.url, main);

package/scripts/rednote/getFeedDetail.ts

@@ -0,0 +1,351 @@
+#!/usr/bin/env -S node --experimental-strip-types
+
+import * as cheerio from 'cheerio';
+import { parseArgs } from 'node:util';
+import vm from 'node:vm';
+import type { Page, Response } from 'playwright-core';
+import { printJson, runCli } from '../utils/browser-cli.ts';
+import { resolveStatusTarget } from './status.ts';
+import { createRednoteSession, disconnectRednoteSession, ensureRednoteLoggedIn, type RednoteSession } from './checkLogin.ts';
+
+export type FeedDetailFormat = 'json' | 'md';
+
+export type FeedDetailCliValues = {
+  instance?: string;
+  urls: string[];
+  format: FeedDetailFormat;
+  help?: boolean;
+};
+
+export type RednoteComment = {
+  id: string | null;
+  content: string | null;
+  userId: string | null;
+  nickname: string | null;
+  likedCount: string | null;
+  subCommentCount: number | null;
+  raw: unknown;
+};
+
+export type RednoteDetailNote = {
+  noteId: string | null;
+  title: string | null;
+  desc: string | null;
+  type: string | null;
+  interactInfo: {
+    likedCount: string | null;
+    commentCount: string | null;
+    collectedCount: string | null;
+    shareCount: string | null;
+  };
+  tagList: Array<{
+    name: string | null;
+  }>;
+  imageList: Array<{
+    urlDefault: string | null;
+    urlPre: string | null;
+    width: number | null;
+    height: number | null;
+  }>;
+  video: {
+    url: string | null;
+    raw: unknown;
+  } | null;
+  raw: unknown;
+};
+
+export type RednoteFeedDetailItem = {
+  url: string;
+  note: RednoteDetailNote;
+  comments: RednoteComment[];
+};
+
+export type FeedDetailResult = {
+  ok: true;
+  detail: {
+    fetchedAt: string;
+    total: number;
+    items: RednoteFeedDetailItem[];
+  };
+};
+
+function printGetFeedDetailHelp() {
+  process.stdout.write(`rednote get-feed-detail
+
+Usage:
+  npx -y @skills-store/rednote get-feed-detail [--instance NAME] --url URL [--url URL] [--format md|json]
+  node --experimental-strip-types ./scripts/rednote/getFeedDetail.ts --instance NAME --url URL [--url URL] [--format md|json]
+  bun ./scripts/rednote/getFeedDetail.ts --instance NAME --url URL [--url URL] [--format md|json]
+
+Options:
+  --instance NAME   Optional. Defaults to the saved lastConnect instance
+  --url URL         Required. Xiaohongshu explore url, repeatable
+  --format FORMAT   Output format: md | json. Default: md
+  -h, --help        Show this help
+`);
+}
+
+export function parseGetFeedDetailCliArgs(argv: string[]): FeedDetailCliValues {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    strict: false,
+    options: {
+      instance: { type: 'string' },
+      url: { type: 'string', multiple: true },
+      format: { type: 'string' },
+      help: { type: 'boolean', short: 'h' },
+    },
+  });
+
+  if (positionals.length > 0) {
+    throw new Error(`Unexpected positional arguments: ${positionals.join(' ')}`);
+  }
+
+  const format = values.format ?? 'md';
+  if (format !== 'md' && format !== 'json') {
+    throw new Error(`Invalid --format value: ${String(format)}`);
+  }
+
+  return {
+    instance: values.instance,
+    urls: values.url ?? [],
+    format,
+    help: values.help,
+  };
+}
+
+function validateFeedDetailUrl(url: string) {
+  try {
+    const parsed = new URL(url);
+    if (!parsed.href.startsWith('https://www.xiaohongshu.com/explore/')) {
+      throw new Error(`url is not valid: ${url},must start with "https://www.xiaohongshu.com/explore/"`);
+    }
+    if (!parsed.searchParams.get('xsec_token')) {
+      throw new Error(`url is not valid: ${url},must include "xsec_token="`);
+    }
+  } catch (error) {
+    if (error instanceof TypeError) {
+      throw new Error(`url is not valid: ${url}`);
+    }
+    throw error;
+  }
+}
+
+async function getOrCreateXiaohongshuPage(session: RednoteSession) {
+  return session.page;
+}
+
+function extractVideoUrl(note: any) {
+  const streams = Object.values(note?.video?.media?.stream ?? {}) as any[];
+  const firstAvailable = streams.find((items) => Array.isArray(items) && items.length > 0);
+  return firstAvailable?.[0]?.backupUrls?.[0] ?? null;
+}
+
+function normalizeDetailNote(note: any): RednoteDetailNote {
+  return {
+    noteId: note?.noteId ?? null,
+    title: note?.title ?? null,
+    desc: note?.desc ?? null,
+    type: note?.type ?? null,
+    interactInfo: {
+      likedCount: note?.interactInfo?.likedCount ?? null,
+      commentCount: note?.interactInfo?.commentCount ?? null,
+      collectedCount: note?.interactInfo?.collectedCount ?? null,
+      shareCount: note?.interactInfo?.shareCount ?? null,
+    },
+    tagList: Array.isArray(note?.tagList)
+      ? note.tagList.map((tag: any) => ({ name: tag?.name ?? null }))
+      : [],
+    imageList: Array.isArray(note?.imageList)
+      ? note.imageList.map((image: any) => ({
+          urlDefault: image?.urlDefault ?? null,
+          urlPre: image?.urlPre ?? null,
+          width: image?.width ?? null,
+          height: image?.height ?? null,
+        }))
+      : [],
+    video: note?.video
+      ? {
+          url: extractVideoUrl(note),
+          raw: note.video,
+        }
+      : null,
+    raw: note,
+  };
+}
+
+function normalizeComments(comments: any[]): RednoteComment[] {
+  return comments.map((comment) => ({
+    id: comment?.id ?? comment?.commentId ?? null,
+    content: comment?.content ?? null,
+    userId: comment?.userInfo?.userId ?? null,
+    nickname: comment?.userInfo?.nickname ?? null,
+    likedCount: comment?.interactInfo?.likedCount ?? null,
+    subCommentCount: typeof comment?.subCommentCount === 'number' ? comment.subCommentCount : null,
+    raw: comment,
+  }));
+}
+
+function renderDetailMarkdown(items: RednoteFeedDetailItem[]) {
+  if (items.length === 0) {
+    return '没有获取到帖子详情。\n';
+  }
+
+  return `${items.map((item) => {
+    const lines: string[] = ['<note>'];
+    lines.push(`### Url: ${item.url}`);
+    lines.push(`### 标题:${item.note.title ?? ''}`);
+    lines.push(`### 内容\n${item.note.desc ?? ''}`);
+
+    if (item.note.interactInfo.likedCount) {
+      lines.push(`### 点赞: ${item.note.interactInfo.likedCount}`);
+    }
+    if (item.note.interactInfo.commentCount) {
+      lines.push(`### 评论: ${item.note.interactInfo.commentCount}`);
+    }
+    if (item.note.interactInfo.collectedCount) {
+      lines.push(`### 收藏: ${item.note.interactInfo.collectedCount}`);
+    }
+    if (item.note.interactInfo.shareCount) {
+      lines.push(`### 分享: ${item.note.interactInfo.shareCount}`);
+    }
+    if (item.note.tagList.length > 0) {
+      lines.push(`### 标签: ${item.note.tagList.map((tag) => tag.name ? `#${tag.name}` : '').filter(Boolean).join(' ')}`);
+    }
+    if (item.note.imageList.length > 0) {
+      lines.push(`### 图片\n${item.note.imageList.map((image) => image.urlDefault ? `![](${image.urlDefault})` : '').filter(Boolean).join('\n')}`);
+    }
+    if (item.note.video?.url) {
+      lines.push(`### 视频\n[](${item.note.video.url})`);
+    }
+    if (item.comments.length > 0) {
+      lines.push('### 评论:');
+      for (const comment of item.comments) {
+        lines.push(`- ${comment.content ?? ''}`);
+      }
+    }
+
+    lines.push('</note>');
+    return lines.join('\n');
+  }).join('\n\n---\n\n')}\n`;
+}
+
+async function captureFeedDetail(page: Page, targetUrl: string): Promise<RednoteFeedDetailItem> {
+  let note: any = null;
+  let comments: any[] | null = null;
+
+  const handleResponse = async (response: Response) => {
+    try {
+      const url = new URL(response.url());
+      if (response.status() !== 200) {
+        return;
+      }
+
+      if (url.href.includes('/explore/')) {
+        const html = await response.text();
+        const $ = cheerio.load(html);
+
+        $('script').each((_, element) => {
+          const scriptContent = $(element).html();
+          if (!scriptContent?.includes('window.__INITIAL_STATE__')) {
+            return;
+          }
+
+          const scriptText = scriptContent.substring(scriptContent.indexOf('=') + 1);
+          const sandbox: { info?: any } = {};
+          vm.createContext(sandbox);
+          vm.runInContext(`var info = ${scriptText}`, sandbox);
+          const noteState = sandbox.info?.note;
+          if (noteState?.noteDetailMap && noteState?.currentNoteId) {
+            note = noteState.noteDetailMap[noteState.currentNoteId]?.note ?? note;
+          }
+        });
+      } else if (url.href.includes('comment/page?')) {
+        const data = await response.json() as { data?: { comments?: any[] } };
+        comments = Array.isArray(data?.data?.comments) ? data.data.comments : [];
+      }
+    } catch {
+    }
+  };
+
+  page.on('response', handleResponse);
+  try {
+    await page.goto(targetUrl, { waitUntil: 'domcontentloaded' });
+
+    const deadline = Date.now() + 15_000;
+    while (Date.now() < deadline) {
+      if (note && comments !== null) {
+        break;
+      }
+      await page.waitForTimeout(200);
+    }
+
+    if (!note) {
+      throw new Error(`Failed to capture note detail: ${targetUrl}`);
+    }
+
+    return {
+      url: targetUrl,
+      note: normalizeDetailNote(note),
+      comments: normalizeComments(comments ?? []),
+    };
+  } finally {
+    page.off('response', handleResponse);
+  }
+}
+
+export async function getFeedDetails(session: RednoteSession, urls: string[]): Promise<FeedDetailResult> {
+  const page = await getOrCreateXiaohongshuPage(session);
+  const items: RednoteFeedDetailItem[] = [];
+  for (const url of urls) {
+    validateFeedDetailUrl(url);
+    items.push(await captureFeedDetail(page, url));
+  }
+
+  return {
+    ok: true,
+    detail: {
+      fetchedAt: new Date().toISOString(),
+      total: items.length,
+      items,
+    },
+  };
+}
+
+function writeFeedDetailOutput(result: FeedDetailResult, format: FeedDetailFormat) {
+  if (format === 'json') {
+    printJson(result);
+    return;
+  }
+
+  process.stdout.write(renderDetailMarkdown(result.detail.items));
+}
+
+export async function runGetFeedDetailCommand(values: FeedDetailCliValues = { urls: [], format: 'md' }) {
+  if (values.help) {
+    printGetFeedDetailHelp();
+    return;
+  }
+  if (values.urls.length === 0) {
+    throw new Error('Missing required option: --url');
+  }
+
+  const target = resolveStatusTarget(values.instance);
+  const session = await createRednoteSession(target);
+
+  try {
+    await ensureRednoteLoggedIn(target, 'fetching feed detail', session);
+    const result = await getFeedDetails(session, values.urls);
+    writeFeedDetailOutput(result, values.format);
+  } finally {
+    disconnectRednoteSession(session);
+  }
+}
+
+async function main() {
+  const values = parseGetFeedDetailCliArgs(process.argv.slice(2));
+  await runGetFeedDetailCommand(values);
+}
+
+runCli(import.meta.url, main);