@jackwener/opencli 1.7.21 → 1.8.0

package/clis/linkedin/salesnav-thread.test.js

@@ -0,0 +1,79 @@
+import { describe, expect, it } from 'vitest';
+import { ArgumentError, CommandExecutionError } from '@jackwener/opencli/errors';
+import './salesnav-thread.js';
+
+const {
+  parseThreadInput,
+  threadApiUrl,
+  parseSalesnavThreadMessages,
+  threadMatchesInput,
+  salesnavThreadUrl,
+} = await import('./salesnav-thread.js').then((m) => m.__test__);
+
+describe('linkedin salesnav-thread command', () => {
+  it('accepts Sales Navigator inbox URLs, raw thread ids, lead URLs, urns, and names', () => {
+    expect(parseThreadInput('https://www.linkedin.com/sales/inbox/2-abc%3D%3D')).toEqual(['thread_id', '2-abc==']);
+    expect(parseThreadInput('2-abc==')).toEqual(['thread_id', '2-abc==']);
+    expect(parseThreadInput('https://www.linkedin.com/sales/lead/P1,NAME_SEARCH,T1')).toEqual(['recipient_urn', 'urn:li:fs_salesProfile:(P1,NAME_SEARCH,T1)']);
+    expect(parseThreadInput('urn:li:fs_salesProfile:(P1,NAME_SEARCH,T1)')).toEqual(['recipient_urn', 'urn:li:fs_salesProfile:(P1,NAME_SEARCH,T1)']);
+    expect(parseThreadInput('Rachael Stolberg')).toEqual(['name', 'rachael stolberg']);
+    expect(() => parseThreadInput('urn:li:fs_salesProfile:(P1,undefined,T1)')).toThrow(ArgumentError);
+    expect(() => parseThreadInput('https://www.linkedin.com/sales/lead/P1,undefined,T1')).toThrow(ArgumentError);
+  });
+
+  it('builds the decorated thread API URL with encoded parentheses and message pagination size', () => {
+    const url = threadApiUrl('2-thread==', 40);
+    expect(url).toContain('/sales-api/salesApiMessagingThreads/2-thread%3D%3D?');
+    expect(url).toContain('messageCount=40');
+    expect(url).toContain('count=1');
+    expect(url).toContain('decoration=%28');
+    expect(url).not.toContain('decoration=(');
+  });
+
+  it('parses thread messages in chronological order with sender names and timestamps', () => {
+    const rows = parseSalesnavThreadMessages({
+      id: '2-thread',
+      participants: [
+        'urn:li:fs_salesProfile:(OTHER,NAME_SEARCH,T1)',
+        'urn:li:fs_salesProfile:(SELF,NAME_SEARCH,T2)',
+      ],
+      participantsResolutionResults: {
+        'urn:li:fs_salesProfile:(OTHER,NAME_SEARCH,T1)': { fullName: 'Rachael Stolberg', entityUrn: 'urn:li:fs_salesProfile:(OTHER,NAME_SEARCH,T1)' },
+        'urn:li:fs_salesProfile:(SELF,NAME_SEARCH,T2)': { fullName: 'Hanzi Li', entityUrn: 'urn:li:fs_salesProfile:(SELF,NAME_SEARCH,T2)' },
+      },
+      messages: [
+        { id: 'm2', author: 'urn:li:fs_salesProfile:(OTHER,NAME_SEARCH,T1)', body: 'Happy to chat', deliveredAt: 1778206803669, type: 'MEMBER_TO_MEMBER' },
+        { id: 'm1', author: 'urn:li:fs_salesProfile:(SELF,NAME_SEARCH,T2)', subject: 'Quick question', body: 'Hi Rachael', deliveredAt: 1777188013523, type: 'INMAIL' },
+      ],
+    });
+    expect(rows).toHaveLength(2);
+    expect(rows[0]).toMatchObject({
+      index: 0,
+      message_id: 'm1',
+      thread_id: '2-thread',
+      sender: 'Hanzi Li',
+      subject: 'Quick question',
+      text: 'Hi Rachael',
+      timestamp: '2026-04-26T07:20:13.523Z',
+    });
+    expect(rows[1]).toMatchObject({ index: 1, message_id: 'm2', sender: 'Rachael Stolberg', text: 'Happy to chat' });
+  });
+
+  it('fails typed on malformed thread message payloads', () => {
+    expect(() => parseSalesnavThreadMessages({ messages: [] })).toThrow(CommandExecutionError);
+    expect(() => parseSalesnavThreadMessages({ id: '2-thread' })).toThrow(CommandExecutionError);
+    expect(() => parseSalesnavThreadMessages({ id: '2-thread', messages: [null] })).toThrow(CommandExecutionError);
+  });
+
+  it('matches recipient identifiers against inbox rows', () => {
+    const row = {
+      thread_id: '2-thread',
+      person_name: 'Rachael Stolberg',
+      participants: [{ name: 'Rachael Stolberg', entity_urn: 'urn:li:fs_salesProfile:(P1,NAME_SEARCH,T1)' }],
+    };
+    expect(threadMatchesInput(row, ['thread_id', '2-thread'])).toBe(true);
+    expect(threadMatchesInput(row, ['recipient_urn', 'urn:li:fs_salesProfile:(P1,NAME_SEARCH,T1)'])).toBe(true);
+    expect(threadMatchesInput(row, ['name', 'rachael stolberg'])).toBe(true);
+    expect(salesnavThreadUrl('2-thread')).toBe('https://www.linkedin.com/sales/inbox/2-thread');
+  });
+});

package/clis/linkedin/sent-invitations.js

@@ -0,0 +1,92 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+
+const LINKEDIN_DOMAIN = 'www.linkedin.com';
+const SENT_URL = 'https://www.linkedin.com/mynetwork/invitation-manager/sent/';
+
+function unwrapEvaluateResult(payload) {
+  if (payload && typeof payload === 'object' && 'data' in payload && 'session' in payload) return payload.data;
+  return payload;
+}
+
+function buildSentInvitationsScript() {
+  return String.raw`(() => {
+    const clean = (s) => String(s || '').replace(/[  ]/g, ' ').replace(/\s+/g, ' ').trim();
+    const text = document.body ? (document.body.innerText || '') : '';
+    const href = location.href;
+    const authRequired = /\b(sign in|log in|join linkedin)\b/i.test(text)
+      || /linkedin\.com\/(login|checkpoint|authwall|uas)/i.test(href);
+    const warning = /captcha|verification required|unusual activity|account restricted|temporarily restricted|security check|checkpoint/i.test(text);
+    const cleanName = (value) => {
+      const first = String(value || '').split(/\n+/).map(clean).filter(Boolean)[0] || '';
+      return clean(first
+        .replace(/^(view\s+)?profile\s+of\s+/i, '')
+        .replace(/\s*(?:View profile|LinkedIn|Pending|Sent|Withdraw).*$/i, ''));
+    };
+    const cards = Array.from(document.querySelectorAll('li, div, section, article')).filter((el) => {
+      if (!el || el.offsetParent === null) return false;
+      const t = clean(el.innerText || el.textContent || '');
+      return t && /withdraw/i.test(t) && t.length < 1200;
+    });
+    const byName = new Map();
+    for (const card of cards) {
+      const raw = card.innerText || card.textContent || '';
+      if (!/withdraw/i.test(raw)) continue;
+      const lines = raw.split(/\n+/).map(clean).filter(Boolean);
+      const link = card.querySelector('a[href*="/in/"]');
+      const linkName = cleanName(link ? (link.innerText || link.textContent || link.getAttribute('aria-label') || '') : '');
+      const name = linkName
+        || cleanName(lines.find((line) => !/^(pending|sent|withdraw|message|view profile|invitation|invited|ago|manage|received)\b/i.test(line)) || '');
+      if (!name) continue;
+      const hrefAttr = link ? (link.getAttribute('href') || '') : '';
+      const profile_url = hrefAttr ? new URL(hrefAttr, location.origin).toString().replace(/[?#].*$/, '') : '';
+      const invited_date_text = clean((raw.match(/(?:Sent|Invited)\s+(?:\d+\s+\w+\s+ago|yesterday|today)/i) || [''])[0]);
+      const key = name.toLowerCase();
+      const existing = byName.get(key);
+      if (!existing) {
+        byName.set(key, { name, profile_url, invited_date_text });
+      } else {
+        if (!existing.profile_url && profile_url) existing.profile_url = profile_url;
+        if (!existing.invited_date_text && invited_date_text) existing.invited_date_text = invited_date_text;
+      }
+    }
+    const rows = Array.from(byName.values());
+    return { url: href, title: document.title || '', authRequired, warning, count: rows.length, rows, bodyText: text.slice(0, 1000) };
+  })()`;
+}
+
+cli({
+  site: 'linkedin',
+  name: 'sent-invitations',
+  access: 'read',
+  description: 'List pending LinkedIn sent invitations for CRM reconciliation',
+  domain: LINKEDIN_DOMAIN,
+  strategy: Strategy.UI,
+  browser: true,
+  args: [],
+  columns: ['rank', 'name', 'profile_url', 'invited_date_text'],
+  func: async (page) => {
+    if (!page) throw new CommandExecutionError('Browser session required for linkedin sent-invitations');
+    await page.goto(SENT_URL);
+    await page.wait(12);
+    let result = unwrapEvaluateResult(await page.evaluate(buildSentInvitationsScript()));
+    if (result?.authRequired) {
+      throw new AuthRequiredError(LINKEDIN_DOMAIN, 'LinkedIn sent invitations requires an active signed-in browser session.');
+    }
+    if (result?.warning) {
+      throw new CommandExecutionError('LinkedIn warning/restriction state visible on sent invitations page.');
+    }
+    const rows = Array.isArray(result?.rows) ? result.rows : [];
+    return rows.map((row, index) => ({
+      rank: index + 1,
+      name: row.name || '',
+      profile_url: row.profile_url || '',
+      invited_date_text: row.invited_date_text || '',
+    }));
+  },
+});
+
+export const __test__ = {
+  buildSentInvitationsScript,
+  unwrapEvaluateResult,
+};

package/clis/linkedin/sent-invitations.test.js

@@ -0,0 +1,62 @@
+import { describe, expect, it } from 'vitest';
+import { JSDOM } from 'jsdom';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './sent-invitations.js';
+
+const { buildSentInvitationsScript } = await import('./sent-invitations.js').then((m) => m.__test__);
+
+describe('linkedin sent-invitations command', () => {
+  it('registers with structured columns that do not include raw blobs', () => {
+    const command = getRegistry().get('linkedin/sent-invitations');
+    expect(command).toBeDefined();
+    expect(command.access).toBe('read');
+    expect(command.columns).toEqual(['rank', 'name', 'profile_url', 'invited_date_text']);
+  });
+
+  it('extracts clean names and dedupes invitation cards by profile url', () => {
+    const dom = new JSDOM(`<!doctype html><body>
+      <ul>
+        <li>
+          <a href="/in/olga-magere/?miniProfileUrn=x"><span>Olga Magere</span></a>
+          <span>Pending</span><button>Withdraw</button><span>Sent 2 weeks ago</span>
+        </li>
+        <li>
+          <a href="/in/olga-magere/?trk=dup"><span>Olga Magere</span></a>
+          <span>Pending</span><button>Withdraw</button><span>Sent 2 weeks ago</span>
+        </li>
+        <li>
+          <div>Sam Founder\nSent yesterday\nWithdraw</div>
+        </li>
+      </ul>
+    </body>`, { url: 'https://www.linkedin.com/mynetwork/invitation-manager/sent/' });
+    const previousWindow = globalThis.window;
+    const previousDocument = globalThis.document;
+    const previousLocation = globalThis.location;
+    try {
+      globalThis.window = dom.window;
+      globalThis.document = dom.window.document;
+      globalThis.location = dom.window.location;
+      globalThis.getComputedStyle = dom.window.getComputedStyle;
+      Object.defineProperty(dom.window.HTMLElement.prototype, 'offsetParent', { get() { return dom.window.document.body; }, configurable: true });
+      const run = Function(`return ${buildSentInvitationsScript()}`);
+      const result = run();
+      expect(result.rows).toEqual([
+        {
+          name: 'Olga Magere',
+          profile_url: 'https://www.linkedin.com/in/olga-magere/',
+          invited_date_text: 'Sent 2 weeks ago',
+        },
+        {
+          name: 'Sam Founder',
+          profile_url: '',
+          invited_date_text: 'Sent yesterday',
+        },
+      ]);
+      expect(result.rows[0]).not.toHaveProperty('raw');
+    } finally {
+      globalThis.window = previousWindow;
+      globalThis.document = previousDocument;
+      globalThis.location = previousLocation;
+    }
+  });
+});

package/clis/linkedin/thread-snapshot.js

@@ -0,0 +1,214 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+
+const LINKEDIN_DOMAIN = 'www.linkedin.com';
+
+function normalizeWhitespace(value) {
+  return String(value ?? '').replace(/[\u00a0\u202f]/g, ' ').replace(/\s+/g, ' ').trim();
+}
+
+function unwrapEvaluateResult(payload) {
+  if (payload && typeof payload === 'object' && 'data' in payload && 'session' in payload) return payload.data;
+  return payload;
+}
+
+function isLinkedInHost(hostname) {
+  const host = String(hostname || '').toLowerCase();
+  return host === 'linkedin.com' || host.endsWith('.linkedin.com');
+}
+
+function canonicalizeLinkedInThreadUrl(value) {
+  const raw = normalizeWhitespace(value);
+  if (!raw) return '';
+  try {
+    const url = new URL(raw);
+    if (url.protocol !== 'https:' || url.username || url.password || url.port || !isLinkedInHost(url.hostname)) return '';
+    const match = url.pathname.match(/^\/messaging\/thread\/([^/]+)\/?$/i);
+    if (!match || !match[1]) return '';
+    url.hostname = 'www.linkedin.com';
+    url.hash = '';
+    url.search = '';
+    if (!url.pathname.endsWith('/')) url.pathname += '/';
+    return url.toString();
+  } catch {
+    return '';
+  }
+}
+
+function requireStringArg(args, key, label = key) {
+  const value = normalizeWhitespace(args[key]);
+  if (!value) throw new ArgumentError(`${label} is required`);
+  return value;
+}
+
+function requireLinkedInThreadUrl(value, label) {
+  const url = canonicalizeLinkedInThreadUrl(value);
+  if (!url) throw new ArgumentError(`${label} must be an exact https://www.linkedin.com/messaging/thread/<id>/ URL`);
+  return url;
+}
+
+function parseMaxScrolls(value) {
+  if (value === undefined || value === null || value === '') return 30;
+  const scrolls = Number(value);
+  if (!Number.isInteger(scrolls) || scrolls < 0 || scrolls > 80) {
+    throw new ArgumentError('--max-scrolls must be an integer between 0 and 80');
+  }
+  return scrolls;
+}
+
+function buildThreadSnapshotScript(maxScrolls) {
+  const scrolls = maxScrolls;
+  return String.raw`(async () => {
+    const marker = '__OPENCLI_LINKEDIN_THREAD_SNAPSHOT__';
+    void marker;
+    const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    const clean = (s) => String(s || '').replace(/[\u00a0\u202f]/g, ' ').replace(/\s+/g, ' ').trim();
+    const text = document.body ? (document.body.innerText || '') : '';
+    const authRequired = /\b(sign in|log in|join linkedin)\b/i.test(text)
+      || /linkedin\.com\/(login|checkpoint|authwall)/i.test(location.href)
+      || /captcha|verification required/i.test(text);
+
+    const selectors = [
+      '.msg-s-message-list',
+      '.msg-s-message-list-scrollable',
+      '.msg-thread',
+      'main [role="main"]',
+      'main'
+    ];
+    let scroller = null;
+    for (const selector of selectors) {
+      const el = document.querySelector(selector);
+      if (el && (el.scrollHeight > el.clientHeight || selector === 'main')) { scroller = el; break; }
+    }
+    scroller = scroller || document.scrollingElement || document.documentElement;
+    let previousHeight = -1;
+    let stable = 0;
+    for (let i = 0; i < ${scrolls}; i += 1) {
+      scroller.scrollTop = 0;
+      window.scrollTo(0, 0);
+      await sleep(750);
+      const height = scroller.scrollHeight || document.body.scrollHeight || 0;
+      if (height === previousHeight) stable += 1; else stable = 0;
+      previousHeight = height;
+      if (stable >= 3) break;
+    }
+    await sleep(1000);
+
+    const headerCandidates = [];
+    const headerSelectors = [
+      '.msg-thread__link-to-profile',
+      '.msg-thread__link-to-profile span[aria-hidden="true"]',
+      '.msg-entity-lockup__entity-title',
+      '.msg-conversation-card__participant-names',
+      'main h1',
+      'main h2',
+      '[data-anonymize="person-name"]',
+      'a[href*="/in/"] span[aria-hidden="true"]',
+      'a[href*="/in/"]'
+    ];
+    for (const selector of headerSelectors) {
+      for (const el of Array.from(document.querySelectorAll(selector)).slice(0, 8)) {
+        const value = clean(el.innerText || el.textContent || el.getAttribute('aria-label'));
+        if (value && value.length <= 120 && !/^(message|messaging|send|profile|view profile)$/i.test(value)) {
+          headerCandidates.push(value);
+        }
+      }
+    }
+
+    const seen = new Set();
+    const messages = [];
+    const nodes = Array.from(document.querySelectorAll('.msg-s-message-list__event, .msg-s-event-listitem, [data-event-urn], .msg-s-message-list-content'));
+    for (const [nodeIndex, el] of nodes.entries()) {
+      const raw = clean(el.innerText || el.textContent);
+      if (!raw || seen.has(raw)) continue;
+      seen.add(raw);
+      const lines = raw.split(/\n+/).map(clean).filter(Boolean);
+      const speaker = lines.length > 1 && lines[0].length <= 120 ? lines[0] : '';
+      messages.push({ index: messages.length, nodeIndex, speaker, text: raw });
+    }
+
+    const refreshedText = document.body ? (document.body.innerText || '') : '';
+    const fallbackLines = refreshedText.split(/\n+/).map(clean).filter(Boolean);
+    const latestMessageText = messages.length
+      ? messages[messages.length - 1].text
+      : ([...fallbackLines].reverse().find((line) => !/^(send|reply|write a message|press enter to send)$/i.test(line)) || '');
+
+    return {
+      url: location.href,
+      title: document.title || '',
+      headerNames: Array.from(new Set(headerCandidates)).slice(0, 10),
+      bodyText: refreshedText,
+      latestMessageText,
+      messages,
+      messageCount: messages.length,
+      authRequired,
+      extractedAt: new Date().toISOString(),
+      maxScrolls: ${scrolls}
+    };
+  })()`;
+}
+
+cli({
+  site: 'linkedin',
+  name: 'thread-snapshot',
+  access: 'read',
+  description: 'Load a LinkedIn messaging thread, scroll for available history, and return a full context snapshot',
+  domain: LINKEDIN_DOMAIN,
+  strategy: Strategy.UI,
+  browser: true,
+  args: [
+    { name: 'thread-url', required: true, help: 'Exact LinkedIn messaging thread URL to open and snapshot' },
+    { name: 'max-scrolls', type: 'number', default: 30, help: 'Maximum upward scroll attempts to load older messages' },
+    { name: 'json', type: 'bool', default: false, help: 'Return only JSON snapshot string in the snapshot_json field' },
+  ],
+  columns: ['thread_url', 'recipient', 'message_count', 'latest_text', 'snapshot_json'],
+  func: async (page, args) => {
+    if (!page) throw new CommandExecutionError('Browser session required for linkedin thread-snapshot');
+    const threadUrl = requireLinkedInThreadUrl(requireStringArg(args, 'thread-url', '--thread-url'), '--thread-url');
+    const maxScrolls = parseMaxScrolls(args['max-scrolls']);
+
+    await page.goto('https://www.linkedin.com/messaging/');
+    await page.wait(4);
+    await page.goto(threadUrl);
+    await page.wait(10);
+
+    const snapshot = unwrapEvaluateResult(await page.evaluate(buildThreadSnapshotScript(maxScrolls)));
+    if (snapshot?.authRequired) {
+      throw new AuthRequiredError(LINKEDIN_DOMAIN, 'LinkedIn thread-snapshot requires an active signed-in LinkedIn browser session.');
+    }
+    if (!snapshot || typeof snapshot !== 'object' || Array.isArray(snapshot) || !Array.isArray(snapshot.headerNames) || !Array.isArray(snapshot.messages)) {
+      throw new CommandExecutionError('LinkedIn thread-snapshot returned malformed snapshot payload');
+    }
+
+    const actualUrl = canonicalizeLinkedInThreadUrl(snapshot?.url || '');
+    if (threadUrl && actualUrl && threadUrl !== actualUrl) {
+      throw new CommandExecutionError('LinkedIn thread-snapshot blocked: thread_url_mismatch', `Expected ${threadUrl}; actual ${actualUrl}`);
+    }
+
+    const recipient = normalizeWhitespace(snapshot.headerNames[0] || '');
+    const messageCount = snapshot.messages.length;
+    const normalized = {
+      ...snapshot,
+      url: actualUrl || threadUrl,
+      headerNames: snapshot.headerNames,
+      latestMessageText: normalizeWhitespace(snapshot?.latestMessageText || ''),
+      messages: snapshot.messages,
+    };
+
+    return [{
+      thread_url: normalized.url,
+      recipient,
+      message_count: messageCount,
+      latest_text: normalized.latestMessageText,
+      snapshot_json: JSON.stringify(normalized),
+    }];
+  },
+});
+
+export const __test__ = {
+  normalizeWhitespace,
+  canonicalizeLinkedInThreadUrl,
+  parseMaxScrolls,
+  unwrapEvaluateResult,
+  buildThreadSnapshotScript,
+};

package/clis/linkedin/thread-snapshot.test.js

@@ -0,0 +1,89 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError } from '@jackwener/opencli/errors';
+import './thread-snapshot.js';
+
+const { canonicalizeLinkedInThreadUrl, parseMaxScrolls } = await import('./thread-snapshot.js').then((m) => m.__test__);
+
+function makeFakePage(snapshot) {
+  return {
+    goto: vi.fn(async () => undefined),
+    wait: vi.fn(async () => undefined),
+    evaluate: vi.fn(async () => snapshot),
+  };
+}
+
+describe('linkedin thread-snapshot command', () => {
+  it('accepts only exact LinkedIn messaging thread URLs', () => {
+    expect(canonicalizeLinkedInThreadUrl('https://www.linkedin.com/messaging/thread/2-abc==/?mini=true#x'))
+      .toBe('https://www.linkedin.com/messaging/thread/2-abc==/');
+    expect(canonicalizeLinkedInThreadUrl('https://www.linkedin.com/messaging/thread/2-abc==/extra')).toBe('');
+    expect(canonicalizeLinkedInThreadUrl('https://evil-linkedin.com/messaging/thread/2-abc==/')).toBe('');
+    expect(canonicalizeLinkedInThreadUrl('http://www.linkedin.com/messaging/thread/2-abc==/')).toBe('');
+  });
+
+  it('validates max-scrolls without silent clamping', () => {
+    expect(parseMaxScrolls(undefined)).toBe(30);
+    expect(parseMaxScrolls(0)).toBe(0);
+    expect(parseMaxScrolls(80)).toBe(80);
+    expect(() => parseMaxScrolls(81)).toThrow('--max-scrolls must be an integer between 0 and 80');
+    expect(() => parseMaxScrolls(1.5)).toThrow('--max-scrolls must be an integer between 0 and 80');
+  });
+
+  it('registers as a read command for loading full thread context', () => {
+    const command = getRegistry().get('linkedin/thread-snapshot');
+    expect(command).toBeDefined();
+    expect(command.access).toBe('read');
+    expect(command.columns).toEqual(expect.arrayContaining(['thread_url', 'recipient', 'message_count', 'latest_text']));
+  });
+
+  it('opens messaging first, then exact thread, and returns extracted messages', async () => {
+    const command = getRegistry().get('linkedin/thread-snapshot');
+    const page = makeFakePage({
+      url: 'https://www.linkedin.com/messaging/thread/abc/',
+      headerNames: ['Neha Rudraraju'],
+      latestMessageText: 'safe-send test from hermes. pls ignore :)',
+      messages: [
+        { index: 0, speaker: 'Neha Rudraraju', text: 'damn i just saw ur msg sry sry' },
+        { index: 1, speaker: 'Me', text: 'safe-send test from hermes. pls ignore :)' },
+      ],
+    });
+
+    const rows = await command.func(page, {
+      'thread-url': 'https://www.linkedin.com/messaging/thread/abc/',
+      'max-scrolls': 8,
+      json: false,
+    });
+
+    expect(page.goto).toHaveBeenNthCalledWith(1, 'https://www.linkedin.com/messaging/');
+    expect(page.goto).toHaveBeenNthCalledWith(2, 'https://www.linkedin.com/messaging/thread/abc/');
+    expect(rows[0]).toMatchObject({
+      thread_url: 'https://www.linkedin.com/messaging/thread/abc/',
+      recipient: 'Neha Rudraraju',
+      message_count: 2,
+      latest_text: 'safe-send test from hermes. pls ignore :)',
+    });
+    expect(rows[0].snapshot_json).toContain('damn i just saw ur msg sry sry');
+  });
+
+  it('rejects invalid thread URL before navigation', async () => {
+    const command = getRegistry().get('linkedin/thread-snapshot');
+    const page = makeFakePage({});
+
+    await expect(command.func(page, {
+      'thread-url': 'https://www.linkedin.com/feed/',
+      'max-scrolls': 8,
+    })).rejects.toBeInstanceOf(ArgumentError);
+    expect(page.goto).not.toHaveBeenCalled();
+  });
+
+  it('fails typed on malformed snapshot payloads', async () => {
+    const command = getRegistry().get('linkedin/thread-snapshot');
+    const page = makeFakePage({ url: 'https://www.linkedin.com/messaging/thread/abc/', headerNames: ['Neha Rudraraju'] });
+
+    await expect(command.func(page, {
+      'thread-url': 'https://www.linkedin.com/messaging/thread/abc/',
+      'max-scrolls': 8,
+    })).rejects.toBeInstanceOf(CommandExecutionError);
+  });
+});

package/clis/linkedin-learning/course.js

@@ -0,0 +1,138 @@
+/**
+ * LinkedIn Learning course detail by slug, via /learning-api/courses?q=slug.
+ */
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+const DOMAIN = 'www.linkedin.com';
+
+function normalizeWhitespace(value) {
+    return String(value ?? '').replace(/[  ]/g, ' ').replace(/\s+/g, ' ').trim();
+}
+
+function unwrapEvaluateResult(payload) {
+    if (payload && typeof payload === 'object' && 'data' in payload && 'session' in payload) return payload.data;
+    return payload;
+}
+
+function parseSlug(value) {
+    const s = normalizeWhitespace(value);
+    if (!s) throw new ArgumentError('<slug> is required');
+    let slug = s;
+    if (/^https?:\/\//i.test(s)) {
+        let parsed;
+        try {
+            parsed = new URL(s);
+        } catch {
+            throw new ArgumentError(`Invalid LinkedIn Learning URL: "${s}"`);
+        }
+        const host = parsed.hostname.toLowerCase();
+        if (host !== 'linkedin.com' && host !== 'www.linkedin.com') {
+            throw new ArgumentError(`Invalid LinkedIn Learning host: "${parsed.hostname}"`);
+        }
+        const m = parsed.pathname.match(/^\/learning\/([^/?#]+)/);
+        if (!m) throw new ArgumentError(`Invalid LinkedIn Learning course URL: "${s}"`);
+        slug = m[1];
+    } else {
+        const m = s.match(/^\/?learning\/([^/?#]+)/);
+        slug = m ? m[1] : s;
+    }
+    if (!/^[a-zA-Z0-9-_]+$/.test(slug)) {
+        throw new ArgumentError(`Invalid LinkedIn Learning slug: "${slug}"`);
+    }
+    return slug;
+}
+
+function buildFetchScript(url, csrf) {
+    return String.raw`(async () => {
+    try {
+      const res = await fetch(${JSON.stringify(url)}, {
+        credentials: 'include',
+        headers: {
+          'csrf-token': ${JSON.stringify(csrf)},
+          'x-restli-protocol-version': '2.0.0',
+          accept: 'application/json',
+        },
+      });
+      if (res.status === 401 || res.status === 403) return { authRequired: true, status: res.status };
+      if (!res.ok) return { error: 'HTTP ' + res.status };
+      return { json: await res.json() };
+    } catch (e) {
+      return { error: 'fetch failed: ' + ((e && e.message) || String(e)) };
+    }
+  })()`;
+}
+
+function parseCourse(el, slug) {
+    const title = normalizeWhitespace(el?.title);
+    if (!title) return null;
+    const description = typeof el?.description === 'string'
+        ? el.description
+        : (el?.description?.text || '');
+    const duration = el?.duration?.unit === 'SECOND' ? String(el.duration.duration ?? '') : '';
+    const released = el?.activatedAt ? new Date(el.activatedAt).toISOString().slice(0, 10) : '';
+    return {
+        title,
+        slug,
+        description,
+        difficulty: el?.difficultyLevel || '',
+        duration_sec: duration,
+        videos_count: el?.videosCount ?? '',
+        rating: typeof el?.rating?.averageRating === 'number' ? el.rating.averageRating.toFixed(2) : '',
+        rating_count: el?.rating?.ratingCount ?? '',
+        released,
+        url: `https://www.linkedin.com/learning/${slug}`,
+    };
+}
+
+cli({
+    site: 'linkedin-learning',
+    name: 'course',
+    access: 'read',
+    description: 'Get LinkedIn Learning course detail by slug or course URL',
+    domain: DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'slug', type: 'string', required: true, positional: true, help: 'Course slug (e.g. agentic-ai-build-your-first-agentic-ai-system) or full /learning/<slug> URL' },
+    ],
+    columns: ['title', 'slug', 'description', 'difficulty', 'duration_sec', 'videos_count', 'rating', 'rating_count', 'released', 'url'],
+    func: async (page, args) => {
+        if (!page) throw new CommandExecutionError('Browser session required for linkedin-learning course');
+        const slug = parseSlug(args.slug);
+
+        await page.goto('https://www.linkedin.com/learning/');
+        await page.wait(3);
+
+        const cookies = await page.getCookies({ url: 'https://www.linkedin.com' });
+        const jsession = cookies.find((c) => c.name === 'JSESSIONID')?.value;
+        if (!jsession) {
+            throw new AuthRequiredError(DOMAIN, 'LinkedIn JSESSIONID cookie not found. Please sign in to LinkedIn in the browser.');
+        }
+        const csrf = jsession.replace(/^"|"$/g, '');
+
+        const url = `https://www.linkedin.com/learning-api/courses?q=slug&slug=${encodeURIComponent(slug)}`;
+        const result = unwrapEvaluateResult(await page.evaluate(buildFetchScript(url, csrf)));
+        if (result?.authRequired) {
+            throw new AuthRequiredError(DOMAIN, `LinkedIn Learning auth failed (HTTP ${result.status ?? ''}).`);
+        }
+        if (!result?.json) {
+            throw new CommandExecutionError(`LinkedIn Learning courses lookup failed: ${result?.error ?? 'no payload'}`);
+        }
+        const elements = result.json?.elements;
+        if (!Array.isArray(elements)) {
+            throw new CommandExecutionError('LinkedIn Learning courses lookup returned malformed payload: missing elements array');
+        }
+        const el = elements[0];
+        if (!el) {
+            throw new EmptyResultError(`No LinkedIn Learning course found for slug "${slug}"`);
+        }
+        const row = parseCourse(el, slug);
+        if (!row) {
+            throw new CommandExecutionError('LinkedIn Learning courses lookup returned malformed course detail: missing title');
+        }
+        return [row];
+    },
+});
+
+export const __test__ = { parseSlug, parseCourse };