@jackwener/opencli 1.7.22 → 1.8.1

package/clis/linkedin/people-search.test.js

@@ -0,0 +1,216 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import './people-search.js';
+
+const {
+    parseLimit,
+    buildSearchUrl,
+    looksLinkedInAuthWall,
+    normalizeProfileUrl,
+    normalizePeopleRows,
+    parseNonNegativeCount,
+    extractionScript,
+} = await import('./people-search.js').then((m) => m.__test__);
+
+function extractionResult(rows, counts = {}) {
+    return {
+        rows,
+        candidate_count: counts.candidate_count ?? rows.length,
+        person_entries_count: counts.person_entries_count ?? counts.candidate_count ?? rows.length,
+        resolved_count: counts.resolved_count ?? rows.length,
+    };
+}
+
+function makePage({
+    evaluateResult,
+    evaluateReject,
+    gotoReject,
+    cookies = [{ name: 'JSESSIONID', value: '"ajax:1234567890"' }],
+} = {}) {
+    return {
+        goto: vi.fn().mockImplementation(() => gotoReject ? Promise.reject(gotoReject) : Promise.resolve(undefined)),
+        wait: vi.fn().mockResolvedValue(undefined),
+        getCookies: vi.fn().mockResolvedValue(cookies),
+        evaluate: vi.fn().mockImplementation(() => evaluateReject ? Promise.reject(evaluateReject) : Promise.resolve(evaluateResult)),
+    };
+}
+
+describe('linkedin people-search command', () => {
+    it('builds the canonical SSR search URL with encoded keywords', () => {
+        expect(buildSearchUrl('site reliability engineer'))
+            .toBe('https://www.linkedin.com/search/results/people/?keywords=site%20reliability%20engineer');
+        expect(buildSearchUrl('hello/world & stuff'))
+            .toBe('https://www.linkedin.com/search/results/people/?keywords=hello%2Fworld%20%26%20stuff');
+    });
+
+    it('validates --limit without silent clamping', () => {
+        expect(parseLimit(undefined)).toBe(5);
+        expect(parseLimit(1)).toBe(1);
+        expect(parseLimit(10)).toBe(10);
+        expect(() => parseLimit(0)).toThrow(ArgumentError);
+        expect(() => parseLimit(11)).toThrow(ArgumentError);
+        expect(() => parseLimit(-1)).toThrow(ArgumentError);
+        expect(() => parseLimit('abc')).toThrow(ArgumentError);
+        expect(() => parseLimit(1.5)).toThrow(ArgumentError);
+    });
+
+    it('extraction script slices main.innerText by person-name boundaries', () => {
+        const s = extractionScript();
+        // Anchor enumeration finds /in/<handle>.
+        expect(s).toContain('a[href*="/in/"]');
+        expect(s).toContain('\\/in\\/([^/?#]+)');
+        // Text-slice approach: split main.innerText and locate names.
+        expect(s).toContain('main.innerText');
+        expect(s).toContain('lines.findIndex');
+        // Mutual-connection anchors are filtered out via the skip()
+        // predicate on the name-line match.
+        expect(s).toContain('mutual connection');
+        // Names dedup'd by handle.
+        expect(s).toContain('seenHandles');
+        // Aria-hidden span as canonical name source.
+        expect(s).toContain('span[aria-hidden="true"]');
+        // Only operates on the people-search page.
+        expect(s).toContain('search\\/results\\/people');
+        expect(s).toContain('candidate_count');
+        expect(s).toContain('resolved_count');
+    });
+
+    it('normalizes only stable LinkedIn profile identities', () => {
+        expect(normalizeProfileUrl('https://www.linkedin.com/in/alice-engineer/?mini=true'))
+            .toBe('https://www.linkedin.com/in/alice-engineer/');
+        expect(normalizeProfileUrl('https://linkedin.com/in/bob-builder')).toBe('https://www.linkedin.com/in/bob-builder/');
+        expect(normalizeProfileUrl('https://evil-linkedin.com/in/bob-builder')).toBe('');
+        expect(normalizeProfileUrl('http://www.linkedin.com/in/bob-builder')).toBe('');
+        expect(normalizeProfileUrl('https://www.linkedin.com/company/opencli')).toBe('');
+    });
+
+    it('detects LinkedIn auth-wall URLs separately from CUL redirects', () => {
+        expect(looksLinkedInAuthWall('https://www.linkedin.com/authwall Sign in to continue')).toBe(true);
+        expect(looksLinkedInAuthWall('https://www.linkedin.com/checkpoint/challenge security verification required')).toBe(true);
+        expect(looksLinkedInAuthWall('https://www.linkedin.com/feed/')).toBe(false);
+    });
+
+    it('rejects malformed extraction rows instead of fabricating success rows', () => {
+        expect(() => normalizePeopleRows({})).toThrow(CommandExecutionError);
+        expect(() => normalizePeopleRows([null])).toThrow(CommandExecutionError);
+        expect(() => normalizePeopleRows([{ name: 'No URL', headline: 'h', location: 'l', profile_url: '' }]))
+            .toThrow(CommandExecutionError);
+        expect(() => normalizePeopleRows([{ name: '', headline: 'h', location: 'l', profile_url: 'https://www.linkedin.com/in/no-name/' }]))
+            .toThrow(CommandExecutionError);
+    });
+
+    it('validates extraction evidence counters', () => {
+        expect(parseNonNegativeCount(0, 'candidate_count')).toBe(0);
+        expect(parseNonNegativeCount(2, 'candidate_count')).toBe(2);
+        expect(() => parseNonNegativeCount(undefined, 'candidate_count')).toThrow(CommandExecutionError);
+        expect(() => parseNonNegativeCount(-1, 'candidate_count')).toThrow(CommandExecutionError);
+        expect(() => parseNonNegativeCount(1.2, 'candidate_count')).toThrow(CommandExecutionError);
+    });
+
+    it('returns ranked rows when the page yields people', async () => {
+        const cmd = getRegistry().get('linkedin/people-search');
+        expect(cmd?.func).toBeTypeOf('function');
+        const page = makePage({
+            evaluateResult: extractionResult([
+                { name: 'Alice Engineer', headline: 'Staff SWE at Acme', location: 'Berlin', profile_url: 'https://www.linkedin.com/in/alice-engineer/' },
+                { name: 'Bob Builder', headline: 'CTO at Globex', location: 'Remote', profile_url: 'https://www.linkedin.com/in/bob-builder/' },
+            ]),
+        });
+        const result = await cmd.func(page, { keywords: 'reinforcement learning', limit: 5 });
+        expect(page.goto).toHaveBeenCalledWith('https://www.linkedin.com/search/results/people/?keywords=reinforcement%20learning');
+        expect(result).toEqual([
+            { rank: 1, name: 'Alice Engineer', headline: 'Staff SWE at Acme', location: 'Berlin', profile_url: 'https://www.linkedin.com/in/alice-engineer/' },
+            { rank: 2, name: 'Bob Builder', headline: 'CTO at Globex', location: 'Remote', profile_url: 'https://www.linkedin.com/in/bob-builder/' },
+        ]);
+    });
+
+    it('slices to --limit when more rows are extracted than requested', async () => {
+        const cmd = getRegistry().get('linkedin/people-search');
+        const page = makePage({
+            evaluateResult: extractionResult(Array.from({ length: 8 }, (_, i) => ({
+                name: `Person ${i}`, headline: 'h', location: 'l', profile_url: `https://www.linkedin.com/in/p${i}/`,
+            }))),
+        });
+        const result = await cmd.func(page, { keywords: 'x', limit: 3 });
+        expect(result).toHaveLength(3);
+        expect(result.map((r) => r.rank)).toEqual([1, 2, 3]);
+    });
+
+    it('throws AuthRequiredError when JSESSIONID cookie is missing', async () => {
+        const cmd = getRegistry().get('linkedin/people-search');
+        const page = makePage({ cookies: [], evaluateResult: extractionResult([]) });
+        await expect(cmd.func(page, { keywords: 'x', limit: 5 })).rejects.toBeInstanceOf(AuthRequiredError);
+    });
+
+    it('treats malformed cookie lookup results as CommandExecutionError', async () => {
+        const cmd = getRegistry().get('linkedin/people-search');
+        const page = makePage({ cookies: null, evaluateResult: extractionResult([]) });
+        await expect(cmd.func(page, { keywords: 'x', limit: 5 })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('treats LinkedIn redirect away from search page as a CUL-flavoured CommandExecutionError', async () => {
+        const cmd = getRegistry().get('linkedin/people-search');
+        const page = makePage({ evaluateResult: { error: 'not on people search page', url: 'https://www.linkedin.com/' } });
+        await expect(cmd.func(page, { keywords: 'x', limit: 5 })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('treats LinkedIn auth-wall redirects as AuthRequiredError', async () => {
+        const cmd = getRegistry().get('linkedin/people-search');
+        const page = makePage({ evaluateResult: { error: 'not on people search page', url: 'https://www.linkedin.com/authwall?trk=people_search' } });
+        await expect(cmd.func(page, { keywords: 'x', limit: 5 })).rejects.toBeInstanceOf(AuthRequiredError);
+    });
+
+    it('wraps browser extraction exceptions as CommandExecutionError', async () => {
+        const cmd = getRegistry().get('linkedin/people-search');
+        const page = makePage({ evaluateReject: new SyntaxError('Unexpected token <') });
+        await expect(cmd.func(page, { keywords: 'x', limit: 5 })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('wraps browser navigation exceptions as CommandExecutionError', async () => {
+        const cmd = getRegistry().get('linkedin/people-search');
+        const page = makePage({ gotoReject: new Error('navigation failed') });
+        await expect(cmd.func(page, { keywords: 'x', limit: 5 })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('throws EmptyResultError when the page rendered zero rows', async () => {
+        const cmd = getRegistry().get('linkedin/people-search');
+        const page = makePage({ evaluateResult: extractionResult([]) });
+        await expect(cmd.func(page, { keywords: 'x', limit: 5 })).rejects.toBeInstanceOf(EmptyResultError);
+    });
+
+    it('treats profile candidates without stable parsed rows as parser drift', async () => {
+        const cmd = getRegistry().get('linkedin/people-search');
+        const page = makePage({
+            evaluateResult: extractionResult([], {
+                candidate_count: 1,
+                person_entries_count: 1,
+                resolved_count: 0,
+            }),
+        });
+        await expect(cmd.func(page, { keywords: 'x', limit: 5 })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('treats missing rows array as parser drift, not empty results', async () => {
+        const cmd = getRegistry().get('linkedin/people-search');
+        const page = makePage({ evaluateResult: {} });
+        await expect(cmd.func(page, { keywords: 'x', limit: 5 })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('rejects empty keywords with ArgumentError before navigation', async () => {
+        const cmd = getRegistry().get('linkedin/people-search');
+        const page = makePage({ evaluateResult: extractionResult([]) });
+        await expect(cmd.func(page, { keywords: '   ', limit: 5 })).rejects.toBeInstanceOf(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+
+    it('registers with the expected columns and arg shape', () => {
+        const cmd = getRegistry().get('linkedin/people-search');
+        expect(cmd?.columns).toEqual(['rank', 'name', 'headline', 'location', 'profile_url']);
+        expect(cmd?.access).toBe('read');
+        expect(cmd?.browser).toBe(true);
+        const keywordsArg = cmd?.args?.find((a) => a.name === 'keywords');
+        expect(keywordsArg?.positional).toBe(true);
+        expect(keywordsArg?.required).toBe(true);
+    });
+});

package/clis/linkedin/post-analytics.js

@@ -0,0 +1,74 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { parseLimit } from './shared.js';
+import { collectPosts } from './posts-core.js';
+
+const DEFAULT_LIMIT = 30;
+const MAX_LIMIT = 100;
+
+function sum(posts, field) {
+  return posts.reduce((total, post) => total + (Number(post[field]) || 0), 0);
+}
+
+function summarize(posts) {
+  if (!Array.isArray(posts)) {
+    throw new CommandExecutionError('LinkedIn post analytics expected an array of posts');
+  }
+  if (posts.length === 0) {
+    throw new EmptyResultError('linkedin post-analytics', 'No posts were available for analytics.');
+  }
+  const latest = posts[0] || {};
+  return {
+    posts_analyzed: posts.length,
+    total_reactions: sum(posts, 'reactions'),
+    total_comments: sum(posts, 'comments'),
+    total_reposts: sum(posts, 'reposts'),
+    total_impressions: sum(posts, 'impressions'),
+    posts_with_media: posts.filter((post) => post.media).length,
+    posts_with_urls: posts.filter((post) => post.url).length,
+    latest_posted_at: latest.posted_at || '',
+    latest_reactions: Number(latest.reactions) || 0,
+    latest_comments: Number(latest.comments) || 0,
+    latest_reposts: Number(latest.reposts) || 0,
+    latest_impressions: Number(latest.impressions) || 0,
+    latest_url: latest.url || '',
+  };
+}
+
+cli({
+  site: 'linkedin',
+  name: 'post-analytics',
+  access: 'read',
+  description: 'Summarize raw visible LinkedIn post counters without custom scoring or classification',
+  domain: 'www.linkedin.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    { name: 'profile-url', type: 'string', required: false, help: 'LinkedIn /in/<handle>/ profile URL. Defaults to /in/me/.' },
+    { name: 'limit', type: 'int', default: DEFAULT_LIMIT, help: 'Maximum posts to summarize (1-100)' },
+  ],
+  columns: [
+    'posts_analyzed',
+    'total_reactions',
+    'total_comments',
+    'total_reposts',
+    'total_impressions',
+    'posts_with_media',
+    'posts_with_urls',
+    'latest_posted_at',
+    'latest_reactions',
+    'latest_comments',
+    'latest_reposts',
+    'latest_impressions',
+    'latest_url',
+  ],
+  func: async (page, args) => {
+    const limit = parseLimit(args.limit, DEFAULT_LIMIT, MAX_LIMIT);
+    const posts = await collectPosts(page, { ...args, limit });
+    return [summarize(posts)];
+  },
+});
+
+export const __test__ = {
+  summarize,
+};

package/clis/linkedin/post-analytics.test.js

@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import './post-analytics.js';
+
+const { summarize } = await import('./post-analytics.js').then((m) => m.__test__);
+
+describe('linkedin post-analytics adapter', () => {
+  const command = getRegistry().get('linkedin/post-analytics');
+
+  it('registers command shape', () => {
+    expect(command).toBeDefined();
+    expect(command.strategy).toBe('cookie');
+    expect(command.browser).toBe(true);
+    expect(command.columns).toContain('total_reactions');
+    expect(command.columns).not.toContain('total_engagement_score');
+  });
+
+  it('summarizes raw counters without custom scoring', () => {
+    const out = summarize([
+      { body: 'Latest post', reactions: 10, comments: 3, reposts: 1, impressions: 50, media: 'image', url: 'u1', posted_at: '1d' },
+      { body: 'Older post', reactions: 2, comments: 0, reposts: 0, impressions: 20, media: '', url: '', posted_at: '2d' },
+    ]);
+    expect(out).toMatchObject({
+      posts_analyzed: 2,
+      total_reactions: 12,
+      total_comments: 3,
+      total_reposts: 1,
+      total_impressions: 70,
+      posts_with_media: 1,
+      posts_with_urls: 1,
+      latest_posted_at: '1d',
+      latest_url: 'u1',
+    });
+  });
+
+  it('rejects empty analytics input', () => {
+    expect(() => summarize([])).toThrow(EmptyResultError);
+  });
+});

package/clis/linkedin/posts-core.js

@@ -0,0 +1,241 @@
+import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import {
+  assertLinkedInAuthenticated,
+  assertSafeLinkedinUrl,
+  compactRepeatedText,
+  normalizeHttpUrl,
+  normalizeWhitespace,
+  parseLimit,
+  unwrapEvaluateResult,
+} from './shared.js';
+
+export const DEFAULT_POSTS_LIMIT = 20;
+export const MAX_POSTS_LIMIT = 100;
+
+export function activityUrl(profileUrl) {
+  const url = assertSafeLinkedinUrl(profileUrl || 'https://www.linkedin.com/in/me/', 'profile-url', '/in/me/');
+  const parsed = new URL(url);
+  if (!/^\/in\/[^/?#]+\/?$/.test(parsed.pathname)) {
+    throw new CommandExecutionError('linkedin posts requires a /in/<handle>/ profile URL');
+  }
+  return `https://www.linkedin.com${parsed.pathname.replace(/\/?$/, '/') }recent-activity/all/`;
+}
+
+export function parseMetric(value) {
+  const raw = normalizeWhitespace(value).toLowerCase().replace(/,/g, '');
+  const match = raw.match(/(\d+(?:\.\d+)?)(k|m)?/i);
+  if (!match) return 0;
+  const base = Number(match[1]);
+  if (match[2]?.toLowerCase() === 'k') return Math.round(base * 1000);
+  if (match[2]?.toLowerCase() === 'm') return Math.round(base * 1000000);
+  return Math.round(base);
+}
+
+export function parseReactionText(value) {
+  const text = normalizeWhitespace(value);
+  const explicit = text.match(/(\d[\d,.]*\s*(?:k|m)?\s+reactions?)/i);
+  if (explicit) return parseMetric(explicit[1]);
+  const namedOthers = text.match(/(?:^|\s)(\d[\d,.]*\s*(?:k|m)?)\s+[A-Z][^.!?\n]{0,100}\s+and\s+\d[\d,.]*\s+others/i);
+  if (namedOthers) return parseMetric(namedOthers[1]);
+  const beforeComments = text.match(/(?:^|\s)(\d[\d,.]*\s*(?:k|m)?)\s+(?:\d[\d,.]*\s+comments?|\d[\d,.]*\s+reposts?)/i);
+  if (beforeComments) return parseMetric(beforeComments[1]);
+  const trailingNumber = text.match(/(?:^|\s)(\d[\d,.]*\s*(?:k|m)?)\s*$/i);
+  return trailingNumber ? parseMetric(trailingNumber[1]) : 0;
+}
+
+export function normalizePost(row) {
+  if (!row || typeof row !== 'object') {
+    throw new CommandExecutionError('LinkedIn posts returned malformed row');
+  }
+  const body = normalizeWhitespace(row.body);
+  const url = normalizeHttpUrl(row.url);
+  if (!body && !url) throw new CommandExecutionError('LinkedIn posts returned a row without body or URL');
+  return {
+    author: compactRepeatedText(row.author),
+    posted_at: normalizeWhitespace(row.posted_at),
+    body,
+    reactions: Number(row.reactions) || 0,
+    comments: Number(row.comments) || 0,
+    reposts: Number(row.reposts) || 0,
+    impressions: Number(row.impressions) || 0,
+    media: normalizeWhitespace(row.media),
+    media_urls: normalizeWhitespace(row.media_urls)
+      .split(/\s*\|\s*/)
+      .map((url) => normalizeHttpUrl(url))
+      .filter(Boolean)
+      .join(' | '),
+    url,
+    raw_text: normalizeWhitespace(row.raw_text),
+  };
+}
+
+export function buildPostsScript() {
+  return String.raw`(() => {
+    const clean = (s) => String(s || '').replace(/[\u00a0\u202f]+/g, ' ').replace(/\s+/g, ' ').trim();
+    const parseMetric = (s) => {
+      const raw = clean(s).toLowerCase().replace(/,/g, '');
+      const m = raw.match(/(\d+(?:\.\d+)?)(k|m)?/i);
+      if (!m) return 0;
+      const n = Number(m[1]);
+      if ((m[2] || '').toLowerCase() === 'k') return Math.round(n * 1000);
+      if ((m[2] || '').toLowerCase() === 'm') return Math.round(n * 1000000);
+      return Math.round(n);
+    };
+    const parseReactionText = (value) => {
+      const text = clean(value);
+      const explicit = text.match(/(\d[\d,.]*\s*(?:k|m)?\s+reactions?)/i);
+      if (explicit) return parseMetric(explicit[1]);
+      const namedOthers = text.match(/(?:^|\s)(\d[\d,.]*\s*(?:k|m)?)\s+[A-Z][^.!?\n]{0,100}\s+and\s+\d[\d,.]*\s+others/i);
+      if (namedOthers) return parseMetric(namedOthers[1]);
+      const beforeComments = text.match(/(?:^|\s)(\d[\d,.]*\s*(?:k|m)?)\s+(?:\d[\d,.]*\s+comments?|\d[\d,.]*\s+reposts?)/i);
+      if (beforeComments) return parseMetric(beforeComments[1]);
+      const trailingNumber = text.match(/(?:^|\s)(\d[\d,.]*\s*(?:k|m)?)\s*$/i);
+      return trailingNumber ? parseMetric(trailingNumber[1]) : 0;
+    };
+    const expanders = Array.from(document.querySelectorAll('button, a'))
+      .filter((el) => /\b(see more|show more|more)\b|…more/i.test(clean(el.innerText || el.textContent || el.getAttribute('aria-label') || '')));
+    for (const expander of expanders.slice(0, 20)) {
+      try { expander.click(); } catch {}
+    }
+    const cards = Array.from(document.querySelectorAll('article, [role="article"], .feed-shared-update-v2, .occludable-update'))
+      .filter((card) => clean(card.innerText || card.textContent || '').length > 60);
+    const rows = [];
+    const seen = new Set();
+    const stopLine = (line) => /^(like|comment|repost|send|share|copy link|follow|following|connect|message|activate to view|promoted|show more|see more)$/i.test(line)
+      || /^\d[\d,.]*\s*(?:k|m)?\s+(?:reactions?|comments?|reposts?|shares?|impressions?)$/i.test(line)
+      || /^[A-Z][A-Za-z ]+\s+and\s+\d[\d,.]*\s+others$/i.test(line);
+    const readBody = (root, lines) => {
+      const selectors = [
+        '.feed-shared-update-v2__description',
+        '.update-components-text',
+        '.feed-shared-text',
+        '[data-test-id*="main-feed-activity-card"] [dir="ltr"]',
+        '[class*="update-components-text"]'
+      ];
+      for (const selector of selectors) {
+        const node = root.querySelector(selector);
+        const value = clean(node?.innerText || node?.textContent || '');
+        if (value && value.length > 8) return value.replace(/…more$/i, '').trim();
+      }
+      const timestampIndex = lines.findIndex((line) => /^\d+\s*(?:s|m|h|d|w|mo|yr|min)\b/i.test(line));
+      const start = timestampIndex >= 0 ? timestampIndex + 1 : Math.min(3, lines.length);
+      const body = [];
+      for (const line of lines.slice(start)) {
+        if (stopLine(line)) break;
+        if (/^(visible to anyone|edited|author|view .* profile)$/i.test(line)) continue;
+        body.push(line);
+      }
+      return clean(body.join(' ')).replace(/…more$/i, '').trim();
+    };
+    const readMedia = (root) => {
+      const media = [];
+      const mediaUrls = [];
+      const isDecorativeImageUrl = (src) => /profile-displayphoto|profile-framedphoto|company-logo|emoji|reaction|ghost-person|100_100/i.test(src || '');
+      const safeHttpUrl = (value) => {
+        try {
+          const parsed = new URL(value, location.origin);
+          if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') return '';
+          if (parsed.username || parsed.password) return '';
+          return parsed.toString();
+        } catch {
+          return '';
+        }
+      };
+      const images = Array.from(root.querySelectorAll('img[alt]'))
+        .map((img) => ({ alt: clean(img.getAttribute('alt')), src: img.currentSrc || img.src || '' }))
+        .filter((img) => img.alt
+          && !/profile|photo of|emoji|reaction|^like$|^love$|^celebrate$|^support$|^funny$|^insightful$|^curious$/i.test(img.alt));
+      for (const image of images) {
+        media.push('image: ' + image.alt);
+        const imageUrl = safeHttpUrl(image.src);
+        if (imageUrl && !isDecorativeImageUrl(imageUrl)) mediaUrls.push(imageUrl);
+      }
+      const videos = Array.from(root.querySelectorAll('video'));
+      for (const video of videos) {
+        media.push('video');
+        const src = video.currentSrc || video.src || video.querySelector('source')?.src || '';
+        const videoUrl = safeHttpUrl(src);
+        if (videoUrl) mediaUrls.push(videoUrl);
+      }
+      const externalLinks = Array.from(root.querySelectorAll('a[href]'))
+        .map((link) => ({ href: link.href, label: clean(link.innerText || link.textContent || '') }))
+        .map((link) => ({ ...link, href: safeHttpUrl(link.href) }))
+        .filter((link) => link.href && !/linkedin\.com/.test(link.href))
+        .slice(0, 5);
+      for (const link of externalLinks) {
+        media.push(clean('link: ' + (link.label || link.href) + ' ' + link.href));
+        mediaUrls.push(link.href);
+      }
+      return {
+        labels: Array.from(new Set(media)).join(' | '),
+        urls: Array.from(new Set(mediaUrls)).join(' | '),
+      };
+    };
+    for (const card of cards) {
+      const root = card.closest('article, [role="article"], .feed-shared-update-v2, .occludable-update') || card;
+      if (!root || seen.has(root)) continue;
+      seen.add(root);
+      const rawFullText = String(root.innerText || root.textContent || '');
+      const rawText = clean(rawFullText);
+      if (!rawText || rawText.length < 20) continue;
+      const permalink = root.querySelector('a[href*="/feed/update/"], a[href*="/posts/"], a[href*="/pulse/"]');
+      const url = permalink?.href ? new URL(permalink.href, location.origin).toString() : '';
+      const authorLink = root.querySelector('a[href*="/in/"], a[href*="/company/"]');
+      const lines = rawFullText.split(/\n+/).map(clean).filter(Boolean);
+      const author = clean(authorLink?.innerText || authorLink?.textContent || '')
+        || lines.find((line) => line && !/^feed post/i.test(line) && !/verified|you|senior|engineer|developer/i.test(line)) || '';
+      const timestamp = (rawText.match(/\b\d+\s*(?:s|m|h|d|w|mo|yr|min)\b/i) || [''])[0];
+      const reactions = parseReactionText(rawText);
+      const comments = parseMetric((rawText.match(/(\d[\d,.]*\s*(?:k|m)?\s+comments?)/i) || [''])[0]);
+      const reposts = parseMetric((rawText.match(/(\d[\d,.]*\s*(?:k|m)?\s+reposts?)/i) || [''])[0]);
+      const impressions = parseMetric((rawText.match(/(\d[\d,.]*\s*(?:k|m)?\s+impressions?)/i) || [''])[0]);
+      const body = readBody(root, lines);
+      const mediaData = readMedia(root);
+      if (!body && !url) continue;
+      rows.push({
+        author,
+        posted_at: timestamp,
+        body,
+        reactions,
+        comments,
+        reposts,
+        impressions,
+        media: mediaData.labels,
+        media_urls: mediaData.urls,
+        url,
+        raw_text: rawText,
+      });
+    }
+    return { rows, url: location.href, title: document.title || '' };
+  })()`;
+}
+
+export async function collectPosts(page, args) {
+  if (!page) throw new CommandExecutionError('Browser session required for linkedin posts');
+  const limit = parseLimit(args.limit, DEFAULT_POSTS_LIMIT, MAX_POSTS_LIMIT);
+  await page.goto(activityUrl(args['profile-url']));
+  await page.wait(5);
+  await assertLinkedInAuthenticated(page, 'LinkedIn posts');
+  let rows = [];
+  for (let i = 0; i < 6 && rows.length < limit; i++) {
+    const payload = unwrapEvaluateResult(await page.evaluate(buildPostsScript()));
+    if (!payload || !Array.isArray(payload.rows)) {
+      throw new CommandExecutionError('LinkedIn posts returned malformed extraction payload');
+    }
+    rows = rows.concat(payload.rows.map(normalizePost));
+    const seen = new Set();
+    rows = rows.filter((row) => {
+      const key = row.url || `${row.author}::${row.posted_at}::${row.body.slice(0, 80)}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+    if (rows.length >= limit) break;
+    await page.autoScroll({ times: 1, delayMs: 900 });
+    await page.wait(1);
+  }
+  if (rows.length === 0) {
+    throw new EmptyResultError('linkedin posts', 'No visible posts were found on the LinkedIn activity page.');
+  }
+  return rows.slice(0, limit).map((row, index) => ({ rank: index + 1, ...row }));
+}

package/clis/linkedin/posts.js

@@ -0,0 +1,22 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import {
+  collectPosts,
+  DEFAULT_POSTS_LIMIT,
+  MAX_POSTS_LIMIT,
+} from './posts-core.js';
+
+cli({
+  site: 'linkedin',
+  name: 'posts',
+  access: 'read',
+  description: 'Export visible posts from a LinkedIn profile activity page with engagement metrics',
+  domain: 'www.linkedin.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    { name: 'profile-url', type: 'string', required: false, help: 'LinkedIn /in/<handle>/ profile URL. Defaults to /in/me/.' },
+    { name: 'limit', type: 'int', default: DEFAULT_POSTS_LIMIT, help: `Maximum posts to return (1-${MAX_POSTS_LIMIT})` },
+  ],
+  columns: ['rank', 'author', 'posted_at', 'body', 'reactions', 'comments', 'reposts', 'impressions', 'media', 'media_urls', 'url', 'raw_text'],
+  func: async (page, args) => collectPosts(page, args),
+});

package/clis/linkedin/posts.test.js

@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import './posts.js';
+
+const { activityUrl, parseMetric, parseReactionText, normalizePost } = await import('./posts-core.js');
+
+describe('linkedin posts adapter', () => {
+  const command = getRegistry().get('linkedin/posts');
+
+  it('registers command shape', () => {
+    expect(command).toBeDefined();
+    expect(command.strategy).toBe('cookie');
+    expect(command.browser).toBe(true);
+    expect(command.columns).toContain('reactions');
+    expect(command.columns).toContain('media_urls');
+    expect(command.columns).toContain('raw_text');
+  });
+
+  it('builds profile activity URL', () => {
+    expect(activityUrl('https://www.linkedin.com/in/gauravsaxena1997/')).toBe('https://www.linkedin.com/in/gauravsaxena1997/recent-activity/all/');
+  });
+
+  it('parses compact metrics', () => {
+    expect(parseMetric('1,200 reactions')).toBe(1200);
+    expect(parseMetric('2.5k comments')).toBe(2500);
+    expect(parseReactionText('19 Divyang Bhargava and 18 others 12 comments')).toBe(19);
+    expect(parseReactionText('32 5 comments')).toBe(32);
+  });
+
+  it('normalizes post rows and rejects identity-free rows', () => {
+    expect(() => normalizePost({ text: '', url: '' })).toThrow(CommandExecutionError);
+    expect(normalizePost({ author: 'AliceAlice', body: 'Post body', reactions: '3', impressions: '12', media: 'image: demo', media_urls: 'https://example.com/a.png' }))
+      .toMatchObject({ author: 'Alice', body: 'Post body', reactions: 3, impressions: 12, media: 'image: demo', media_urls: 'https://example.com/a.png' });
+    expect(normalizePost({ body: 'Post body', media_urls: 'javascript:alert(1) | https://example.com/a.png' }))
+      .toMatchObject({ media_urls: 'https://example.com/a.png' });
+    expect(normalizePost({ body: 'Post body', url: 'javascript:alert(1)' }))
+      .toMatchObject({ url: '' });
+  });
+});