@jackwener/opencli 1.7.21 → 1.8.0

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

@@ -0,0 +1,172 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import './salesnav-message.js';
+
+const {
+  parseSalesProfileUrn,
+  parseRecipient,
+  salesLeadUrlFromParts,
+  profileApiUrl,
+  buildCreateMessagePayload,
+  extractRemainingCredits,
+  profileSummary,
+  requireProfileSummary,
+  salesPageShowsSentMessage,
+} = await import('./salesnav-message.js').then((m) => m.__test__);
+
+function createPageMock(evaluateResults = []) {
+  const evaluate = vi.fn();
+  for (const result of evaluateResults) evaluate.mockResolvedValueOnce(result);
+  evaluate.mockResolvedValue(undefined);
+  return {
+    goto: vi.fn().mockResolvedValue(undefined),
+    wait: vi.fn().mockResolvedValue(undefined),
+    evaluate,
+    getCookies: vi.fn().mockResolvedValue([{ name: 'JSESSIONID', value: '"csrf"', domain: '.linkedin.com' }]),
+  };
+}
+
+describe('linkedin salesnav-message command', () => {
+  it('parses Sales Navigator profile urns and lead URLs', () => {
+    const urn = 'urn:li:fs_salesProfile:(ACwAAAJS8TABxyz,NAME_SEARCH,Enlo)';
+    expect(parseSalesProfileUrn(urn)).toMatchObject({
+      profileId: 'ACwAAAJS8TABxyz',
+      authType: 'NAME_SEARCH',
+      authToken: 'Enlo',
+      entityUrn: urn,
+    });
+    expect(parseSalesProfileUrn('urn:li:fs_salesProfile:(ACwAAAJS8TABxyz,undefined,undefined)')).toBeNull();
+
+    const parsed = parseRecipient('https://www.linkedin.com/sales/lead/ACwAAAJS8TABxyz,NAME_SEARCH,Enlo');
+    expect(parsed).toMatchObject({ profileId: 'ACwAAAJS8TABxyz', authType: 'NAME_SEARCH', authToken: 'Enlo' });
+    expect(parsed.entityUrn).toBe(urn);
+    expect(salesLeadUrlFromParts(parsed)).toBe('https://www.linkedin.com/sales/lead/ACwAAAJS8TABxyz,NAME_SEARCH,Enlo');
+  });
+
+  it('accepts LinkedIn /in tokens as unresolved recipients', () => {
+    expect(parseRecipient('https://www.linkedin.com/in/ACwAAAJS8TABxyz/')).toMatchObject({
+      profileId: 'ACwAAAJS8TABxyz',
+      authType: '',
+      authToken: '',
+      entityUrn: '',
+    });
+  });
+
+  it('builds profile API URLs with the Sales Navigator auth key', () => {
+    const url = profileApiUrl({ profileId: 'P1', authType: 'NAME_SEARCH', authToken: 'T1' });
+    expect(url).toContain('/sales-api/salesApiProfiles/(profileId:P1,authType:NAME_SEARCH,authToken:T1)');
+    expect(url).toContain('decoration=');
+  });
+
+  it('constructs the createMessage action payload used by Sales Navigator', () => {
+    const payload = buildCreateMessagePayload({
+      recipientUrn: 'urn:li:fs_salesProfile:(P1,NAME_SEARCH,T1)',
+      subject: 'Quick QA doc question',
+      body: 'Hi Jane, can I ask a quick question?',
+      trackingId: '0123456789abcdef',
+      copyToCrm: false,
+    });
+    expect(payload).toEqual({
+      createMessageRequest: {
+        recipients: ['urn:li:fs_salesProfile:(P1,NAME_SEARCH,T1)'],
+        subject: 'Quick QA doc question',
+        body: 'Hi Jane, can I ask a quick question?',
+        copyToCrm: false,
+        trackingId: '0123456789abcdef',
+      },
+    });
+  });
+
+  it('validates payload fields before any send attempt', () => {
+    expect(() => buildCreateMessagePayload({ recipientUrn: '', subject: 's', body: 'b' })).toThrow();
+    expect(() => buildCreateMessagePayload({ recipientUrn: 'urn:li:fs_salesProfile:(P,A,T)', subject: '', body: 'b' })).toThrow();
+    expect(() => buildCreateMessagePayload({ recipientUrn: 'urn:li:fs_salesProfile:(P,A,T)', subject: 's', body: '' })).toThrow();
+    expect(() => buildCreateMessagePayload({ recipientUrn: 'urn:li:fs_salesProfile:(P,A,T)', subject: 'x'.repeat(201), body: 'b' })).toThrow();
+    expect(() => buildCreateMessagePayload({ recipientUrn: 'urn:li:fs_salesProfile:(P,undefined,undefined)', subject: 's', body: 'b' })).toThrow();
+  });
+
+  it('detects the Sales Navigator sent activity on a verified lead page', () => {
+    expect(salesPageShowsSentMessage('5/18/2026 You sent a Sales Navigator message to Jane', 'Jane Q')).toBe(true);
+    expect(salesPageShowsSentMessage('No recent activity', 'Jane Q')).toBe(false);
+  });
+
+  it('extracts a plausible remaining InMail credit count', () => {
+    expect(extractRemainingCredits({ elements: [{ type: 'LSS_INMAIL', value: 149, id: 1 }], paging: { count: 10 } })).toBe(149);
+    expect(extractRemainingCredits({ data: { remaining: 149, used: 1 } })).toBe(149);
+    expect(extractRemainingCredits({ elements: [{ availableCount: 12 }] })).toBe(12);
+    expect(extractRemainingCredits({})).toBe(null);
+  });
+
+  it('summarizes decorated Sales Navigator profile data', () => {
+    expect(profileSummary({ data: {
+      fullName: 'Rayki Goh',
+      headline: 'Food Safety',
+      degree: 3,
+      defaultPosition: { title: 'FSQA Manager', companyName: 'Acme Foods' },
+      memberBadges: { openLink: false },
+    } })).toMatchObject({
+      recipient: 'Rayki Goh',
+      title: 'FSQA Manager',
+      company: 'Acme Foods',
+      degree: '3',
+      open_link: false,
+    });
+  });
+
+  it('fails typed when decorated profile data has no recipient identity', () => {
+    expect(() => requireProfileSummary({ data: { defaultPosition: { title: 'FSQA' } } }))
+      .toThrow(CommandExecutionError);
+  });
+
+  it('keeps manifest columns aligned with dry-run rows and fails typed on malformed profile API', async () => {
+    const cmd = getRegistry().get('linkedin/salesnav-message');
+    expect(cmd?.columns).toEqual([
+      'status',
+      'recipient',
+      'title',
+      'company',
+      'credits_remaining',
+      'credits_before',
+      'credits_after',
+      'sent_in_salesnav',
+      'message_chars',
+      'subject_chars',
+      'recipient_urn',
+      'degree',
+      'inmail_restriction',
+      'open_link',
+    ]);
+
+    const goodPage = createPageMock([
+      { status: 200, json: { data: { fullName: 'Jane Doe', defaultPosition: { title: 'QA', companyName: 'Acme' }, degree: 2, inmailRestriction: 'NO_RESTRICTION', memberBadges: { openLink: true } } } },
+      { status: 200, json: { elements: [{ type: 'LSS_INMAIL', value: 12 }] } },
+    ]);
+    const rows = await cmd.func(goodPage, {
+      recipient: 'urn:li:fs_salesProfile:(P1,NAME_SEARCH,T1)',
+      subject: 'Hello',
+      body: 'Quick question',
+    });
+    expect(Object.keys(rows[0]).sort()).toEqual([...cmd.columns].sort());
+    expect(rows[0]).toMatchObject({
+      status: 'validated_dry_run',
+      recipient: 'Jane Doe',
+      credits_remaining: 12,
+      credits_before: 12,
+      credits_after: '',
+      sent_in_salesnav: false,
+      degree: '2',
+      inmail_restriction: 'NO_RESTRICTION',
+      open_link: true,
+    });
+
+    const malformedPage = createPageMock([
+      { status: 200, json: { data: { defaultPosition: { title: 'QA' } } } },
+    ]);
+    await expect(cmd.func(malformedPage, {
+      recipient: 'urn:li:fs_salesProfile:(P1,NAME_SEARCH,T1)',
+      subject: 'Hello',
+      body: 'Quick question',
+    })).rejects.toThrow(CommandExecutionError);
+  });
+});

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