@jackwener/opencli 1.7.22 → 1.8.1

package/clis/linkedin/salesnav-search.js

@@ -0,0 +1,186 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+const LINKEDIN_DOMAIN = 'www.linkedin.com';
+const SALES_HOME = 'https://www.linkedin.com/sales/';
+const LEAD_SEARCH_BASE = 'https://www.linkedin.com/sales-api/salesApiLeadSearch';
+// Versioned response decoration. LinkedIn bumps this on Sales Navigator
+// redeploys; if the response shape ever changes, refresh it from a live
+// /sales/search/people request.
+const LEAD_SEARCH_DECORATION = 'com.linkedin.sales.deco.desktop.searchv2.LeadSearchResult-14';
+const PAGE_SIZE = 25;
+
+function normalizeWhitespace(value) {
+  return String(value ?? '').replace(/[  ]/g, ' ').replace(/\s+/g, ' ').trim();
+}
+
+function requireStringArg(args, key, label = key) {
+  const value = normalizeWhitespace(args[key]);
+  if (!value) throw new ArgumentError(`${label} is required`);
+  return value;
+}
+
+function parseLimit(value) {
+  if (value === undefined || value === null || value === '') return 25;
+  const limit = Number(value);
+  if (!Number.isInteger(limit) || limit < 1 || limit > 500) {
+    throw new ArgumentError('--limit must be an integer between 1 and 500');
+  }
+  return limit;
+}
+
+function unwrapEvaluateResult(payload) {
+  if (payload && typeof payload === 'object' && 'data' in payload && 'session' in payload) return payload.data;
+  return payload;
+}
+
+// Sales Navigator keeps the structural ( ) , : of the query literal and only
+// percent-encodes the keyword value.
+function leadSearchUrl(keywords, start) {
+  const query = '(spellCorrectionEnabled:true,recentSearchParam:(doLogHistory:true),keywords:'
+    + encodeURIComponent(keywords) + ')';
+  return LEAD_SEARCH_BASE
+    + '?q=searchQuery&query=' + query
+    + '&start=' + start + '&count=' + PAGE_SIZE
+    + '&decorationId=' + LEAD_SEARCH_DECORATION;
+}
+
+function fetchLeadSearchScript(url, csrf) {
+  return String.raw`(async () => {
+    const headers = {
+      'csrf-token': ${JSON.stringify(csrf)},
+      'x-restli-protocol-version': '2.0.0',
+      accept: 'application/json',
+    };
+    try {
+      const res = await fetch(${JSON.stringify(url)}, { credentials: 'include', headers });
+      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)) };
+    }
+  })()`;
+}
+
+// Sales Navigator search returns no /in/ vanity URL, but the entityUrn carries
+// the obfuscated member token, and linkedin.com/in/<token> is a valid profile
+// URL that the connect command accepts.
+function profileUrlFromEntityUrn(entityUrn) {
+  const match = String(entityUrn || '').match(/fs_salesProfile:\(([^,)]+)/);
+  return match && match[1] ? 'https://www.linkedin.com/in/' + match[1] : '';
+}
+
+function leadUrlFromEntityUrn(entityUrn) {
+  const match = String(entityUrn || '').match(/^urn:li:fs_salesProfile:\(([^,()]+),([^,()]+),([^,()]+)\)$/);
+  if (!match) return '';
+  return `https://www.linkedin.com/sales/lead/${encodeURIComponent(match[1])},${encodeURIComponent(match[2])},${encodeURIComponent(match[3])}`;
+}
+
+function parseLeads(json) {
+  if (!json || typeof json !== 'object' || !Array.isArray(json.elements)) {
+    throw new CommandExecutionError('Sales Navigator lead search API returned malformed payload');
+  }
+  const leads = [];
+  for (const el of json.elements) {
+    if (!el || typeof el !== 'object') {
+      throw new CommandExecutionError('Sales Navigator lead search API returned malformed lead row');
+    }
+    const current = Array.isArray(el.currentPositions) ? el.currentPositions : [];
+    const past = Array.isArray(el.pastPositions) ? el.pastPositions : [];
+    const pos = current[0] || past[0] || {};
+    const name = normalizeWhitespace(el.fullName || [el.firstName, el.lastName].filter(Boolean).join(' '));
+    if (!name) {
+      throw new CommandExecutionError('Sales Navigator lead row missing name');
+    }
+    const entityUrn = normalizeWhitespace(el.entityUrn || '');
+    if (!profileUrlFromEntityUrn(entityUrn)) {
+      throw new CommandExecutionError('Sales Navigator lead row missing profile identity');
+    }
+    leads.push({
+      name,
+      title: normalizeWhitespace(pos.title || ''),
+      company: normalizeWhitespace(pos.companyName || ''),
+      location: normalizeWhitespace(el.geoRegion || ''),
+      degree: normalizeWhitespace(el.degree || ''),
+      profile_url: profileUrlFromEntityUrn(entityUrn),
+      lead_url: leadUrlFromEntityUrn(entityUrn),
+      recipient_urn: entityUrn,
+    });
+  }
+  return leads;
+}
+
+function requireLeadSearchResult(result) {
+  if (result?.authRequired) {
+    throw new AuthRequiredError(LINKEDIN_DOMAIN, 'LinkedIn Sales Navigator API auth failed (HTTP ' + (result.status || '') + '). Confirm the account has Sales Navigator access.');
+  }
+  if (result?.error) {
+    throw new CommandExecutionError('Sales Navigator lead search API returned an unexpected response', result.error);
+  }
+  if (!result || !result.json) {
+    throw new CommandExecutionError('Sales Navigator lead search API returned an unexpected response', 'no_json');
+  }
+  return result.json;
+}
+
+cli({
+  site: 'linkedin',
+  name: 'salesnav-search',
+  access: 'read',
+  description: 'Search LinkedIn Sales Navigator for people leads by keyword',
+  domain: LINKEDIN_DOMAIN,
+  strategy: Strategy.UI,
+  browser: true,
+  args: [
+    { name: 'keywords', type: 'string', required: true, positional: true, help: 'People search keywords, e.g. "quality manager food manufacturing"' },
+    { name: 'limit', type: 'number', default: 25, help: 'Maximum leads to return (1-500, fetched 25 per request)' },
+  ],
+  columns: ['rank', 'name', 'title', 'company', 'location', 'degree', 'profile_url', 'lead_url', 'recipient_urn'],
+  func: async (page, args) => {
+    if (!page) throw new CommandExecutionError('Browser session required for linkedin salesnav-search');
+    const keywords = requireStringArg(args, 'keywords', '--keywords');
+    const limit = parseLimit(args.limit);
+
+    await page.goto(SALES_HOME);
+    await page.wait(6);
+
+    const cookies = await page.getCookies({ url: 'https://www.linkedin.com' });
+    const jsession = cookies.find((c) => c.name === 'JSESSIONID')?.value;
+    if (!jsession) {
+      throw new AuthRequiredError(LINKEDIN_DOMAIN, 'LinkedIn JSESSIONID cookie not found. Please sign in to LinkedIn.');
+    }
+    const csrf = jsession.replace(/^\"|\"$/g, '');
+
+    const leads = [];
+    const seen = new Set();
+    for (let start = 0; leads.length < limit && start < 2000; start += PAGE_SIZE) {
+      const result = unwrapEvaluateResult(await page.evaluate(fetchLeadSearchScript(leadSearchUrl(keywords, start), csrf)));
+      const json = requireLeadSearchResult(result);
+      const pageLeads = parseLeads(json);
+      if (pageLeads.length === 0) break;
+      for (const lead of pageLeads) {
+        const key = lead.profile_url || lead.name.toLowerCase();
+        if (seen.has(key)) continue;
+        seen.add(key);
+        leads.push(lead);
+      }
+      await page.wait(1);
+    }
+
+    if (leads.length === 0) {
+      throw new EmptyResultError('linkedin salesnav-search', 'No Sales Navigator leads were found.');
+    }
+    return leads.slice(0, limit).map((lead, index) => ({ rank: index + 1, ...lead }));
+  },
+});
+
+export const __test__ = {
+  normalizeWhitespace,
+  parseLimit,
+  leadSearchUrl,
+  profileUrlFromEntityUrn,
+  leadUrlFromEntityUrn,
+  parseLeads,
+  requireLeadSearchResult,
+};

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

@@ -0,0 +1,76 @@
+import { describe, expect, it } from 'vitest';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import './salesnav-search.js';
+
+const {
+  parseLimit,
+  leadSearchUrl,
+  profileUrlFromEntityUrn,
+  leadUrlFromEntityUrn,
+  parseLeads,
+  requireLeadSearchResult,
+} = await import('./salesnav-search.js').then((m) => m.__test__);
+
+describe('linkedin salesnav-search command', () => {
+  it('builds a salesApiLeadSearch URL with encoded keywords and pagination', () => {
+    const url = leadSearchUrl('quality manager food', 50);
+    expect(url).toContain('/sales-api/salesApiLeadSearch');
+    expect(url).toContain('keywords:quality%20manager%20food');
+    expect(url).toContain('start=50');
+    expect(url).toContain('count=25');
+  });
+
+  it('derives a profile URL from the sales-profile entityUrn token', () => {
+    expect(profileUrlFromEntityUrn('urn:li:fs_salesProfile:(ACwAAAJS8TABxyz,NAME_SEARCH,Enlo)'))
+      .toBe('https://www.linkedin.com/in/ACwAAAJS8TABxyz');
+    expect(profileUrlFromEntityUrn('')).toBe('');
+    expect(profileUrlFromEntityUrn('not-a-urn')).toBe('');
+  });
+
+  it('derives a Sales Navigator lead URL from the full sales-profile entityUrn', () => {
+    expect(leadUrlFromEntityUrn('urn:li:fs_salesProfile:(ACwAAAJS8TABxyz,NAME_SEARCH,Enlo)'))
+      .toBe('https://www.linkedin.com/sales/lead/ACwAAAJS8TABxyz,NAME_SEARCH,Enlo');
+    expect(leadUrlFromEntityUrn('not-a-urn')).toBe('');
+  });
+
+  it('validates --limit without silent clamping', () => {
+    expect(parseLimit(undefined)).toBe(25);
+    expect(parseLimit(120)).toBe(120);
+    expect(() => parseLimit(0)).toThrow();
+    expect(() => parseLimit(999)).toThrow();
+    expect(() => parseLimit('abc')).toThrow();
+  });
+
+  it('parses lead rows and falls back to past positions', () => {
+    const json = { elements: [
+      { fullName: 'Jane Q', geoRegion: 'Vancouver, BC', degree: 2,
+        entityUrn: 'urn:li:fs_salesProfile:(TOKEN1,NAME_SEARCH,abc)',
+        currentPositions: [{ title: 'QA Manager', companyName: 'Acme Foods' }] },
+      { fullName: 'No Current', geoRegion: 'Toronto',
+        entityUrn: 'urn:li:fs_salesProfile:(TOKEN2,NAME_SEARCH,def)',
+        currentPositions: [], pastPositions: [{ title: 'Past QA Lead', companyName: 'Old Co' }] },
+    ] };
+    const leads = parseLeads(json);
+    expect(leads).toHaveLength(2);
+    expect(leads[0]).toMatchObject({
+      name: 'Jane Q',
+      title: 'QA Manager',
+      company: 'Acme Foods',
+      location: 'Vancouver, BC',
+      profile_url: 'https://www.linkedin.com/in/TOKEN1',
+      lead_url: 'https://www.linkedin.com/sales/lead/TOKEN1,NAME_SEARCH,abc',
+      recipient_urn: 'urn:li:fs_salesProfile:(TOKEN1,NAME_SEARCH,abc)',
+    });
+    expect(leads[1]).toMatchObject({ name: 'No Current', title: 'Past QA Lead', company: 'Old Co' });
+  });
+
+  it('fails typed on malformed lead payloads instead of silently dropping rows', () => {
+    expect(() => parseLeads({})).toThrow(CommandExecutionError);
+    expect(() => parseLeads({ elements: [{ firstName: '', lastName: '', entityUrn: 'urn:li:fs_salesProfile:(TOKEN3,x,y)' }] }))
+      .toThrow(CommandExecutionError);
+    expect(() => parseLeads({ elements: [{ fullName: 'No Identity' }] }))
+      .toThrow(CommandExecutionError);
+    expect(() => requireLeadSearchResult({ error: 'HTTP 500' })).toThrow(CommandExecutionError);
+    expect(() => requireLeadSearchResult({})).toThrow(CommandExecutionError);
+  });
+});

package/clis/linkedin/salesnav-thread.js

@@ -0,0 +1,212 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import {
+  THREAD_DECORATION,
+  THREADS_BASE,
+  encodeRestliDecoration,
+  fetchInboxRows,
+  fetchSalesnavJson,
+  getCsrf,
+  normalizeWhitespace,
+  parseLimit,
+} from './salesnav-inbox.js';
+
+const LINKEDIN_DOMAIN = 'www.linkedin.com';
+const SALES_INBOX_URL = 'https://www.linkedin.com/sales/inbox/';
+const DEFAULT_MESSAGE_LIMIT = 200;
+const THREAD_PAGE_SIZE = 20;
+
+function isLinkedInHost(hostname) {
+  const host = String(hostname || '').toLowerCase();
+  return host === 'linkedin.com' || host.endsWith('.linkedin.com');
+}
+
+function parseSalesProfileUrn(value) {
+  const raw = normalizeWhitespace(value);
+  const match = raw.match(/^urn:li:fs_salesProfile:\(([^,()]+),([^,()]+),([^,()]+)\)$/);
+  if (!match) return '';
+  const parts = [match[1], match[2], match[3]].map((part) => normalizeWhitespace(part).toLowerCase());
+  if (parts.some((part) => !part || part === 'undefined' || part === 'null' || part === 'not_available')) return '';
+  return raw;
+}
+
+function parseThreadInput(value) {
+  const raw = normalizeWhitespace(value);
+  if (!raw) return ['empty', ''];
+  if (/^2-[A-Za-z0-9+/=_-]+$/.test(raw)) return ['thread_id', raw];
+  if (/^urn:li:fs_salesProfile:\(/.test(raw)) {
+    const urn = parseSalesProfileUrn(raw);
+    if (!urn) throw new ArgumentError('Sales Navigator recipient urn must be urn:li:fs_salesProfile:(profileId,authType,authToken)');
+    return ['recipient_urn', urn];
+  }
+  try {
+    const url = new URL(raw);
+    if (url.protocol !== 'https:' || url.username || url.password || url.port || !isLinkedInHost(url.hostname)) return ['name', raw.toLowerCase()];
+    const inboxMatch = url.pathname.match(/^\/sales\/inbox\/([^/]+)\/?$/i);
+    if (inboxMatch) return ['thread_id', decodeURIComponent(inboxMatch[1])];
+    const leadMatch = url.pathname.match(/^\/sales\/lead\/([^,/]+),([^,/]+),([^/]+)\/?$/i);
+    if (leadMatch) {
+      const urn = `urn:li:fs_salesProfile:(${decodeURIComponent(leadMatch[1])},${decodeURIComponent(leadMatch[2])},${decodeURIComponent(leadMatch[3])})`;
+      if (!parseSalesProfileUrn(urn)) {
+        throw new ArgumentError('Sales Navigator lead URL must contain resolved profileId, authType, and authToken');
+      }
+      return ['recipient_urn', urn];
+    }
+  } catch (err) {
+    if (err instanceof ArgumentError) throw err;
+    // Fall through to name matching for non-URL text.
+  }
+  return ['name', raw.toLowerCase()];
+}
+
+function salesnavThreadUrl(threadId) {
+  return threadId ? `https://www.linkedin.com/sales/inbox/${encodeURIComponent(threadId)}` : '';
+}
+
+function threadApiUrl(threadId, messageCount) {
+  return `${THREADS_BASE}/${encodeURIComponent(threadId)}?decoration=${encodeRestliDecoration(THREAD_DECORATION)}&count=1&messageCount=${messageCount}`;
+}
+
+function participantName(profile) {
+  return normalizeWhitespace(profile?.fullName || [profile?.firstName, profile?.lastName].filter(Boolean).join(' '));
+}
+
+function participantIndex(thread) {
+  const resolution = thread?.participantsResolutionResults || {};
+  const participants = Array.isArray(thread?.participants) ? thread.participants : Object.keys(resolution);
+  const byUrn = new Map();
+  for (const urn of participants) {
+    const profile = resolution[urn] || { entityUrn: urn };
+    byUrn.set(urn, profile);
+  }
+  return byUrn;
+}
+
+function parseSalesnavThreadMessages(thread) {
+  if (!thread || typeof thread !== 'object') {
+    throw new CommandExecutionError('Sales Navigator messaging thread API returned malformed payload');
+  }
+  const threadId = normalizeWhitespace(thread?.id || '');
+  if (!threadId) {
+    throw new CommandExecutionError('Sales Navigator messaging thread API returned a thread without id');
+  }
+  if (!Array.isArray(thread?.messages)) {
+    throw new CommandExecutionError('Sales Navigator messaging thread API returned malformed messages');
+  }
+  const byUrn = participantIndex(thread);
+  const messages = thread.messages;
+  const rows = messages.map((message) => {
+    if (!message || typeof message !== 'object') {
+      throw new CommandExecutionError('Sales Navigator messaging thread API returned malformed message row');
+    }
+    const deliveredAt = Number(message?.deliveredAt || 0);
+    const senderProfile = byUrn.get(message?.author);
+    return {
+      message_id: normalizeWhitespace(message?.id || ''),
+      thread_id: threadId,
+      sender: participantName(senderProfile) || normalizeWhitespace(message?.author || ''),
+      sender_urn: normalizeWhitespace(message?.author || ''),
+      text: normalizeWhitespace(message?.body || message?.systemMessageContent || ''),
+      subject: normalizeWhitespace(message?.subject || ''),
+      timestamp: deliveredAt ? new Date(deliveredAt).toISOString() : '',
+      delivered_at: deliveredAt || '',
+      type: normalizeWhitespace(message?.type || ''),
+    };
+  }).filter((row) => row.text || row.subject || row.message_id);
+  rows.sort((a, b) => Number(a.delivered_at || 0) - Number(b.delivered_at || 0));
+  return rows.map((row, index) => ({ index, ...row }));
+}
+
+function threadMatchesInput(row, parsed) {
+  if (!row || !parsed) return false;
+  const [kind, criterion] = parsed;
+  if (kind === 'thread_id') return row.thread_id === criterion;
+  if (kind === 'recipient_urn') {
+    return (row.participants || []).some((p) => normalizeWhitespace(p.entity_urn) === criterion);
+  }
+  if (kind === 'name') {
+    const needle = normalizeWhitespace(criterion).toLowerCase();
+    if (!needle) return false;
+    if (normalizeWhitespace(row.person_name).toLowerCase() === needle) return true;
+    return (row.participants || []).some((p) => normalizeWhitespace(p.name).toLowerCase() === needle);
+  }
+  return false;
+}
+
+async function resolveThreadId(page, input, { maxPages = 30 } = {}) {
+  const parsed = parseThreadInput(input);
+  if (parsed[0] === 'empty') throw new ArgumentError('thread or recipient is required');
+  if (parsed[0] === 'thread_id') return parsed[1];
+  const inboxRows = await fetchInboxRows(page, { limit: 500, maxPages });
+  const match = inboxRows.find((row) => threadMatchesInput(row, parsed));
+  if (!match) {
+    throw new EmptyResultError('linkedin salesnav-thread', `No Sales Navigator thread matched ${input}`);
+  }
+  return match.thread_id;
+}
+
+async function fetchThreadWithPagination(page, csrf, threadId, limit = DEFAULT_MESSAGE_LIMIT) {
+  let requested = THREAD_PAGE_SIZE;
+  if (limit < requested) requested = limit;
+  let thread = null;
+  for (let attempts = 0; attempts < 30; attempts += 1) {
+    thread = await fetchSalesnavJson(page, csrf, threadApiUrl(threadId, requested), 'Sales Navigator messaging thread API');
+    const total = Number(thread?.totalMessageCount || 0);
+    const have = Array.isArray(thread?.messages) ? thread.messages.length : 0;
+    if (have >= limit || (total && have >= total) || requested >= limit) break;
+    let nextRequested = requested + THREAD_PAGE_SIZE;
+    if (total && total > nextRequested) nextRequested = total;
+    if (nextRequested > limit) nextRequested = limit;
+    requested = nextRequested;
+  }
+  const total = Number(thread?.totalMessageCount || 0);
+  const have = Array.isArray(thread?.messages) ? thread.messages.length : 0;
+  if (total && have < total && have < limit) {
+    throw new CommandExecutionError(`Sales Navigator messaging thread API returned partial history (${have}/${total})`);
+  }
+  return thread;
+}
+
+cli({
+  site: 'linkedin',
+  name: 'salesnav-thread',
+  access: 'read',
+  description: 'Return full Sales Navigator message history for a thread id, Sales Navigator inbox URL, lead URL, recipient urn, or exact recipient name',
+  domain: LINKEDIN_DOMAIN,
+  strategy: Strategy.UI,
+  browser: true,
+  args: [
+    { name: 'thread-or-recipient', type: 'string', required: true, positional: true, help: 'Sales Navigator inbox URL/thread id, Sales Navigator lead URL, recipient urn, or exact participant name' },
+    { name: 'limit', type: 'number', default: DEFAULT_MESSAGE_LIMIT, help: 'Maximum messages to return (1-500)' },
+    { name: 'max-pages', type: 'number', default: 30, help: 'Maximum inbox pages to scan when resolving a recipient' },
+  ],
+  columns: ['index', 'thread_id', 'thread_url', 'sender', 'text', 'timestamp', 'subject', 'message_id', 'sender_urn', 'delivered_at', 'type', 'total_message_count'],
+  func: async (page, args) => {
+    if (!page) throw new CommandExecutionError('Browser session required for linkedin salesnav-thread');
+    const input = normalizeWhitespace(args['thread-or-recipient']);
+    if (!input) throw new ArgumentError('thread-or-recipient is required');
+    const limit = parseLimit(args.limit, DEFAULT_MESSAGE_LIMIT);
+    const maxPages = parseLimit(args['max-pages'], 30);
+    await page.goto(SALES_INBOX_URL);
+    await page.wait(4);
+    const threadId = await resolveThreadId(page, input, { maxPages });
+    const csrf = await getCsrf(page);
+    const thread = await fetchThreadWithPagination(page, csrf, threadId, limit);
+    const messages = parseSalesnavThreadMessages(thread).slice(0, limit);
+    if (messages.length === 0) throw new EmptyResultError('linkedin salesnav-thread', `No messages found for ${threadId}`);
+    return messages.map((message) => ({
+      ...message,
+      thread_url: salesnavThreadUrl(threadId),
+      total_message_count: Number(thread?.totalMessageCount || messages.length),
+    }));
+  },
+});
+
+export const __test__ = {
+  parseThreadInput,
+  threadApiUrl,
+  participantIndex,
+  parseSalesnavThreadMessages,
+  threadMatchesInput,
+  salesnavThreadUrl,
+};

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,
+};