@jackwener/opencli 1.8.0 → 1.8.1

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: '' });
+  });
+});

package/clis/linkedin/profile-analytics.js

@@ -0,0 +1,104 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import {
+  assertLinkedInAuthenticated,
+  assertSafeLinkedinUrl,
+  normalizeWhitespace,
+  unwrapEvaluateResult,
+} from './shared.js';
+
+function normalizeProfileAnalyticsUrl(value) {
+  const url = assertSafeLinkedinUrl(value || 'https://www.linkedin.com/in/me/', 'profile-url', '/in/me/');
+  const parsed = new URL(url);
+  if (!/^\/in\/[^/?#]+\/?$/.test(parsed.pathname)) {
+    throw new CommandExecutionError('LinkedIn profile-analytics requires a /in/<handle>/ profile URL');
+  }
+  return parsed.toString();
+}
+
+function parseMetric(value) {
+  const raw = normalizeWhitespace(value).toLowerCase().replace(/,/g, '');
+  const match = raw.match(/(\d+(?:\.\d+)?)(k|m)?/i);
+  if (!match) return '';
+  const base = Number(match[1]);
+  if (match[2]?.toLowerCase() === 'k') return String(Math.round(base * 1000));
+  if (match[2]?.toLowerCase() === 'm') return String(Math.round(base * 1000000));
+  return String(Math.round(base));
+}
+
+function firstMetric(text, patterns) {
+  for (const pattern of patterns) {
+    const match = normalizeWhitespace(text).match(pattern);
+    if (match) return parseMetric(match[1]);
+  }
+  return '';
+}
+
+function parseDashboardMetrics(text) {
+  const normalized = normalizeWhitespace(text);
+  return {
+    profile_views: firstMetric(normalized, [/(\d[\d,.]*\s*(?:k|m)?)\s+profile views?/i, /profile views?\s+(\d[\d,.]*\s*(?:k|m)?)/i]),
+    post_impressions: firstMetric(normalized, [/(\d[\d,.]*\s*(?:k|m)?)\s+post impressions?/i, /post impressions?\s+(\d[\d,.]*\s*(?:k|m)?)/i]),
+    search_appearances: firstMetric(normalized, [/(\d[\d,.]*\s*(?:k|m)?)\s+search appearances?/i, /search appearances?\s+(\d[\d,.]*\s*(?:k|m)?)/i]),
+    followers: firstMetric(normalized, [/(\d[\d,.]*\s*(?:k|m)?)\s+followers?/i]),
+    connections: firstMetric(normalized, [/(\d[\d,.]*\s*(?:k|m)?)\s+connections?/i]),
+  };
+}
+
+function buildProfileAnalyticsScript() {
+  return String.raw`(() => {
+    const clean = (s) => String(s || '').replace(/[\u00a0\u202f]+/g, ' ').replace(/\s+/g, ' ').trim();
+    const text = clean(document.body?.innerText || document.body?.textContent || '');
+    const matches = [
+      ...text.matchAll(/\d[\d,.]*\s*(?:k|m)?\s+(?:profile views?|post impressions?|search appearances?|followers?|connections?)/gi),
+    ].map((match) => clean(match[0]));
+    return {
+      profile_url: window.location.href,
+      raw_analytics: matches.join(' | '),
+    };
+  })()`;
+}
+
+function normalizeAnalytics(row) {
+  if (!row || typeof row !== 'object') {
+    throw new CommandExecutionError('LinkedIn profile-analytics returned malformed extraction payload');
+  }
+  const metrics = parseDashboardMetrics(row.raw_analytics);
+  if (!Object.values(metrics).some(Boolean)) {
+    throw new EmptyResultError('linkedin profile-analytics', 'No visible LinkedIn profile analytics counters were found.');
+  }
+  return {
+    profile_url: normalizeWhitespace(row.profile_url),
+    ...metrics,
+    raw_analytics: normalizeWhitespace(row.raw_analytics),
+  };
+}
+
+cli({
+  site: 'linkedin',
+  name: 'profile-analytics',
+  access: 'read',
+  description: 'Read visible LinkedIn profile dashboard metrics such as profile views, post impressions, and search appearances',
+  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/.' },
+  ],
+  columns: ['profile_url', 'profile_views', 'post_impressions', 'search_appearances', 'followers', 'connections', 'raw_analytics'],
+  func: async (page, args) => {
+    if (!page) throw new CommandExecutionError('Browser session required for linkedin profile-analytics');
+    await page.goto(normalizeProfileAnalyticsUrl(args['profile-url']));
+    await page.wait(5);
+    await assertLinkedInAuthenticated(page, 'LinkedIn profile-analytics');
+    const row = unwrapEvaluateResult(await page.evaluate(buildProfileAnalyticsScript()));
+    return [normalizeAnalytics(row)];
+  },
+});
+
+export const __test__ = {
+  normalizeProfileAnalyticsUrl,
+  parseMetric,
+  parseDashboardMetrics,
+  normalizeAnalytics,
+};

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

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import './profile-analytics.js';
+
+const {
+  normalizeProfileAnalyticsUrl,
+  parseMetric,
+  parseDashboardMetrics,
+  normalizeAnalytics,
+} = await import('./profile-analytics.js').then((m) => m.__test__);
+
+describe('linkedin profile-analytics adapter', () => {
+  const command = getRegistry().get('linkedin/profile-analytics');
+
+  it('registers command shape', () => {
+    expect(command).toBeDefined();
+    expect(command.strategy).toBe('cookie');
+    expect(command.browser).toBe(true);
+    expect(command.columns).toEqual([
+      'profile_url',
+      'profile_views',
+      'post_impressions',
+      'search_appearances',
+      'followers',
+      'connections',
+      'raw_analytics',
+    ]);
+  });
+
+  it('normalizes profile url default and explicit /in URL', () => {
+    expect(normalizeProfileAnalyticsUrl(undefined)).toBe('https://www.linkedin.com/in/me/');
+    expect(normalizeProfileAnalyticsUrl('https://www.linkedin.com/in/gauravsaxena1997/')).toBe('https://www.linkedin.com/in/gauravsaxena1997/');
+  });
+
+  it('rejects non-profile URLs', () => {
+    expect(() => normalizeProfileAnalyticsUrl('https://www.linkedin.com/jobs/')).toThrow(CommandExecutionError);
+  });
+
+  it('parses compact dashboard metrics', () => {
+    expect(parseMetric('1.2K')).toBe('1200');
+    expect(parseDashboardMetrics('31 post impressions 23 search appearances 32 profile views 1,234 followers 500 connections'))
+      .toEqual({
+        profile_views: '32',
+        post_impressions: '31',
+        search_appearances: '23',
+        followers: '1234',
+        connections: '500',
+      });
+  });
+
+  it('normalizes browser payload into columns', () => {
+    expect(normalizeAnalytics({
+      profile_url: 'https://www.linkedin.com/in/me/',
+      raw_analytics: '31 post impressions | 23 search appearances | 32 profile views',
+    })).toMatchObject({
+      profile_views: '32',
+      post_impressions: '31',
+      search_appearances: '23',
+    });
+  });
+
+  it('does not emit an all-empty analytics row', () => {
+    expect(() => normalizeAnalytics({ profile_url: 'https://www.linkedin.com/in/me/', raw_analytics: '' }))
+      .toThrow(EmptyResultError);
+  });
+});