@jackwener/opencli 1.3.3 → 1.4.1

package/src/clis/weibo/comments.ts

@@ -0,0 +1,54 @@
+/**
+ * Weibo comments — get comments on a post.
+ */
+import { cli, Strategy } from '../../registry.js';
+
+cli({
+  site: 'weibo',
+  name: 'comments',
+  description: 'Get comments on a Weibo post',
+  domain: 'weibo.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'id', required: true, positional: true, help: 'Post ID (numeric idstr)' },
+    { name: 'limit', type: 'int', default: 20, help: 'Number of comments (max 50)' },
+  ],
+  columns: ['rank', 'author', 'text', 'likes', 'replies', 'time'],
+  func: async (page, kwargs) => {
+    const count = Math.min(kwargs.limit || 20, 50);
+    await page.goto('https://weibo.com');
+    await page.wait(2);
+
+    const id = String(kwargs.id);
+    const data = await page.evaluate(`
+      (async () => {
+        const id = ${JSON.stringify(id)};
+        const count = ${count};
+        const strip = (html) => (html || '').replace(/<[^>]+>/g, '').replace(/&nbsp;/g, ' ').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&').trim();
+
+        const url = '/ajax/statuses/buildComments?flow=0&is_reload=1&id=' + id + '&is_show_bulletin=2&is_mix=0&count=' + count;
+        const resp = await fetch(url, {credentials: 'include'});
+        if (!resp.ok) return {error: 'HTTP ' + resp.status};
+        const data = await resp.json();
+        if (!data.ok) return {error: 'API error: ' + (data.msg || 'unknown')};
+
+        return (data.data || []).map((c, i) => {
+          const item = {
+            rank: i + 1,
+            author: c.user?.screen_name || '',
+            text: strip(c.text || ''),
+            likes: c.like_count || 0,
+            replies: c.total_number || 0,
+            time: c.created_at || '',
+          };
+          if (c.reply_comment) {
+            item.reply_to = (c.reply_comment.user?.screen_name || '') + ': ' + strip(c.reply_comment.text || '').substring(0, 80);
+          }
+          return item;
+        });
+      })()
+    `);
+    if (!Array.isArray(data)) return [];
+    return data;
+  },
+});

package/src/clis/weibo/feed.ts

@@ -0,0 +1,57 @@
+/**
+ * Weibo feed — home timeline from followed users.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { getSelfUid } from './utils.js';
+
+cli({
+  site: 'weibo',
+  name: 'feed',
+  description: 'Weibo home timeline (posts from followed users)',
+  domain: 'weibo.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'limit', type: 'int', default: 15, help: 'Number of posts (max 50)' },
+  ],
+  columns: ['author', 'text', 'reposts', 'comments', 'likes', 'time', 'url'],
+  func: async (page, kwargs) => {
+    const count = Math.min(kwargs.limit || 15, 50);
+    await page.goto('https://weibo.com');
+    await page.wait(2);
+    const uid = await getSelfUid(page);
+
+    const data = await page.evaluate(`
+      (async () => {
+        const uid = ${JSON.stringify(uid)};
+        const count = ${count};
+        const listId = '10001' + uid;
+        const strip = (html) => (html || '').replace(/<[^>]+>/g, '').replace(/&nbsp;/g, ' ').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&').trim();
+
+        const resp = await fetch('/ajax/feed/unreadfriendstimeline?list_id=' + listId + '&refresh=4&since_id=0&count=' + count, {credentials: 'include'});
+        if (!resp.ok) return {error: 'HTTP ' + resp.status};
+        const data = await resp.json();
+        if (!data.ok) return {error: 'API error: ' + (data.msg || 'unknown')};
+
+        return (data.statuses || []).slice(0, count).map(s => {
+          const u = s.user || {};
+          const item = {
+            author: u.screen_name || '',
+            text: (s.text_raw || strip(s.text || '')).substring(0, 200),
+            reposts: s.reposts_count || 0,
+            comments: s.comments_count || 0,
+            likes: s.attitudes_count || 0,
+            time: s.created_at || '',
+            url: 'https://weibo.com/' + (u.id || '') + '/' + (s.mblogid || ''),
+          };
+          if (s.retweeted_status) {
+            const rt = s.retweeted_status;
+            item.retweeted = (rt.user?.screen_name || '[deleted]') + ': ' + (rt.text_raw || strip(rt.text || '')).substring(0, 100);
+          }
+          return item;
+        });
+      })()
+    `);
+    if (!Array.isArray(data)) return [];
+    return data;
+  },
+});

package/src/clis/weibo/hot.ts

@@ -1,6 +1,5 @@
 /**
  * Weibo hot search — browser cookie API.
- * Source: bb-sites/weibo/hot.js
  */
 import { cli, Strategy } from '../../registry.js';
 

package/src/clis/weibo/me.ts

@@ -0,0 +1,77 @@
+/**
+ * Weibo me — current logged-in user profile.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CommandExecutionError } from '../../errors.js';
+import { getSelfUid } from './utils.js';
+
+cli({
+  site: 'weibo',
+  name: 'me',
+  description: 'My Weibo profile info',
+  domain: 'weibo.com',
+  strategy: Strategy.COOKIE,
+  args: [],
+  columns: ['screen_name', 'uid', 'followers', 'following', 'statuses', 'verified', 'location'],
+  func: async (page) => {
+    await page.goto('https://weibo.com');
+    await page.wait(2);
+    const uid = await getSelfUid(page);
+
+    const data = await page.evaluate(`
+      (async () => {
+        const uid = ${JSON.stringify(uid)};
+
+        // Try Vue store first
+        const app = document.querySelector('#app')?.__vue_app__;
+        const store = app?.config?.globalProperties?.$store;
+        const cfg = store?.state?.config?.config;
+        const u = cfg?.user;
+
+        // Fetch detail info
+        const detailResp = await fetch('/ajax/profile/detail?uid=' + uid, {credentials: 'include'});
+        const detail = detailResp.ok ? await detailResp.json() : null;
+        const d = detail?.data || {};
+
+        if (u && u.id) {
+          return {
+            screen_name: u.screen_name,
+            uid: u.id,
+            followers: u.followers_count,
+            following: u.friends_count,
+            statuses: u.statuses_count,
+            verified: u.verified || false,
+            location: u.location || '',
+            description: u.description || d.description || '',
+            avatar: u.avatar_hd || u.avatar_large || '',
+            profile_url: 'https://weibo.com' + (u.profile_url || '/u/' + u.id),
+          };
+        }
+
+        // Fallback: fetch profile API
+        const resp = await fetch('/ajax/profile/info?uid=' + uid, {credentials: 'include'});
+        if (!resp.ok) return {error: 'HTTP ' + resp.status};
+        const info = await resp.json();
+        if (!info.ok) return {error: 'API error'};
+        const p = info.data?.user;
+        if (!p) return {error: 'User data not found'};
+        return {
+          screen_name: p.screen_name,
+          uid: p.id,
+          followers: p.followers_count,
+          following: p.friends_count,
+          statuses: p.statuses_count,
+          verified: p.verified || false,
+          location: p.location || '',
+          description: p.description || d.description || '',
+          avatar: p.avatar_hd || p.avatar_large || '',
+          profile_url: 'https://weibo.com' + (p.profile_url || '/u/' + p.id),
+        };
+      })()
+    `);
+
+    if (!data || typeof data !== 'object') throw new CommandExecutionError('Failed to fetch profile');
+    if ((data as Record<string, unknown>).error) throw new CommandExecutionError(String((data as Record<string, unknown>).error));
+    return data as Record<string, unknown>;
+  },
+});

package/src/clis/weibo/post.ts

@@ -0,0 +1,77 @@
+/**
+ * Weibo post — get a single post by ID.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CommandExecutionError } from '../../errors.js';
+
+cli({
+  site: 'weibo',
+  name: 'post',
+  description: 'Get a single Weibo post',
+  domain: 'weibo.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'id', required: true, positional: true, help: 'Post ID (numeric idstr or mblogid from URL)' },
+  ],
+  columns: ['field', 'value'],
+  func: async (page, kwargs) => {
+    await page.goto('https://weibo.com');
+    await page.wait(2);
+
+    const id = String(kwargs.id);
+    const data = await page.evaluate(`
+      (async () => {
+        const id = ${JSON.stringify(id)};
+        const strip = (html) => (html || '').replace(/<[^>]+>/g, '').replace(/&nbsp;/g, ' ').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&').trim();
+
+        const resp = await fetch('/ajax/statuses/show?id=' + encodeURIComponent(id), {credentials: 'include'});
+        if (!resp.ok) return {error: 'HTTP ' + resp.status};
+        const s = await resp.json();
+        if (!s.ok && !s.idstr) return {error: 'Post not found'};
+
+        // Fetch long text if needed
+        let fullText = s.text_raw || strip(s.text || '');
+        if (s.isLongText || s.is_long_text) {
+          try {
+            const ltResp = await fetch('/ajax/statuses/longtext?id=' + s.idstr, {credentials: 'include'});
+            if (ltResp.ok) {
+              const lt = await ltResp.json();
+              if (lt.data?.longTextContent) fullText = strip(lt.data.longTextContent);
+            }
+          } catch {}
+        }
+
+        const u = s.user || {};
+        const result = {
+          id: s.idstr || String(s.id),
+          mblogid: s.mblogid,
+          author: u.screen_name || '',
+          text: fullText,
+          created_at: s.created_at,
+          source: strip(s.source || ''),
+          reposts: s.reposts_count || 0,
+          comments: s.comments_count || 0,
+          likes: s.attitudes_count || 0,
+          pic_count: s.pic_num || 0,
+          url: 'https://weibo.com/' + (u.id || '') + '/' + (s.mblogid || ''),
+        };
+
+        if (s.retweeted_status) {
+          const rt = s.retweeted_status;
+          result.retweeted_from = (rt.user?.screen_name || '[deleted]');
+          result.retweeted_text = rt.text_raw || strip(rt.text || '');
+        }
+
+        return result;
+      })()
+    `);
+
+    if (!data || typeof data !== 'object') throw new CommandExecutionError('Failed to fetch post');
+    if ((data as Record<string, unknown>).error) throw new CommandExecutionError(String((data as Record<string, unknown>).error));
+
+    return Object.entries(data as Record<string, unknown>).map(([field, value]) => ({
+      field,
+      value: String(value),
+    }));
+  },
+});

package/src/clis/weibo/user.ts

@@ -0,0 +1,64 @@
+/**
+ * Weibo user — get user profile by uid or screen_name.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CommandExecutionError } from '../../errors.js';
+
+cli({
+  site: 'weibo',
+  name: 'user',
+  description: 'Get Weibo user profile',
+  domain: 'weibo.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'id', required: true, positional: true, help: 'User ID (numeric uid) or screen name' },
+  ],
+  columns: ['screen_name', 'uid', 'followers', 'following', 'statuses', 'verified', 'description', 'location', 'url'],
+  func: async (page, kwargs) => {
+    await page.goto('https://weibo.com');
+    await page.wait(2);
+
+    const id = String(kwargs.id);
+    const data = await page.evaluate(`
+      (async () => {
+        const id = ${JSON.stringify(id)};
+        const isUid = /^\\d+$/.test(id);
+        const query = isUid ? 'uid=' + id : 'screen_name=' + encodeURIComponent(id);
+
+        const resp = await fetch('/ajax/profile/info?' + query, {credentials: 'include'});
+        if (!resp.ok) return {error: 'HTTP ' + resp.status};
+        const data = await resp.json();
+        if (!data.ok || !data.data?.user) return {error: 'User not found'};
+
+        const u = data.data.user;
+
+        // Fetch detail info
+        const detailResp = await fetch('/ajax/profile/detail?uid=' + u.id, {credentials: 'include'});
+        const detail = detailResp.ok ? await detailResp.json() : null;
+        const d = detail?.data || {};
+
+        return {
+          screen_name: u.screen_name,
+          uid: u.id,
+          followers: u.followers_count,
+          following: u.friends_count,
+          statuses: u.statuses_count,
+          verified: u.verified || false,
+          verified_reason: u.verified_reason || '',
+          description: u.description || d.description || '',
+          location: u.location || '',
+          gender: u.gender === 'm' ? 'male' : u.gender === 'f' ? 'female' : '',
+          avatar: u.avatar_hd || u.avatar_large || '',
+          url: 'https://weibo.com' + (u.profile_url || '/u/' + u.id),
+          birthday: d.birthday || '',
+          created_at: d.created_at || '',
+          ip_location: d.ip_location || '',
+        };
+      })()
+    `);
+
+    if (!data || typeof data !== 'object') throw new CommandExecutionError('Failed to fetch user profile');
+    if ((data as Record<string, unknown>).error) throw new CommandExecutionError(String((data as Record<string, unknown>).error));
+    return data as Record<string, unknown>;
+  },
+});

package/src/clis/weibo/utils.ts

@@ -0,0 +1,32 @@
+/**
+ * Shared Weibo utilities — uid extraction.
+ */
+
+import type { IPage } from '../../types.js';
+import { AuthRequiredError } from '../../errors.js';
+
+/** Get the currently logged-in user's uid from Vue store or config API. */
+export async function getSelfUid(page: IPage): Promise<string> {
+  const uid = await page.evaluate(`
+    (() => {
+      const app = document.querySelector('#app')?.__vue_app__;
+      const store = app?.config?.globalProperties?.$store;
+      const uid = store?.state?.config?.config?.uid;
+      if (uid) return String(uid);
+      return null;
+    })()
+  `);
+  if (uid) return uid as string;
+
+  // Fallback: config API
+  const config = await page.evaluate(`
+    (async () => {
+      const resp = await fetch('/ajax/config/get_config', {credentials: 'include'});
+      if (!resp.ok) return null;
+      const data = await resp.json();
+      return data.ok && data.data?.uid ? String(data.data.uid) : null;
+    })()
+  `);
+  if (config) return config as string;
+  throw new AuthRequiredError('weibo.com');
+}

package/src/clis/weread/search.ts

@@ -12,15 +12,16 @@ cli({
     { name: 'query', positional: true, required: true, help: 'Search keyword' },
     { name: 'limit', type: 'int', default: 10, help: 'Max results' },
   ],
-  columns: ['rank', 'title', 'author', 'bookId'],
+  columns: ['rank', 'title', 'author', 'bookId', 'url'],
   func: async (_page, args) => {
-    const data = await fetchWebApi('/search/global', { keyword: args.keyword });
+    const data = await fetchWebApi('/search/global', { keyword: args.query });
     const books: any[] = data?.books ?? [];
     return books.slice(0, Number(args.limit)).map((item: any, i: number) => ({
       rank: i + 1,
       title: item.bookInfo?.title ?? '',
       author: item.bookInfo?.author ?? '',
       bookId: item.bookInfo?.bookId ?? '',
+      url: item.bookInfo?.bookId ? 'https://weread.qq.com/web/bookDetail/' + item.bookInfo.bookId : '',
     }));
   },
 });

package/src/clis/xueqiu/danjuan-utils.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it, vi } from 'vitest';
+import { fetchDanjuanAll } from './danjuan-utils.js';
+
+describe('fetchDanjuanAll', () => {
+  it('throws when no Danjuan accounts are visible', async () => {
+    const mockPage = {
+      evaluate: vi.fn().mockResolvedValue({ _emptyAccounts: true }),
+    } as any;
+
+    await expect(fetchDanjuanAll(mockPage)).rejects.toThrow('No fund accounts found');
+  });
+
+  it('throws when any account detail request fails', async () => {
+    const mockPage = {
+      evaluate: vi.fn().mockResolvedValue({
+        detailErrors: [
+          { accountName: '默认账户', accountId: 'acc-1', error: 403 },
+        ],
+      }),
+    } as any;
+
+    await expect(fetchDanjuanAll(mockPage)).rejects.toThrow(
+      'Failed to fetch Danjuan account details: 默认账户 (acc-1): 403',
+    );
+  });
+
+  it('returns the combined snapshot when all account details succeed', async () => {
+    const snapshot = {
+      asOf: '2026-03-25',
+      totalAssetAmount: 100,
+      totalAssetDailyGain: 1,
+      totalAssetHoldGain: 2,
+      totalAssetTotalGain: 3,
+      totalFundMarketValue: 80,
+      accounts: [{ accountId: 'acc-1', accountName: '默认账户' }],
+      holdings: [{ accountId: 'acc-1', fdCode: '000001', fdName: '示例基金' }],
+      detailErrors: [],
+    };
+    const mockPage = {
+      evaluate: vi.fn().mockResolvedValue(snapshot),
+    } as any;
+
+    await expect(fetchDanjuanAll(mockPage)).resolves.toMatchObject({
+      asOf: '2026-03-25',
+      accounts: [{ accountId: 'acc-1', accountName: '默认账户' }],
+      holdings: [{ accountId: 'acc-1', fdCode: '000001', fdName: '示例基金' }],
+    });
+  });
+});

package/src/clis/xueqiu/danjuan-utils.ts

@@ -0,0 +1,176 @@
+/**
+ * Shared helpers for Danjuan (蛋卷基金) adapters.
+ *
+ * Core design: a single page.evaluate call fetches the gain overview AND
+ * all per-account holdings in parallel (Promise.all), minimising Node↔Browser
+ * round-trips to exactly one.
+ */
+
+import type { IPage } from '../../types.js';
+
+export const DANJUAN_DOMAIN = 'danjuanfunds.com';
+export const DANJUAN_ASSET_PAGE = `https://${DANJUAN_DOMAIN}/my-money`;
+
+const GAIN_URL = `https://${DANJUAN_DOMAIN}/djapi/fundx/profit/assets/gain?gains=%5B%22private%22%5D`;
+const SUMMARY_URL = `https://${DANJUAN_DOMAIN}/djapi/fundx/profit/assets/summary?invest_account_id=`;
+
+// ---------------------------------------------------------------------------
+// Types — keep everything explicit so TS consumers get autocomplete.
+// ---------------------------------------------------------------------------
+
+export interface DanjuanAccount {
+  accountId: string;
+  accountName: string;
+  accountType: string;
+  accountCode: string;
+  marketValue: number | null;
+  dailyGain: number | null;
+  mainFlag: boolean;
+}
+
+export interface DanjuanHolding {
+  accountId: string;
+  accountName: string;
+  accountType: string;
+  fdCode: string;
+  fdName: string;
+  category: string;
+  marketValue: number | null;
+  volume: number | null;
+  usableRemainShare: number | null;
+  dailyGain: number | null;
+  holdGain: number | null;
+  holdGainRate: number | null;
+  totalGain: number | null;
+  nav: number | null;
+  marketPercent: number | null;
+}
+
+export interface DanjuanSnapshot {
+  asOf: string | null;
+  totalAssetAmount: number | null;
+  totalAssetDailyGain: number | null;
+  totalAssetHoldGain: number | null;
+  totalAssetTotalGain: number | null;
+  totalFundMarketValue: number | null;
+  accounts: DanjuanAccount[];
+  holdings: DanjuanHolding[];
+}
+
+// ---------------------------------------------------------------------------
+// Single-evaluate fetcher
+// ---------------------------------------------------------------------------
+
+/**
+ * Fetch the complete Danjuan fund picture in ONE browser round-trip.
+ *
+ * Inside the browser context we:
+ *   1. Fetch the gain/assets overview (contains account list)
+ *   2. Promise.all → fetch every account's holdings in parallel
+ *   3. Return the combined result to Node
+ */
+export async function fetchDanjuanAll(page: IPage): Promise<DanjuanSnapshot> {
+  const raw: any = await page.evaluate(`
+    (async () => {
+      const f = async (u) => {
+        const r = await fetch(u, { credentials: 'include' });
+        if (!r.ok) return { _err: r.status };
+        try { return await r.json(); } catch { return { _err: 'parse' }; }
+      };
+      const n = (v) => { const x = Number(v); return Number.isFinite(x) ? x : null; };
+
+      const gain = await f(${JSON.stringify(GAIN_URL)});
+      if (gain._err) return { _httpError: gain._err };
+
+      const root = gain.data || {};
+      const fundSec = (root.items || []).find(i => i && i.summary_type === 'FUND');
+      const rawAccs = fundSec && Array.isArray(fundSec.invest_account_list)
+        ? fundSec.invest_account_list : [];
+
+      const accounts = rawAccs.map(a => ({
+        accountId:   String(a.invest_account_id || ''),
+        accountName: a.invest_account_name || '',
+        accountType: a.invest_account_type || '',
+        accountCode: a.invest_account_code || '',
+        marketValue: n(a.market_value),
+        dailyGain:   n(a.daily_gain),
+        mainFlag:    !!a.main_flag,
+      }));
+
+      if (!accounts.length) {
+        return { _emptyAccounts: true };
+      }
+
+      const details = await Promise.all(
+        accounts.map(a => f(${JSON.stringify(SUMMARY_URL)} + encodeURIComponent(a.accountId)))
+      );
+
+      const holdings = [];
+      const detailErrors = [];
+      for (let i = 0; i < accounts.length; i++) {
+        const d = details[i];
+        if (d._err) {
+          detailErrors.push({
+            accountId: accounts[i].accountId,
+            accountName: accounts[i].accountName,
+            error: d._err,
+          });
+          continue;
+        }
+        const data = d.data || {};
+        const funds = Array.isArray(data.items) ? data.items : [];
+        const acc = accounts[i];
+        for (const fd of funds) {
+          holdings.push({
+            accountId:        acc.accountId,
+            accountName:      data.invest_account_name || acc.accountName,
+            accountType:      data.invest_account_type || acc.accountType,
+            fdCode:           fd.fd_code || '',
+            fdName:           fd.fd_name || '',
+            category:         fd.category_text || fd.category || '',
+            marketValue:      n(fd.market_value),
+            volume:           n(fd.volume),
+            usableRemainShare:n(fd.usable_remain_share),
+            dailyGain:        n(fd.daily_gain),
+            holdGain:         n(fd.hold_gain),
+            holdGainRate:     n(fd.hold_gain_rate),
+            totalGain:        n(fd.total_gain),
+            nav:              n(fd.nav),
+            marketPercent:    n(fd.market_percent),
+          });
+        }
+      }
+
+      return {
+        asOf:                root.daily_gain_date || null,
+        totalAssetAmount:    n(root.amount),
+        totalAssetDailyGain: n(root.daily_gain),
+        totalAssetHoldGain:  n(root.hold_gain),
+        totalAssetTotalGain: n(root.total_gain),
+        totalFundMarketValue:n(fundSec && fundSec.amount),
+        accounts,
+        holdings,
+        detailErrors,
+      };
+    })()
+  `);
+
+  if (raw?._httpError) {
+    throw new Error(`HTTP ${raw._httpError} — Hint: not logged in to ${DANJUAN_DOMAIN}?`);
+  }
+  if (raw?._emptyAccounts) {
+    throw new Error(`No fund accounts found — Hint: not logged in to ${DANJUAN_DOMAIN}?`);
+  }
+  if (Array.isArray(raw?.detailErrors) && raw.detailErrors.length > 0) {
+    const failedAccounts = raw.detailErrors
+      .map((item: { accountName?: string; accountId?: string; error?: string | number }) => {
+        const label = item.accountName && item.accountId
+          ? `${item.accountName} (${item.accountId})`
+          : item.accountName || item.accountId || 'unknown account';
+        return `${label}: ${item.error}`;
+      })
+      .join(', ');
+    throw new Error(`Failed to fetch Danjuan account details: ${failedAccounts}`);
+  }
+  return raw as DanjuanSnapshot;
+}

package/src/clis/xueqiu/fund-holdings.ts

@@ -0,0 +1,32 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+import { fetchDanjuanAll } from './danjuan-utils.js';
+
+cli({
+  site: 'xueqiu',
+  name: 'fund-holdings',
+  description: '获取蛋卷基金持仓明细（可用 --account 按子账户过滤）',
+  domain: 'danjuanfunds.com',
+  strategy: Strategy.COOKIE,
+  navigateBefore: 'https://danjuanfunds.com/my-money',
+  args: [
+    { name: 'account', type: 'str', default: '', help: '按子账户名称或 ID 过滤' },
+  ],
+  columns: ['accountName', 'fdCode', 'fdName', 'marketValue', 'volume', 'dailyGain', 'holdGain', 'holdGainRate', 'marketPercent'],
+  func: async (page: IPage, args) => {
+    const snapshot = await fetchDanjuanAll(page);
+    if (!snapshot.accounts.length) {
+      throw new Error('No fund accounts found — Hint: not logged in to danjuanfunds.com?');
+    }
+
+    const filter = String(args.account ?? '').trim();
+    const rows = filter
+      ? snapshot.holdings.filter(h => h.accountId === filter || h.accountName.includes(filter))
+      : snapshot.holdings;
+
+    if (!rows.length) {
+      throw new Error(filter ? `No holdings matched account filter: ${filter}` : 'No holdings found.');
+    }
+    return rows;
+  },
+});

package/src/clis/xueqiu/fund-snapshot.ts

@@ -0,0 +1,27 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+import { fetchDanjuanAll } from './danjuan-utils.js';
+
+cli({
+  site: 'xueqiu',
+  name: 'fund-snapshot',
+  description: '获取蛋卷基金快照（总资产、子账户、持仓，推荐 -f json 输出）',
+  domain: 'danjuanfunds.com',
+  strategy: Strategy.COOKIE,
+  navigateBefore: 'https://danjuanfunds.com/my-money',
+  args: [],
+  columns: ['asOf', 'totalAssetAmount', 'totalFundMarketValue', 'accountCount', 'holdingCount'],
+  func: async (page: IPage) => {
+    const s = await fetchDanjuanAll(page);
+    return [{
+      asOf: s.asOf,
+      totalAssetAmount: s.totalAssetAmount,
+      totalAssetDailyGain: s.totalAssetDailyGain,
+      totalFundMarketValue: s.totalFundMarketValue,
+      accountCount: s.accounts.length,
+      holdingCount: s.holdings.length,
+      accounts: s.accounts,
+      holdings: s.holdings,
+    }];
+  },
+});