@jackwener/opencli 1.3.3 → 1.4.1

package/dist/clis/xueqiu/danjuan-utils.js

@@ -0,0 +1,126 @@
+/**
+ * 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.
+ */
+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=`;
+// ---------------------------------------------------------------------------
+// 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) {
+    const raw = 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) => {
+            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;
+}

package/dist/clis/xueqiu/danjuan-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/xueqiu/danjuan-utils.test.js

@@ -0,0 +1,41 @@
+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 }),
+        };
+        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 },
+                ],
+            }),
+        };
+        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),
+        };
+        await expect(fetchDanjuanAll(mockPage)).resolves.toMatchObject({
+            asOf: '2026-03-25',
+            accounts: [{ accountId: 'acc-1', accountName: '默认账户' }],
+            holdings: [{ accountId: 'acc-1', fdCode: '000001', fdName: '示例基金' }],
+        });
+    });
+});

package/dist/clis/xueqiu/fund-holdings.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/xueqiu/fund-holdings.js

@@ -0,0 +1,28 @@
+import { cli, Strategy } from '../../registry.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, 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/dist/clis/xueqiu/fund-snapshot.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/xueqiu/fund-snapshot.js

@@ -0,0 +1,25 @@
+import { cli, Strategy } from '../../registry.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) => {
+        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,
+            }];
+    },
+});

package/dist/clis/xueqiu/search.yaml

@@ -48,7 +48,8 @@ pipeline:
       exchange: ${{ item.exchange }}
       price: ${{ item.price }}
       changePercent: ${{ item.changePercent }}
+      url: ${{ item.url }}
       
   - limit: ${{ args.limit }}
 
-columns: [symbol, name, exchange, price, changePercent]
+columns: [symbol, name, exchange, price, changePercent, url]

package/dist/clis/yahoo-finance/quote.js

@@ -1,6 +1,5 @@
 /**
  * Yahoo Finance stock quote — multi-strategy API fallback.
- * Source: bb-sites/yahoo-finance/quote.js
  */
 import { cli, Strategy } from '../../registry.js';
 cli({

package/dist/clis/youtube/channel.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/youtube/channel.js

@@ -0,0 +1,150 @@
+/**
+ * YouTube channel — get channel info and recent videos via InnerTube API.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CommandExecutionError } from '../../errors.js';
+cli({
+    site: 'youtube',
+    name: 'channel',
+    description: 'Get YouTube channel info and recent videos',
+    domain: 'www.youtube.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'id', required: true, positional: true, help: 'Channel ID (UCxxxx) or handle (@name)' },
+        { name: 'limit', type: 'int', default: 10, help: 'Max recent videos (max 30)' },
+    ],
+    columns: ['field', 'value'],
+    func: async (page, kwargs) => {
+        const channelId = String(kwargs.id);
+        const limit = Math.min(kwargs.limit || 10, 30);
+        await page.goto('https://www.youtube.com');
+        await page.wait(2);
+        const data = await page.evaluate(`
+      (async () => {
+        const channelId = ${JSON.stringify(channelId)};
+        const limit = ${limit};
+        const cfg = window.ytcfg?.data_ || {};
+        const apiKey = cfg.INNERTUBE_API_KEY;
+        const context = cfg.INNERTUBE_CONTEXT;
+        if (!apiKey || !context) return {error: 'YouTube config not found'};
+
+        // Resolve handle to browseId if needed
+        let browseId = channelId;
+        if (channelId.startsWith('@')) {
+          const resolveResp = await fetch('/youtubei/v1/navigation/resolve_url?key=' + apiKey + '&prettyPrint=false', {
+            method: 'POST', credentials: 'include',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify({context, url: 'https://www.youtube.com/' + channelId})
+          });
+          if (resolveResp.ok) {
+            const resolveData = await resolveResp.json();
+            browseId = resolveData.endpoint?.browseEndpoint?.browseId || channelId;
+          }
+        }
+
+        // Fetch channel data
+        const resp = await fetch('/youtubei/v1/browse?key=' + apiKey + '&prettyPrint=false', {
+          method: 'POST', credentials: 'include',
+          headers: {'Content-Type': 'application/json'},
+          body: JSON.stringify({context, browseId})
+        });
+        if (!resp.ok) return {error: 'Channel API returned HTTP ' + resp.status};
+        const data = await resp.json();
+
+        // Channel metadata
+        const metadata = data.metadata?.channelMetadataRenderer || {};
+        const header = data.header?.pageHeaderRenderer || data.header?.c4TabbedHeaderRenderer || {};
+
+        // Subscriber count from header
+        let subscriberCount = '';
+        try {
+          const rows = header.content?.pageHeaderViewModel?.metadata?.contentMetadataViewModel?.metadataRows || [];
+          for (const row of rows) {
+            for (const part of (row.metadataParts || [])) {
+              const text = part.text?.content || '';
+              if (text.includes('subscriber')) subscriberCount = text;
+            }
+          }
+        } catch {}
+        // Fallback for old c4TabbedHeaderRenderer format
+        if (!subscriberCount && header.subscriberCountText?.simpleText) {
+          subscriberCount = header.subscriberCountText.simpleText;
+        }
+
+        // Extract recent videos from Home tab
+        const tabs = data.contents?.twoColumnBrowseResultsRenderer?.tabs || [];
+        const homeTab = tabs.find(t => t.tabRenderer?.selected);
+        const recentVideos = [];
+
+        if (homeTab) {
+          const sections = homeTab.tabRenderer?.content?.sectionListRenderer?.contents || [];
+          for (const section of sections) {
+            for (const shelf of (section.itemSectionRenderer?.contents || [])) {
+              for (const item of (shelf.shelfRenderer?.content?.horizontalListRenderer?.items || [])) {
+                // New lockupViewModel format
+                const lvm = item.lockupViewModel;
+                if (lvm && lvm.contentType === 'LOCKUP_CONTENT_TYPE_VIDEO' && recentVideos.length < limit) {
+                  const meta = lvm.metadata?.lockupMetadataViewModel;
+                  const rows = meta?.metadata?.contentMetadataViewModel?.metadataRows || [];
+                  const viewsAndTime = (rows[0]?.metadataParts || []).map(p => p.text?.content).filter(Boolean).join(' | ');
+                  let duration = '';
+                  for (const ov of (lvm.contentImage?.thumbnailViewModel?.overlays || [])) {
+                    for (const b of (ov.thumbnailBottomOverlayViewModel?.badges || [])) {
+                      if (b.thumbnailBadgeViewModel?.text) duration = b.thumbnailBadgeViewModel.text;
+                    }
+                  }
+                  recentVideos.push({
+                    title: meta?.title?.content || '',
+                    duration,
+                    views: viewsAndTime,
+                    url: 'https://www.youtube.com/watch?v=' + lvm.contentId,
+                  });
+                }
+                // Legacy gridVideoRenderer format
+                if (item.gridVideoRenderer && recentVideos.length < limit) {
+                  const v = item.gridVideoRenderer;
+                  recentVideos.push({
+                    title: v.title?.runs?.[0]?.text || v.title?.simpleText || '',
+                    duration: v.thumbnailOverlays?.[0]?.thumbnailOverlayTimeStatusRenderer?.text?.simpleText || '',
+                    views: (v.shortViewCountText?.simpleText || '') + (v.publishedTimeText?.simpleText ? ' | ' + v.publishedTimeText.simpleText : ''),
+                    url: 'https://www.youtube.com/watch?v=' + v.videoId,
+                  });
+                }
+              }
+            }
+          }
+        }
+
+        return {
+          name: metadata.title || '',
+          channelId: metadata.externalId || browseId,
+          handle: metadata.vanityChannelUrl?.split('/').pop() || '',
+          description: (metadata.description || '').substring(0, 500),
+          subscribers: subscriberCount,
+          url: metadata.channelUrl || 'https://www.youtube.com/channel/' + browseId,
+          keywords: metadata.keywords || '',
+          recentVideos,
+        };
+      })()
+    `);
+        if (!data || typeof data !== 'object')
+            throw new CommandExecutionError('Failed to fetch channel data');
+        if (data.error)
+            throw new CommandExecutionError(String(data.error));
+        const result = data;
+        const videos = result.recentVideos;
+        delete result.recentVideos;
+        // Channel info as field/value pairs + recent videos as table
+        const rows = Object.entries(result).map(([field, value]) => ({
+            field,
+            value: String(value),
+        }));
+        if (videos && videos.length > 0) {
+            rows.push({ field: '---', value: '--- Recent Videos ---' });
+            for (const v of videos) {
+                rows.push({ field: v.title, value: `${v.duration} | ${v.views} | ${v.url}` });
+            }
+        }
+        return rows;
+    },
+});

package/dist/clis/youtube/comments.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/youtube/comments.js

@@ -0,0 +1,95 @@
+/**
+ * YouTube comments — get video comments via InnerTube API.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CommandExecutionError } from '../../errors.js';
+import { parseVideoId } from './utils.js';
+cli({
+    site: 'youtube',
+    name: 'comments',
+    description: 'Get YouTube video comments',
+    domain: 'www.youtube.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'url', required: true, positional: true, help: 'YouTube video URL or video ID' },
+        { name: 'limit', type: 'int', default: 20, help: 'Max comments (max 100)' },
+    ],
+    columns: ['rank', 'author', 'text', 'likes', 'replies', 'time'],
+    func: async (page, kwargs) => {
+        const videoId = parseVideoId(kwargs.url);
+        const limit = Math.min(kwargs.limit || 20, 100);
+        await page.goto(`https://www.youtube.com/watch?v=${videoId}`);
+        await page.wait(3);
+        const data = await page.evaluate(`
+      (async () => {
+        const videoId = ${JSON.stringify(videoId)};
+        const limit = ${limit};
+        const cfg = window.ytcfg?.data_ || {};
+        const apiKey = cfg.INNERTUBE_API_KEY;
+        const context = cfg.INNERTUBE_CONTEXT;
+        if (!apiKey || !context) return {error: 'YouTube config not found'};
+
+        // Step 1: Get comment continuation token
+        let continuationToken = null;
+
+        // Try from current page ytInitialData
+        if (window.ytInitialData) {
+          const results = window.ytInitialData.contents?.twoColumnWatchNextResults?.results?.results?.contents || [];
+          const commentSection = results.find(i => i.itemSectionRenderer?.targetId === 'comments-section');
+          continuationToken = commentSection?.itemSectionRenderer?.contents?.[0]?.continuationItemRenderer?.continuationEndpoint?.continuationCommand?.token;
+        }
+
+        // Fallback: fetch via next API
+        if (!continuationToken) {
+          const nextResp = await fetch('/youtubei/v1/next?key=' + apiKey + '&prettyPrint=false', {
+            method: 'POST', credentials: 'include',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify({context, videoId})
+          });
+          if (!nextResp.ok) return {error: 'Failed to get video data: HTTP ' + nextResp.status};
+          const nextData = await nextResp.json();
+          const results = nextData.contents?.twoColumnWatchNextResults?.results?.results?.contents || [];
+          const commentSection = results.find(i => i.itemSectionRenderer?.targetId === 'comments-section');
+          continuationToken = commentSection?.itemSectionRenderer?.contents?.[0]?.continuationItemRenderer?.continuationEndpoint?.continuationCommand?.token;
+        }
+
+        if (!continuationToken) return {error: 'No comment section found — comments may be disabled'};
+
+        // Step 2: Fetch comments
+        const commentResp = await fetch('/youtubei/v1/next?key=' + apiKey + '&prettyPrint=false', {
+          method: 'POST', credentials: 'include',
+          headers: {'Content-Type': 'application/json'},
+          body: JSON.stringify({context, continuation: continuationToken})
+        });
+        if (!commentResp.ok) return {error: 'Failed to fetch comments: HTTP ' + commentResp.status};
+        const commentData = await commentResp.json();
+
+        // Parse from frameworkUpdates (new ViewModel format)
+        const mutations = commentData.frameworkUpdates?.entityBatchUpdate?.mutations || [];
+        const commentEntities = mutations.filter(m => m.payload?.commentEntityPayload);
+
+        return commentEntities.slice(0, limit).map((m, i) => {
+          const p = m.payload.commentEntityPayload;
+          const props = p.properties || {};
+          const author = p.author || {};
+          const toolbar = p.toolbar || {};
+          return {
+            rank: i + 1,
+            author: author.displayName || '',
+            text: (props.content?.content || '').substring(0, 300),
+            likes: toolbar.likeCountNotliked || '0',
+            replies: toolbar.replyCount || '0',
+            time: props.publishedTime || '',
+          };
+        });
+      })()
+    `);
+        if (!Array.isArray(data)) {
+            const errMsg = data && typeof data === 'object' ? String(data.error || '') : '';
+            if (errMsg)
+                throw new CommandExecutionError(errMsg);
+            return [];
+        }
+        return data;
+    },
+});

package/dist/clis/youtube/search.js

@@ -1,6 +1,5 @@
 /**
  * YouTube search — innertube API via browser session.
- * Source: bb-sites/youtube/search.js
  */
 import { cli, Strategy } from '../../registry.js';
 cli({

package/dist/clis/youtube/transcript.js

@@ -12,6 +12,7 @@
 import { cli, Strategy } from '../../registry.js';
 import { parseVideoId } from './utils.js';
 import { groupTranscriptSegments, formatGroupedTranscript, } from './transcript-group.js';
+import { CommandExecutionError, EmptyResultError } from '../../errors.js';
 cli({
     site: 'youtube',
     name: 'transcript',
@@ -82,10 +83,10 @@ cli({
       })()
     `);
         if (!captionData || typeof captionData === 'string') {
-            throw new Error(`Failed to get caption info: ${typeof captionData === 'string' ? captionData : 'null response'}`);
+            throw new CommandExecutionError(`Failed to get caption info: ${typeof captionData === 'string' ? captionData : 'null response'}`);
         }
         if (captionData.error) {
-            throw new Error(`${captionData.error}${captionData.available ? ' (available: ' + captionData.available.join(', ') + ')' : ''}`);
+            throw new CommandExecutionError(`${captionData.error}${captionData.available ? ' (available: ' + captionData.available.join(', ') + ')' : ''}`);
         }
         // Warn if --lang was specified but not matched
         if (captionData.requestedLang && !captionData.langMatched && !captionData.langPrefixMatched) {
@@ -164,10 +165,10 @@ cli({
       })()
     `);
         if (!Array.isArray(segments)) {
-            throw new Error(segments?.error || 'Failed to parse caption segments');
+            throw new CommandExecutionError(segments?.error || 'Failed to parse caption segments');
         }
         if (segments.length === 0) {
-            throw new Error('No caption segments found');
+            throw new EmptyResultError('youtube transcript');
         }
         // Step 3: Fetch chapters (for grouped mode)
         let chapters = [];

package/dist/clis/youtube/video.js

@@ -3,6 +3,7 @@
  */
 import { cli, Strategy } from '../../registry.js';
 import { parseVideoId } from './utils.js';
+import { CommandExecutionError } from '../../errors.js';
 cli({
     site: 'youtube',
     name: 'video',
@@ -102,9 +103,9 @@ cli({
       })()
     `);
         if (!data || typeof data !== 'object')
-            throw new Error('Failed to extract video metadata from page');
+            throw new CommandExecutionError('Failed to extract video metadata from page');
         if (data.error)
-            throw new Error(data.error);
+            throw new CommandExecutionError(data.error);
         // Return as field/value pairs for table display
         return Object.entries(data).map(([field, value]) => ({
             field,

package/dist/clis/zhihu/search.yaml

@@ -52,7 +52,8 @@ pipeline:
       type: ${{ item.type }}
       author: ${{ item.author }}
       votes: ${{ item.votes }}
+      url: ${{ item.url }}
 
   - limit: ${{ args.limit }}
 
-columns: [rank, title, type, author, votes]
+columns: [rank, title, type, author, votes, url]

package/dist/daemon.js

@@ -49,17 +49,21 @@ function readBody(req) {
     return new Promise((resolve, reject) => {
         const chunks = [];
         let size = 0;
+        let aborted = false;
         req.on('data', (c) => {
             size += c.length;
             if (size > MAX_BODY) {
+                aborted = true;
                 req.destroy();
                 reject(new Error('Body too large'));
                 return;
             }
             chunks.push(c);
         });
-        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
-        req.on('error', reject);
+        req.on('end', () => { if (!aborted)
+            resolve(Buffer.concat(chunks).toString('utf-8')); });
+        req.on('error', (err) => { if (!aborted)
+            reject(err); });
     });
 }
 function jsonResponse(res, status, data) {
@@ -237,7 +241,7 @@ httpServer.listen(PORT, '127.0.0.1', () => {
 httpServer.on('error', (err) => {
     if (err.code === 'EADDRINUSE') {
         console.error(`[daemon] Port ${PORT} already in use — another daemon is likely running. Exiting.`);
-        process.exit(0);
+        process.exit(1);
     }
     console.error('[daemon] Server error:', err.message);
     process.exit(1);