@jackwener/opencli 1.3.3 → 1.4.0

package/src/clis/douban/utils.ts

@@ -1,9 +1,173 @@
 /**
- * Douban movie adapter utilities.
+ * Douban adapter utilities.
  */
 
+import { CliError } from '../../errors.js';
 import type { IPage } from '../../types.js';
 
+function clampLimit(limit: number): number {
+  return Math.max(1, Math.min(limit || 20, 50));
+}
+
+async function ensureDoubanReady(page: IPage): Promise<void> {
+  const state = await page.evaluate(`
+    (() => {
+      const title = (document.title || '').trim();
+      const href = (location.href || '').trim();
+      const blocked = href.includes('sec.douban.com') || /登录跳转/.test(title) || /异常请求/.test(document.body?.innerText || '');
+      return { blocked, title, href };
+    })()
+  `);
+  if (state?.blocked) {
+    throw new CliError(
+      'AUTH_REQUIRED',
+      'Douban requires a logged-in browser session before these commands can load data.',
+      'Please sign in to douban.com in the browser that opencli reuses, then rerun the command.',
+    );
+  }
+}
+
+export async function loadDoubanBookHot(page: IPage, limit: number): Promise<any[]> {
+  const safeLimit = clampLimit(limit);
+  await page.goto('https://book.douban.com/chart');
+  await page.wait(4);
+  await ensureDoubanReady(page);
+  const data = await page.evaluate(`
+    (() => {
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const books = [];
+      for (const el of Array.from(document.querySelectorAll('.media.clearfix'))) {
+        try {
+          const titleEl = el.querySelector('h2 a[href*="/subject/"]');
+          const title = normalize(titleEl?.textContent);
+          let url = titleEl?.getAttribute('href') || '';
+          if (!title || !url) continue;
+          if (!url.startsWith('http')) url = 'https://book.douban.com' + url;
+
+          const info = normalize(el.querySelector('.subject-abstract, .pl, .pub')?.textContent);
+          const infoParts = info.split('/').map((part) => part.trim()).filter(Boolean);
+          const ratingText = normalize(el.querySelector('.subject-rating .font-small, .rating_nums, .rating')?.textContent);
+          const quote = Array.from(el.querySelectorAll('.subject-tags .tag'))
+            .map((node) => normalize(node.textContent))
+            .filter(Boolean)
+            .join(' / ');
+
+          books.push({
+            rank: parseInt(normalize(el.querySelector('.green-num-box')?.textContent), 10) || books.length + 1,
+            title,
+            rating: parseFloat(ratingText) || 0,
+            quote,
+            author: infoParts[0] || '',
+            publisher: infoParts.find((part) => /出版社|出版公司|Press/i.test(part)) || infoParts[2] || '',
+            year: infoParts.find((part) => /\\d{4}(?:-\\d{1,2})?/.test(part))?.match(/\\d{4}/)?.[0] || '',
+            price: infoParts.find((part) => /元|USD|\\$|￥/.test(part)) || '',
+            url,
+            cover: el.querySelector('img')?.getAttribute('src') || '',
+          });
+        } catch {}
+      }
+      return books.slice(0, ${safeLimit});
+    })()
+  `);
+  return Array.isArray(data) ? data : [];
+}
+
+export async function loadDoubanMovieHot(page: IPage, limit: number): Promise<any[]> {
+  const safeLimit = clampLimit(limit);
+  await page.goto('https://movie.douban.com/chart');
+  await page.wait(4);
+  await ensureDoubanReady(page);
+  const data = await page.evaluate(`
+    (() => {
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const results = [];
+      for (const el of Array.from(document.querySelectorAll('.item'))) {
+        const titleEl = el.querySelector('.pl2 a');
+        const title = normalize(titleEl?.textContent);
+        let url = titleEl?.getAttribute('href') || '';
+        if (!title || !url) continue;
+        if (!url.startsWith('http')) url = 'https://movie.douban.com' + url;
+
+        const info = normalize(el.querySelector('.pl2 p')?.textContent);
+        const infoParts = info.split('/').map((part) => part.trim()).filter(Boolean);
+        const releaseIndex = (() => {
+          for (let i = infoParts.length - 1; i >= 0; i -= 1) {
+            if (/\\d{4}-\\d{2}-\\d{2}|\\d{4}\\/\\d{2}\\/\\d{2}/.test(infoParts[i])) return i;
+          }
+          return -1;
+        })();
+        const directorPart = releaseIndex >= 1 ? infoParts[releaseIndex - 1] : '';
+        const regionPart = releaseIndex >= 2 ? infoParts[releaseIndex - 2] : '';
+        const yearMatch = info.match(/\\b(19|20)\\d{2}\\b/);
+        results.push({
+          rank: results.length + 1,
+          title,
+          rating: parseFloat(normalize(el.querySelector('.rating_nums')?.textContent)) || 0,
+          quote: normalize(el.querySelector('.inq')?.textContent),
+          director: directorPart.replace(/^导演:\\s*/, ''),
+          year: yearMatch?.[0] || '',
+          region: regionPart,
+          url,
+          cover: el.querySelector('img')?.getAttribute('src') || '',
+        });
+        if (results.length >= ${safeLimit}) break;
+      }
+      return results;
+    })()
+  `);
+  return Array.isArray(data) ? data : [];
+}
+
+export async function searchDouban(page: IPage, type: string, keyword: string, limit: number): Promise<any[]> {
+  const safeLimit = clampLimit(limit);
+  await page.goto(`https://search.douban.com/${encodeURIComponent(type)}/subject_search?search_text=${encodeURIComponent(keyword)}`);
+  await page.wait(2);
+  await ensureDoubanReady(page);
+  const data = await page.evaluate(`
+    (async () => {
+      const type = ${JSON.stringify(type)};
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const seen = new Set();
+      const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+      for (let i = 0; i < 20; i += 1) {
+        if (document.querySelector('.item-root .title-text, .item-root .title a')) break;
+        await sleep(300);
+      }
+
+      const items = Array.from(document.querySelectorAll('.item-root'));
+
+      const results = [];
+      for (const el of items) {
+        const titleEl = el.querySelector('.title-text, .title a, a[title]');
+        const title = normalize(titleEl?.textContent) || normalize(titleEl?.getAttribute('title'));
+        let url = titleEl?.getAttribute('href') || '';
+        if (!title || !url) continue;
+        if (!url.startsWith('http')) url = 'https://search.douban.com' + url;
+        if (!url.includes('/subject/') || seen.has(url)) continue;
+        seen.add(url);
+        const ratingText = normalize(el.querySelector('.rating_nums')?.textContent);
+        const abstract = normalize(
+          el.querySelector('.meta.abstract, .meta, .abstract, p')?.textContent,
+        );
+        results.push({
+          rank: results.length + 1,
+          id: url.match(/subject\\/(\\d+)/)?.[1] || '',
+          type,
+          title,
+          rating: ratingText.includes('.') ? parseFloat(ratingText) : 0,
+          abstract: abstract.slice(0, 100) + (abstract.length > 100 ? '...' : ''),
+          url,
+          cover: el.querySelector('img')?.getAttribute('src') || '',
+        });
+        if (results.length >= ${safeLimit}) break;
+      }
+      return results;
+    })()
+  `);
+  return Array.isArray(data) ? data : [];
+}
+
 /**
  * Get current user's Douban ID from movie.douban.com/mine page
  */

package/src/clis/doubao/ask.ts

@@ -1,6 +1,6 @@
 import { cli, Strategy } from '../../registry.js';
 import type { IPage } from '../../types.js';
-import { DOUBAO_DOMAIN, getDoubaoTranscriptLines, getDoubaoVisibleTurns, sendDoubaoMessage, waitForDoubaoResponse } from './common.js';
+import { DOUBAO_DOMAIN, getDoubaoTranscriptLines, getDoubaoVisibleTurns, sendDoubaoMessage, waitForDoubaoResponse } from './utils.js';
 
 export const askCommand = cli({
   site: 'doubao',

package/src/clis/doubao/new.ts

@@ -1,6 +1,6 @@
 import { cli, Strategy } from '../../registry.js';
 import type { IPage } from '../../types.js';
-import { DOUBAO_DOMAIN, DOUBAO_CHAT_URL, startNewDoubaoChat } from './common.js';
+import { DOUBAO_DOMAIN, DOUBAO_CHAT_URL, startNewDoubaoChat } from './utils.js';
 
 export const newCommand = cli({
   site: 'doubao',

package/src/clis/doubao/read.ts

@@ -1,6 +1,6 @@
 import { cli, Strategy } from '../../registry.js';
 import type { IPage } from '../../types.js';
-import { DOUBAO_DOMAIN, getDoubaoVisibleTurns } from './common.js';
+import { DOUBAO_DOMAIN, getDoubaoVisibleTurns } from './utils.js';
 
 export const readCommand = cli({
   site: 'doubao',

package/src/clis/doubao/send.ts

@@ -1,6 +1,6 @@
 import { cli, Strategy } from '../../registry.js';
 import type { IPage } from '../../types.js';
-import { DOUBAO_DOMAIN, DOUBAO_CHAT_URL, sendDoubaoMessage } from './common.js';
+import { DOUBAO_DOMAIN, DOUBAO_CHAT_URL, sendDoubaoMessage } from './utils.js';
 
 export const sendCommand = cli({
   site: 'doubao',

package/src/clis/doubao/status.ts

@@ -1,6 +1,6 @@
 import { cli, Strategy } from '../../registry.js';
 import type { IPage } from '../../types.js';
-import { DOUBAO_DOMAIN, DOUBAO_CHAT_URL, getDoubaoPageState } from './common.js';
+import { DOUBAO_DOMAIN, DOUBAO_CHAT_URL, getDoubaoPageState } from './utils.js';
 
 export const statusCommand = cli({
   site: 'doubao',

package/src/clis/doubao-app/ask.ts

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '../../registry.js';
-import { SEL, injectTextScript, clickSendScript, pollResponseScript } from './common.js';
+import { SEL, injectTextScript, clickSendScript, pollResponseScript } from './utils.js';
 
 export const askCommand = cli({
   site: 'doubao-app',

package/src/clis/doubao-app/new.ts

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '../../registry.js';
-import { clickNewChatScript } from './common.js';
+import { clickNewChatScript } from './utils.js';
 
 export const newCommand = cli({
   site: 'doubao-app',

package/src/clis/doubao-app/read.ts

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '../../registry.js';
-import { readMessagesScript } from './common.js';
+import { readMessagesScript } from './utils.js';
 
 export const readCommand = cli({
   site: 'doubao-app',

package/src/clis/doubao-app/send.ts

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '../../registry.js';
-import { injectTextScript, clickSendScript } from './common.js';
+import { injectTextScript, clickSendScript } from './utils.js';
 
 export const sendCommand = cli({
   site: 'doubao-app',

package/src/clis/grok/ask.test.ts

@@ -1,7 +1,32 @@
 import { describe, expect, it } from 'vitest';
+import type { IPage } from '../../types.js';
 import { __test__ } from './ask.js';
 
 describe('grok ask helpers', () => {
+  describe('isOnGrok', () => {
+    const fakePage = (url: string | Error): IPage =>
+      ({ evaluate: () => url instanceof Error ? Promise.reject(url) : Promise.resolve(url) }) as unknown as IPage;
+
+    it('returns true for grok.com URLs', async () => {
+      expect(await __test__.isOnGrok(fakePage('https://grok.com/'))).toBe(true);
+      expect(await __test__.isOnGrok(fakePage('https://grok.com/chat/abc123'))).toBe(true);
+    });
+
+    it('returns true for grok.com subdomains', async () => {
+      expect(await __test__.isOnGrok(fakePage('https://api.grok.com/v1'))).toBe(true);
+    });
+
+    it('returns false for non-grok domains', async () => {
+      expect(await __test__.isOnGrok(fakePage('https://fakegrok.com/'))).toBe(false);
+      expect(await __test__.isOnGrok(fakePage('https://example.com/?next=grok.com'))).toBe(false);
+      expect(await __test__.isOnGrok(fakePage('about:blank'))).toBe(false);
+    });
+
+    it('returns false when evaluate throws (detached tab)', async () => {
+      expect(await __test__.isOnGrok(fakePage(new Error('detached')))).toBe(false);
+    });
+  });
+
   it('normalizes boolean flags for explicit web routing', () => {
     expect(__test__.normalizeBooleanFlag(true)).toBe(true);
     expect(__test__.normalizeBooleanFlag('true')).toBe(true);

package/src/clis/grok/ask.ts

@@ -53,6 +53,19 @@ function updateStableState(previousText: string, stableCount: number, nextText:
   return { previousText: nextText, stableCount: 0 };
 }
 
+/** Check whether the tab is already on grok.com (any path). */
+async function isOnGrok(page: IPage): Promise<boolean> {
+  // catch handles blank tabs (about:blank) or detached pages
+  const url = await page.evaluate('window.location.href').catch(() => '');
+  if (typeof url !== 'string' || !url) return false;
+  try {
+    const hostname = new URL(url).hostname;
+    return hostname === 'grok.com' || hostname.endsWith('.grok.com');
+  } catch {
+    return false;
+  }
+}
+
 async function runDefaultAsk(
   page: IPage,
   prompt: string,
@@ -60,21 +73,17 @@ async function runDefaultAsk(
   newChat: boolean,
 ) {
   if (newChat) {
+    // Explicitly start a fresh conversation via the homepage
     await page.goto(GROK_URL);
     await page.wait(2);
-    await page.evaluate(`(() => {
-      const btn = [...document.querySelectorAll('a, button')].find(b => {
-        const t = (b.textContent || '').trim().toLowerCase();
-        return t.includes('new') || b.getAttribute('href') === '/';
-      });
-      if (btn) btn.click();
-    })()`);
+    await tryStartFreshChat(page);
     await page.wait(2);
+  } else if (!(await isOnGrok(page))) {
+    // First invocation or tab was recycled — navigate to Grok
+    await page.goto(GROK_URL);
+    await page.wait(3);
   }
 
-  await page.goto(GROK_URL);
-  await page.wait(3);
-
   const promptJson = JSON.stringify(prompt);
   const sendResult = await page.evaluate(`(async () => {
     try {
@@ -249,11 +258,14 @@ async function runExplicitWebAsk(
   timeoutMs: number,
   newChat: boolean,
 ) {
-  await page.goto(GROK_URL, { settleMs: 2000 });
-
   if (newChat) {
+    // Navigate to homepage and start a fresh conversation
+    await page.goto(GROK_URL, { settleMs: 2000 });
     await tryStartFreshChat(page);
     await page.wait(2);
+  } else if (!(await isOnGrok(page))) {
+    // First invocation or tab was recycled — navigate to Grok
+    await page.goto(GROK_URL, { settleMs: 2000 });
   }
 
   const baselineBubbles = await getBubbleTexts(page);
@@ -318,4 +330,5 @@ export const __test__ = {
   updateStableState,
   normalizeBooleanFlag,
   normalizeBubbleText,
+  isOnGrok,
 };

package/src/clis/jd/item.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './item.js';
+
+describe('jd item adapter', () => {
+  const command = getRegistry().get('jd/item');
+
+  it('registers the command with correct shape', () => {
+    expect(command).toBeDefined();
+    expect(command!.site).toBe('jd');
+    expect(command!.name).toBe('item');
+    expect(command!.domain).toBe('item.jd.com');
+    expect(command!.strategy).toBe('cookie');
+    expect(typeof command!.func).toBe('function');
+  });
+
+  it('has sku as a required positional arg', () => {
+    const skuArg = command!.args.find((a) => a.name === 'sku');
+    expect(skuArg).toBeDefined();
+    expect(skuArg!.required).toBe(true);
+    expect(skuArg!.positional).toBe(true);
+  });
+
+  it('has images arg with default 10', () => {
+    const imagesArg = command!.args.find((a) => a.name === 'images');
+    expect(imagesArg).toBeDefined();
+    expect(imagesArg!.default).toBe(10);
+  });
+
+  it('includes expected columns', () => {
+    expect(command!.columns).toEqual(
+      expect.arrayContaining(['title', 'price', 'shop', 'specs', 'mainImages', 'detailImages']),
+    );
+  });
+});

package/src/clis/jd/item.ts

@@ -0,0 +1,101 @@
+/**
+ * 京东商品详情 — browser cookie, DOM scraping + evaluate.
+ *
+ * 依赖: 需要在 Chrome 已登录京东
+ * 用法: opencli jd item 100291143898
+ */
+import { cli, Strategy } from '../../registry.js';
+
+cli({
+  site: 'jd',
+  name: 'item',
+  description: '京东商品详情（价格、主图、详情图、规格参数）',
+  domain: 'item.jd.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    {
+      name: 'sku',
+      required: true,
+      positional: true,
+      help: '商品 SKU ID（如 100291143898）',
+    },
+    {
+      name: 'images',
+      type: 'int',
+      default: 10,
+      help: '详情图数量（默认10）',
+    },
+  ],
+  columns: ['title', 'price', 'shop', 'specs', 'mainImages', 'detailImages'],
+  func: async (page, kwargs) => {
+    const sku = kwargs.sku;
+    const maxImages = kwargs.images as number;
+    const url = `https://item.jd.com/${sku}.html`;
+
+    await page.goto(url, { waitUntil: 'load' });
+    await page.wait(2);
+
+    // 滚动加载详情图
+    for (let i = 0; i < 6; i++) {
+      await page.evaluate(`window.scrollTo(0, ${i * 2500})`);
+      await page.wait(1);
+    }
+    await page.evaluate(`window.scrollTo(0, document.body.scrollHeight)`);
+    await page.wait(2);
+
+    const data = await page.evaluate(`
+      (() => {
+        const maxImg = ${maxImages};
+        // 尝试多种价格选择器
+        const skuMatch = location.pathname.match(/(\\d+)\\.html/);
+        const sku = skuMatch ? skuMatch[1] : '';
+        const priceEl = document.querySelector('.J-p-' + sku) ||
+                        document.querySelector('[class*="price"] [class*="num"]') ||
+                        document.querySelector('.p-price strong') ||
+                        document.querySelector('.price.jd-price');
+        const price = priceEl?.textContent?.trim() || 'not found';
+
+        // 标题
+        const title = document.querySelector('.product-title')?.textContent?.trim() ||
+                      document.title.split('-')[0].trim();
+
+        // 店铺
+        const shop = document.querySelector('.J-shop-name')?.textContent?.trim() || '京东自营';
+
+        // 所有图片
+        const allImgs = Array.from(document.querySelectorAll('img[src*="360buyimg.com"]'));
+        const srcs = allImgs.map(img => img.src).filter(Boolean);
+        const unique = [...new Set(srcs)];
+
+        // 主图
+        const mainImgs = unique
+          .filter(u => u.includes('/n1/') || u.includes('/n3/') || u.includes('/n4/') || u.includes('/img/'))
+          .slice(0, maxImg);
+
+        // 详情图
+        const detailImgs = unique
+          .filter(u => u.includes('/babel/') || u.includes('/popshop/'))
+          .slice(0, maxImg);
+
+        // 规格参数：从页面文本提取
+        const text = document.body.innerText;
+        const specMatch = text.match(/商品编号[\\s\\S]*?(?=包装清单|\\n\\n|$)/);
+        let specs = {};
+        if (specMatch) {
+          const lines = specMatch[0].split('\\n').filter(l => l.trim());
+          for (let i = 0; i < lines.length - 1; i += 2) {
+            const key = lines[i].trim();
+            const val = lines[i + 1]?.trim() || '';
+            if (key && val && key !== '商品编号') {
+              specs[key] = val;
+            }
+          }
+        }
+
+        return { title, price, shop, specs, mainImages: mainImgs, detailImages: detailImgs, totalImages: unique.length };
+      })()
+    `);
+
+    return [data];
+  },
+});

package/src/clis/jike/feed.ts

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '../../registry.js';
-import { JikePost, getPostDataJs } from './shared.js';
+import { JikePost, getPostDataJs } from './utils.js';
 
 /**
  * 即刻首页动态流适配器

package/src/clis/jike/search.ts

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '../../registry.js';
-import { JikePost, getPostDataJs } from './shared.js';
+import { JikePost, getPostDataJs } from './utils.js';
 
 /**
  * 即刻搜索适配器

package/src/clis/linkedin/search.ts

@@ -1,5 +1,6 @@
 import { cli, Strategy } from '../../registry.js';
 import type { IPage } from '../../types.js';
+import { ArgumentError, CommandExecutionError } from '../../errors.js';
 
 // ── Filter value mappings ──────────────────────────────────────────────
 
@@ -64,7 +65,7 @@ function mapFilterValues(input: unknown, mapping: Record<string, string>, label:
   const resolved = values.map(value => {
     const key = value.toLowerCase();
     const mapped = mapping[key];
-    if (!mapped) throw new Error(`Unsupported ${label}: ${value}`);
+    if (!mapped) throw new ArgumentError(`Unsupported ${label}: ${value}`);
     return mapped;
   });
   return [...new Set(resolved)];
@@ -214,7 +215,7 @@ async function resolveCompanyIds(page: IPage, input: unknown): Promise<string[]>
   }
 
   if (unresolved.length) {
-    throw new Error(`Could not resolve LinkedIn company filter: ${unresolved.join(', ')}`);
+    throw new ArgumentError(`Could not resolve LinkedIn company filter: ${unresolved.join(', ')}`);
   }
 
   return [...ids];
@@ -252,7 +253,7 @@ async function fetchJobCards(
     })()`);
 
     if (!batch || batch.error) {
-      throw new Error(batch?.error || 'LinkedIn search returned an unexpected response');
+      throw new CommandExecutionError(batch?.error || 'LinkedIn search returned an unexpected response');
     }
 
     const elements: any[] = Array.isArray(batch?.elements) ? batch.elements : [];
@@ -387,7 +388,7 @@ cli({
     const location = (kwargs.location ?? '').trim();
     const keywords = String(kwargs.query ?? '').trim();
 
-    if (!keywords) throw new Error('query is required');
+    if (!keywords) throw new ArgumentError('query is required');
 
     const searchParams = new URLSearchParams({ keywords });
     if (location) searchParams.set('location', location);

package/src/clis/linkedin/timeline.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './timeline.js';
+
+const { parseMetric, buildPostId, mergeTimelinePosts } = await import('./timeline.js').then(
+  (m) => (m as any).__test__,
+);
+
+describe('linkedin timeline adapter', () => {
+  const command = getRegistry().get('linkedin/timeline');
+
+  it('registers the command with correct shape', () => {
+    expect(command).toBeDefined();
+    expect(command!.site).toBe('linkedin');
+    expect(command!.name).toBe('timeline');
+    expect(command!.domain).toBe('www.linkedin.com');
+    expect(command!.strategy).toBe('cookie');
+    expect(command!.browser).toBe(true);
+    expect(typeof command!.func).toBe('function');
+  });
+
+  it('has limit arg with default 20', () => {
+    const limitArg = command!.args.find((a) => a.name === 'limit');
+    expect(limitArg).toBeDefined();
+    expect(limitArg!.default).toBe(20);
+  });
+
+  it('includes expected columns', () => {
+    expect(command!.columns).toEqual(
+      expect.arrayContaining(['author', 'text', 'reactions', 'comments', 'url']),
+    );
+  });
+});
+
+describe('parseMetric', () => {
+  it('parses plain numbers', () => {
+    expect(parseMetric('42')).toBe(42);
+    expect(parseMetric('1,234')).toBe(1234);
+  });
+
+  it('handles k/m suffixes', () => {
+    expect(parseMetric('2.5k')).toBe(2500);
+    expect(parseMetric('1.2M')).toBe(1200000);
+  });
+
+  it('returns 0 for empty/undefined', () => {
+    expect(parseMetric('')).toBe(0);
+    expect(parseMetric(undefined)).toBe(0);
+    expect(parseMetric(null)).toBe(0);
+  });
+});
+
+describe('buildPostId', () => {
+  it('uses url when present', () => {
+    expect(buildPostId({ url: 'https://linkedin.com/post/123' })).toBe(
+      'https://linkedin.com/post/123',
+    );
+  });
+
+  it('falls back to composite key', () => {
+    const id = buildPostId({ author: 'Alice', posted_at: '2h', text: 'Hello world' });
+    expect(id).toBe('Alice::2h::Hello world');
+  });
+});
+
+describe('mergeTimelinePosts', () => {
+  it('deduplicates by url', () => {
+    const url = 'https://linkedin.com/post/1';
+    const a = {
+      id: url,
+      author: 'Alice',
+      author_url: '',
+      headline: '',
+      text: 'Hello',
+      posted_at: '1h',
+      reactions: 5,
+      comments: 1,
+      url,
+    };
+    const result = mergeTimelinePosts([a], [a]);
+    expect(result).toHaveLength(1);
+  });
+
+  it('skips posts without author or text', () => {
+    const empty = {
+      id: '2',
+      author: '',
+      author_url: '',
+      headline: '',
+      text: 'some text',
+      posted_at: '',
+      reactions: 0,
+      comments: 0,
+      url: '',
+    };
+    const result = mergeTimelinePosts([], [empty]);
+    expect(result).toHaveLength(0);
+  });
+});