@jackwener/opencli 1.7.21 → 1.8.0

package/clis/linkedin/salesnav-inbox.js

@@ -0,0 +1,210 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+const LINKEDIN_DOMAIN = 'www.linkedin.com';
+const SALES_INBOX_URL = 'https://www.linkedin.com/sales/inbox/';
+const THREADS_BASE = 'https://www.linkedin.com/sales-api/salesApiMessagingThreads';
+const PAGE_SIZE = 20;
+const DEFAULT_LIMIT = 40;
+const MAX_LIMIT = 500;
+const THREAD_DECORATION = '(id,restrictions,archived,unreadMessageCount,nextPageStartsAt,totalMessageCount,messages*(id,type,contentFlag,deliveredAt,lastEditedAt,subject,body,footerText,blockCopy,attachments,author,systemMessageContent),participants*~fs_salesProfile(entityUrn,firstName,lastName,fullName,degree,profilePictureDisplayImage,objectUrn,inmailRestriction))';
+
+export function normalizeWhitespace(value) {
+  return String(value ?? '').replace(/[\u00a0\u202f]/g, ' ').replace(/\s+/g, ' ').trim();
+}
+
+export function parseLimit(value, defaultValue = DEFAULT_LIMIT) {
+  if (value === undefined || value === null || value === '') return defaultValue;
+  const limit = Number(value);
+  if (!Number.isInteger(limit) || limit < 1 || limit > MAX_LIMIT) {
+    throw new ArgumentError(`--limit must be an integer between 1 and ${MAX_LIMIT}`);
+  }
+  return limit;
+}
+
+function unwrapEvaluateResult(payload) {
+  if (payload && typeof payload === 'object' && 'data' in payload && 'session' in payload) return payload.data;
+  return payload;
+}
+
+export function encodeRestliDecoration(value) {
+  // LinkedIn's Sales Navigator Rest.li endpoint returns HTTP 400 when this
+  // decoration is sent with literal parentheses. Keep parentheses percent-encoded.
+  return encodeURIComponent(value).replace(/\(/g, '%28').replace(/\)/g, '%29');
+}
+
+function salesnavThreadUrl(threadId) {
+  return threadId ? `https://www.linkedin.com/sales/inbox/${encodeURIComponent(threadId)}` : '';
+}
+
+function threadListUrl({ count = PAGE_SIZE, pageStartsAt = '' } = {}) {
+  let url = `${THREADS_BASE}?decoration=${encodeRestliDecoration(THREAD_DECORATION)}&count=${count}&filter=INBOX&q=filter`;
+  if (pageStartsAt) url += `&pageStartsAt=${encodeURIComponent(pageStartsAt)}`;
+  return url;
+}
+
+function getThreadParticipants(thread) {
+  const resolution = thread?.participantsResolutionResults || {};
+  const participants = Array.isArray(thread?.participants) ? thread.participants : Object.keys(resolution);
+  return participants.map((urn) => resolution[urn] || { entityUrn: urn }).filter(Boolean);
+}
+
+function isSelfParticipant(profile) {
+  const degree = String(profile?.degree ?? '').trim();
+  return degree === '0';
+}
+
+function otherParticipantName(thread) {
+  const participants = getThreadParticipants(thread);
+  const other = participants.find((p) => !isSelfParticipant(p)) || participants[0];
+  return normalizeWhitespace(other?.fullName || [other?.firstName, other?.lastName].filter(Boolean).join(' '));
+}
+
+function parseSalesnavThreads(json) {
+  if (!json || typeof json !== 'object' || !Array.isArray(json.elements)) {
+    throw new CommandExecutionError('Sales Navigator messaging threads API returned malformed payload');
+  }
+  return json.elements.map((thread) => {
+    if (!thread || typeof thread !== 'object') {
+      throw new CommandExecutionError('Sales Navigator messaging threads API returned malformed thread row');
+    }
+    const messages = Array.isArray(thread?.messages) ? thread.messages : [];
+    const lastMessage = messages[0] || {};
+    const deliveredAt = Number(lastMessage.deliveredAt || thread?.nextPageStartsAt || 0);
+    const threadId = normalizeWhitespace(thread?.id || '');
+    if (!threadId) {
+      throw new CommandExecutionError('Sales Navigator messaging thread row missing id');
+    }
+    return {
+      thread_id: threadId,
+      thread_url: salesnavThreadUrl(threadId),
+      person_name: otherParticipantName(thread),
+      last_message_snippet: normalizeWhitespace(lastMessage.body || lastMessage.subject || '').slice(0, 300),
+      last_activity_time: deliveredAt ? new Date(deliveredAt).toISOString() : '',
+      unread: Number(thread?.unreadMessageCount || 0) > 0,
+      unread_count: Number(thread?.unreadMessageCount || 0),
+      total_message_count: Number(thread?.totalMessageCount || messages.length || 0),
+      archived: Boolean(thread?.archived),
+      next_page_starts_at: normalizeWhitespace(thread?.nextPageStartsAt || ''),
+      participants: getThreadParticipants(thread).map((p) => ({
+        name: normalizeWhitespace(p.fullName || [p.firstName, p.lastName].filter(Boolean).join(' ')),
+        entity_urn: normalizeWhitespace(p.entityUrn || ''),
+        object_urn: normalizeWhitespace(p.objectUrn || ''),
+        degree: normalizeWhitespace(p.degree ?? ''),
+      })),
+    };
+  });
+}
+
+function fetchJsonScript(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',
+        },
+      });
+      const text = await res.text();
+      let json = null;
+      try { json = text ? JSON.parse(text) : null; } catch (_) { json = null; }
+      if (res.status === 401 || res.status === 403) return { authRequired: true, status: res.status, text };
+      if (!res.ok) return { error: 'HTTP ' + res.status, status: res.status, text, json };
+      return { status: res.status, json };
+    } catch (e) {
+      return { error: 'fetch failed: ' + ((e && e.message) || String(e)) };
+    }
+  })()`;
+}
+
+export async function getCsrf(page) {
+  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.');
+  return jsession.replace(/^\"|\"$/g, '');
+}
+
+export async function fetchSalesnavJson(page, csrf, url, label) {
+  const result = unwrapEvaluateResult(await page.evaluate(fetchJsonScript(url, csrf)));
+  if (result?.authRequired) throw new AuthRequiredError(LINKEDIN_DOMAIN, `${label} authentication failed (HTTP ${result.status || 'auth_required'}).`);
+  if (result?.error || !result?.json) throw new CommandExecutionError(`${label} returned an unexpected response`, `${result?.error || 'no_json'}\n${normalizeWhitespace(result?.text || '').slice(0, 500)}`);
+  return result.json;
+}
+
+export async function fetchInboxRows(page, { limit = DEFAULT_LIMIT, maxPages = 30 } = {}) {
+  const csrf = await getCsrf(page);
+  const rows = [];
+  const seen = new Set();
+  let pageStartsAt = '';
+  let pagesFetched = 0;
+  let hasMorePages = false;
+  while (rows.length < limit && pagesFetched < maxPages) {
+    const json = await fetchSalesnavJson(page, csrf, threadListUrl({ count: PAGE_SIZE, pageStartsAt }), 'Sales Navigator messaging threads API');
+    pagesFetched += 1;
+    const pageRows = parseSalesnavThreads(json);
+    if (pageRows.length === 0) break;
+    for (const row of pageRows) {
+      if (seen.has(row.thread_id)) continue;
+      seen.add(row.thread_id);
+      rows.push(row);
+      if (rows.length >= limit) break;
+    }
+    const last = pageRows[pageRows.length - 1];
+    const next = last?.next_page_starts_at;
+    hasMorePages = Boolean(next);
+    if (!next) break;
+    if (next === pageStartsAt) {
+      throw new CommandExecutionError('Sales Navigator messaging threads API returned the same cursor twice');
+    }
+    pageStartsAt = next;
+  }
+  if (rows.length < limit && hasMorePages && pagesFetched >= maxPages) {
+    throw new CommandExecutionError(`Sales Navigator messaging threads API reached the ${maxPages}-page safety cap before collecting ${limit} conversations`);
+  }
+  return rows.slice(0, limit).map((row, index) => ({ ...row, rank: index + 1 }));
+}
+
+export { THREAD_DECORATION, THREADS_BASE };
+
+cli({
+  site: 'linkedin',
+  name: 'salesnav-inbox',
+  access: 'read',
+  description: 'List LinkedIn Sales Navigator message conversations with API pagination',
+  domain: LINKEDIN_DOMAIN,
+  strategy: Strategy.UI,
+  browser: true,
+  args: [
+    { name: 'limit', type: 'number', default: DEFAULT_LIMIT, help: 'Maximum conversations to return (1-500)' },
+    { name: 'max-pages', type: 'number', default: 30, help: 'Maximum Sales Navigator API pages to fetch' },
+    { name: 'unread-only', type: 'bool', default: false, help: 'Return only unread conversations' },
+  ],
+  columns: ['rank', 'thread_id', 'thread_url', 'person_name', 'last_message_snippet', 'last_activity_time', 'unread', 'unread_count', 'total_message_count', 'archived', 'participants', 'next_page_starts_at'],
+  func: async (page, args) => {
+    if (!page) throw new CommandExecutionError('Browser session required for linkedin salesnav-inbox');
+    const limit = parseLimit(args.limit);
+    const maxPages = parseLimit(args['max-pages'], 30);
+    await page.goto(SALES_INBOX_URL);
+    await page.wait(4);
+    let rows = await fetchInboxRows(page, { limit, maxPages });
+    if (args['unread-only']) rows = rows.filter((row) => row.unread);
+    if (rows.length === 0) {
+      if (args['unread-only']) return [];
+      throw new EmptyResultError('linkedin salesnav-inbox', 'No Sales Navigator conversations were found.');
+    }
+    return rows.slice(0, limit).map((row, index) => ({ ...row, rank: index + 1 }));
+  },
+});
+
+export const __test__ = {
+  THREAD_DECORATION,
+  normalizeWhitespace,
+  parseLimit,
+  encodeRestliDecoration,
+  salesnavThreadUrl,
+  threadListUrl,
+  parseSalesnavThreads,
+  fetchInboxRows,
+};

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

@@ -0,0 +1,113 @@
+import { describe, expect, it } from 'vitest';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import './salesnav-inbox.js';
+
+const {
+  THREAD_DECORATION,
+  encodeRestliDecoration,
+  parseLimit,
+  parseSalesnavThreads,
+  salesnavThreadUrl,
+  threadListUrl,
+} = await import('./salesnav-inbox.js').then((m) => m.__test__);
+
+describe('linkedin salesnav-inbox command', () => {
+  it('percent-encodes Rest.li decoration parentheses for Sales Navigator messaging', () => {
+    const encoded = encodeRestliDecoration('(id,messages*(body))');
+    expect(encoded).toBe('%28id%2Cmessages*%28body%29%29');
+    expect(encoded).not.toContain('(');
+    expect(encoded).not.toContain(')');
+  });
+
+  it('builds the paginated salesApiMessagingThreads inbox URL', () => {
+    const url = threadListUrl({ count: 20, pageStartsAt: '1779070755626' });
+    expect(url).toContain('/sales-api/salesApiMessagingThreads?');
+    expect(url).toContain('q=filter');
+    expect(url).toContain('filter=INBOX');
+    expect(url).toContain('count=20');
+    expect(url).toContain('pageStartsAt=1779070755626');
+    expect(url).toContain(encodeRestliDecoration(THREAD_DECORATION));
+  });
+
+  it('validates limits without silent clamping', () => {
+    expect(parseLimit(undefined)).toBe(40);
+    expect(parseLimit(12)).toBe(12);
+    expect(() => parseLimit(0)).toThrow();
+    expect(() => parseLimit(501)).toThrow();
+    expect(() => parseLimit('abc')).toThrow();
+  });
+
+  it('parses Sales Navigator thread rows with other participant and unread state', () => {
+    const rows = parseSalesnavThreads({ elements: [{
+      id: '2-thread',
+      unreadMessageCount: 1,
+      archived: false,
+      totalMessageCount: 2,
+      nextPageStartsAt: 1778206803669,
+      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)': {
+          entityUrn: 'urn:li:fs_salesProfile:(OTHER,NAME_SEARCH,T1)',
+          firstName: 'Rachael',
+          lastName: 'Stolberg',
+          fullName: 'Rachael Stolberg',
+          degree: 2,
+        },
+        'urn:li:fs_salesProfile:(SELF,NAME_SEARCH,T2)': {
+          entityUrn: 'urn:li:fs_salesProfile:(SELF,NAME_SEARCH,T2)',
+          firstName: 'Hanzi',
+          lastName: 'Li',
+          fullName: 'Hanzi Li',
+          degree: 0,
+        },
+      },
+      messages: [{
+        id: 'msg-1',
+        author: 'urn:li:fs_salesProfile:(OTHER,NAME_SEARCH,T1)',
+        body: 'Hi hanzi, happy to chat',
+        deliveredAt: 1778206803669,
+      }],
+    }] });
+    expect(rows).toHaveLength(1);
+    expect(rows[0]).toMatchObject({
+      thread_id: '2-thread',
+      thread_url: salesnavThreadUrl('2-thread'),
+      person_name: 'Rachael Stolberg',
+      last_message_snippet: 'Hi hanzi, happy to chat',
+      last_activity_time: '2026-05-08T02:20:03.669Z',
+      unread: true,
+      unread_count: 1,
+      total_message_count: 2,
+    });
+  });
+
+  it('does not hard-code a specific account name as the inbox owner', () => {
+    const rows = parseSalesnavThreads({ elements: [{
+      id: '2-thread',
+      participants: [
+        'urn:li:fs_salesProfile:(HANZI,NAME_SEARCH,T1)',
+        'urn:li:fs_salesProfile:(ME,NAME_SEARCH,T2)',
+      ],
+      participantsResolutionResults: {
+        'urn:li:fs_salesProfile:(HANZI,NAME_SEARCH,T1)': {
+          fullName: 'Hanzi Li',
+          degree: 2,
+        },
+        'urn:li:fs_salesProfile:(ME,NAME_SEARCH,T2)': {
+          fullName: 'Current User',
+          degree: 0,
+        },
+      },
+      messages: [],
+    }] });
+    expect(rows[0].person_name).toBe('Hanzi Li');
+  });
+
+  it('fails typed on malformed thread payloads and missing thread identity', () => {
+    expect(() => parseSalesnavThreads({})).toThrow(CommandExecutionError);
+    expect(() => parseSalesnavThreads({ elements: [{}] })).toThrow(CommandExecutionError);
+  });
+});

package/clis/linkedin/salesnav-message.js

@@ -0,0 +1,360 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+
+const LINKEDIN_DOMAIN = 'www.linkedin.com';
+const SALES_HOME = 'https://www.linkedin.com/sales/';
+const PROFILE_DECO = '(entityUrn,objectUrn,firstName,lastName,fullName,headline,degree,inmailRestriction,memberBadges,defaultPosition)';
+const CREDITS_URL = 'https://www.linkedin.com/sales-api/salesApiCredits?q=findCreditGrant&creditGrantType=LSS_INMAIL';
+const MESSAGE_ACTION_URL = 'https://www.linkedin.com/sales-api/salesApiMessageActions?action=createMessage';
+
+function normalizeWhitespace(value) {
+  return String(value ?? '').replace(/[\u00a0\u202f]/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 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 parseSalesProfileUrn(value) {
+  const raw = normalizeWhitespace(value);
+  const match = raw.match(/^urn:li:fs_salesProfile:\(([^,()]+),([^,()]+),([^,()]+)\)$/);
+  if (!match) return null;
+  if (!isResolvedSalesProfileParts(match[1], match[2], match[3])) return null;
+  return { profileId: match[1], authType: match[2], authToken: match[3], entityUrn: raw };
+}
+
+function isResolvedSalesProfileParts(profileId, authType, authToken) {
+  return [profileId, authType, authToken].every((part) => {
+    const clean = normalizeWhitespace(part).toLowerCase();
+    return clean && clean !== 'undefined' && clean !== 'null' && clean !== 'not_available';
+  });
+}
+
+function salesLeadUrlFromParts({ profileId, authType, authToken }) {
+  return `https://www.linkedin.com/sales/lead/${encodeURIComponent(profileId)},${encodeURIComponent(authType)},${encodeURIComponent(authToken)}`;
+}
+
+function parseRecipient(value) {
+  const raw = normalizeWhitespace(value);
+  const urn = parseSalesProfileUrn(raw);
+  if (urn) return urn;
+  try {
+    const url = new URL(raw);
+    if (url.protocol !== 'https:' || url.username || url.password || url.port || !isLinkedInHost(url.hostname)) return null;
+    const salesMatch = url.pathname.match(/^\/sales\/lead\/([^,/]+),([^,/]+),([^/]+)\/?$/i);
+    if (salesMatch) {
+      const profileId = decodeURIComponent(salesMatch[1]);
+      const authType = decodeURIComponent(salesMatch[2]);
+      const authToken = decodeURIComponent(salesMatch[3]);
+      if (!isResolvedSalesProfileParts(profileId, authType, authToken)) return null;
+      return { profileId, authType, authToken, entityUrn: `urn:li:fs_salesProfile:(${profileId},${authType},${authToken})` };
+    }
+    const profileMatch = url.pathname.match(/^\/in\/([^/]+)\/?$/i);
+    if (profileMatch) {
+      return { profileId: decodeURIComponent(profileMatch[1]), authType: '', authToken: '', entityUrn: '' };
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+function encodeRestliDecoration(value) {
+  return encodeURIComponent(value).replace(/\(/g, '%28').replace(/\)/g, '%29');
+}
+
+function profileApiUrl(recipient) {
+  if (!recipient?.profileId || !recipient?.authType || !recipient?.authToken) return '';
+  const key = `(profileId:${recipient.profileId},authType:${recipient.authType},authToken:${recipient.authToken})`;
+  return `https://www.linkedin.com/sales-api/salesApiProfiles/${key}?decoration=${encodeRestliDecoration(PROFILE_DECO)}`;
+}
+
+function randomTrackingId() {
+  const bytes = new Uint8Array(8);
+  if (globalThis.crypto?.getRandomValues) globalThis.crypto.getRandomValues(bytes);
+  else for (let i = 0; i < bytes.length; i += 1) bytes[i] = Math.floor(Math.random() * 256);
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+}
+
+function buildCreateMessagePayload({ recipientUrn, subject, body, trackingId = randomTrackingId(), copyToCrm = false }) {
+  const cleanRecipient = normalizeWhitespace(recipientUrn);
+  if (!parseSalesProfileUrn(cleanRecipient)) throw new ArgumentError('--recipient must resolve to a Sales Navigator lead urn');
+  const cleanSubject = normalizeWhitespace(subject);
+  const cleanBody = String(body ?? '').trim();
+  if (!cleanSubject) throw new ArgumentError('--subject is required');
+  if (!cleanBody) throw new ArgumentError('--body is required');
+  if (cleanSubject.length > 200) throw new ArgumentError('--subject must be 200 characters or fewer');
+  if (cleanBody.length > 1900) throw new ArgumentError('--body must be 1900 characters or fewer');
+  return {
+    createMessageRequest: {
+      recipients: [cleanRecipient],
+      subject: cleanSubject,
+      body: cleanBody,
+      copyToCrm: Boolean(copyToCrm),
+      trackingId,
+    },
+  };
+}
+
+function extractRemainingCredits(json) {
+  const elements = Array.isArray(json?.elements) ? json.elements : [];
+  const inmailGrant = elements.find((el) => el?.type === 'LSS_INMAIL' && Number.isInteger(el.value));
+  if (inmailGrant) return inmailGrant.value;
+  const candidates = [];
+  const visit = (value) => {
+    if (value === null || value === undefined) return;
+    if (typeof value === 'number' && Number.isFinite(value)) candidates.push(value);
+    if (Array.isArray(value)) value.forEach(visit);
+    else if (typeof value === 'object') {
+      for (const [key, child] of Object.entries(value)) {
+        if (/remaining|available|balance|value/i.test(key) && typeof child === 'number') candidates.unshift(child);
+        else if (!/^count$|^start$|^id$/i.test(key)) visit(child);
+      }
+    }
+  };
+  visit(json);
+  return candidates.find((n) => Number.isInteger(n) && n >= 0) ?? null;
+}
+
+function fetchJsonScript(url, csrf, options = {}) {
+  return String.raw`(async () => {
+    const headers = {
+      'csrf-token': ${JSON.stringify(csrf)},
+      'x-restli-protocol-version': '2.0.0',
+      accept: ${JSON.stringify(options.accept || 'application/json')},
+      ...((${JSON.stringify(Boolean(options.body))}) ? { 'content-type': 'application/json' } : {}),
+    };
+    try {
+      const res = await fetch(${JSON.stringify(url)}, {
+        credentials: 'include',
+        method: ${JSON.stringify(options.method || 'GET')},
+        headers,
+        body: ${options.body ? JSON.stringify(JSON.stringify(options.body)) : 'undefined'},
+      });
+      const text = await res.text();
+      let json = null;
+      try { json = text ? JSON.parse(text) : null; } catch (_) { json = null; }
+      if (res.status === 401 || res.status === 403) return ['auth', res.status, json, text];
+      if (!res.ok) return ['error', res.status, json, text, 'HTTP ' + res.status];
+      return ['ok', res.status, json, text];
+    } catch (e) {
+      return ['error', 0, null, '', 'fetch failed: ' + ((e && e.message) || String(e))];
+    }
+  })()`;
+}
+
+function requireFetchResult(result, label, { requireJson = true } = {}) {
+  if (Array.isArray(result)) {
+    const [kind, status, json, text, error] = result;
+    result = {
+      authRequired: kind === 'auth',
+      error: kind === 'error' ? error || `HTTP ${status}` : '',
+      status,
+      json,
+      text,
+    };
+  }
+  if (result?.authRequired) throw new AuthRequiredError(LINKEDIN_DOMAIN, `${label} auth failed.`);
+  if (result?.error) throw new CommandExecutionError(`${label} failed`, result.error);
+  if (!result || typeof result !== 'object' || Array.isArray(result)) {
+    throw new CommandExecutionError(`${label} returned malformed response`);
+  }
+  if (requireJson && (!result.json || typeof result.json !== 'object' || Array.isArray(result.json))) {
+    throw new CommandExecutionError(`${label} returned malformed response`, 'missing_json');
+  }
+  return result;
+}
+
+function salesPageShowsSentMessage(text, recipientName) {
+  const normalizedText = normalizeWhitespace(text);
+  const firstName = normalizeWhitespace(recipientName).split(' ')[0];
+  return normalizedText.includes('You sent a Sales Navigator message')
+    && (!firstName || normalizedText.includes(firstName));
+}
+
+async function getCsrf(page) {
+  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.');
+  return jsession.replace(/^\"|\"$/g, '');
+}
+
+async function resolveRecipient(page, parsed, csrf) {
+  if (!parsed) throw new ArgumentError('--recipient must be a Sales Navigator lead URL, Sales Navigator profile URL, LinkedIn /in/ URL, or urn:li:fs_salesProfile:(...)');
+  if (parsed.entityUrn && parsed.authType && parsed.authToken) return parsed;
+
+  await page.goto(`https://www.linkedin.com/sales/lead/${encodeURIComponent(parsed.profileId)}`);
+  await page.wait(6);
+  const probe = unwrapEvaluateResult(await page.evaluate(String.raw`(() => {
+    const href = location.href;
+    const text = document.body ? document.body.innerText : '';
+    const resourceUrns = Array.from(performance.getEntriesByType('resource'))
+      .map((entry) => entry.name)
+      .filter((name) => name.includes('/sales-api/salesApiProfiles/'))
+      .slice(-20);
+    return { href, text: text.slice(0, 1000), resourceUrns };
+  })()`));
+    const urlMatch = String(probe?.href || '').match(/\/sales\/lead\/([^,/]+),([^,/]+),([^/?#]+)/i);
+  if (urlMatch && isResolvedSalesProfileParts(urlMatch[1], urlMatch[2], urlMatch[3])) {
+    return {
+      profileId: decodeURIComponent(urlMatch[1]),
+      authType: decodeURIComponent(urlMatch[2]),
+      authToken: decodeURIComponent(urlMatch[3]),
+      entityUrn: `urn:li:fs_salesProfile:(${decodeURIComponent(urlMatch[1])},${decodeURIComponent(urlMatch[2])},${decodeURIComponent(urlMatch[3])})`,
+    };
+  }
+  for (const resource of probe?.resourceUrns || []) {
+    const resourceMatch = String(resource).match(/profileId:([^,)]+),authType:([^,)]+),authToken:([^,)]+)\)/);
+    if (resourceMatch && resourceMatch[1] === parsed.profileId) {
+      return {
+        profileId: resourceMatch[1],
+        authType: resourceMatch[2],
+        authToken: resourceMatch[3],
+        entityUrn: `urn:li:fs_salesProfile:(${resourceMatch[1]},${resourceMatch[2]},${resourceMatch[3]})`,
+      };
+    }
+  }
+  void csrf;
+  throw new CommandExecutionError('Could not resolve Sales Navigator auth token for recipient', `Observed URL: ${probe?.href || 'url_not_available'}\nBody: ${normalizeWhitespace(probe?.text || '').slice(0, 500)}`);
+}
+
+function profileSummary(json) {
+  const data = json?.data || json || {};
+  const pos = data.defaultPosition || (Array.isArray(data.positions) ? data.positions.find((p) => p.current) || data.positions[0] : {}) || {};
+  return {
+    recipient: normalizeWhitespace(data.fullName || [data.firstName, data.lastName].filter(Boolean).join(' ')),
+    title: normalizeWhitespace(pos.title || data.headline || ''),
+    company: normalizeWhitespace(pos.companyName || pos.company?.name || ''),
+    degree: normalizeWhitespace(data.degree || ''),
+    inmail_restriction: normalizeWhitespace(data.inmailRestriction || ''),
+    open_link: Boolean(data.memberBadges?.openLink),
+  };
+}
+
+function requireProfileSummary(json) {
+  const summary = profileSummary(json);
+  if (!summary.recipient) {
+    throw new CommandExecutionError('Sales Navigator profile lookup returned malformed profile data', 'missing_recipient_name');
+  }
+  return summary;
+}
+
+cli({
+  site: 'linkedin',
+  name: 'salesnav-message',
+  access: 'write',
+  description: 'Send or dry-run a LinkedIn Sales Navigator InMail to a lead using the Sales Navigator messaging API',
+  domain: LINKEDIN_DOMAIN,
+  strategy: Strategy.UI,
+  browser: true,
+  args: [
+    { name: 'recipient', type: 'string', required: true, positional: true, help: 'Sales Navigator lead URL, LinkedIn /in/ URL from salesnav-search, or urn:li:fs_salesProfile:(...)' },
+    { name: 'subject', type: 'string', required: true, help: 'InMail subject' },
+    { name: 'body', type: 'string', required: true, help: 'InMail body' },
+    { name: 'send', type: 'bool', default: false, help: 'Actually send the InMail. Default is dry-run validation only.' },
+    { name: 'copy-to-crm', type: 'bool', default: false, help: 'Set Sales Navigator copyToCrm on the message request' },
+  ],
+  columns: ['status', 'recipient', 'title', 'company', 'credits_remaining', 'credits_before', 'credits_after', 'sent_in_salesnav', 'message_chars', 'subject_chars', 'recipient_urn', 'degree', 'inmail_restriction', 'open_link'],
+  func: async (page, args) => {
+    if (!page) throw new CommandExecutionError('Browser session required for linkedin salesnav-message');
+    const recipientArg = requireStringArg(args, 'recipient', '--recipient');
+    const subject = requireStringArg(args, 'subject', '--subject');
+    const body = String(args.body ?? '').trim();
+    if (!body) throw new ArgumentError('--body is required');
+
+    await page.goto(SALES_HOME);
+    await page.wait(4);
+    const csrf = await getCsrf(page);
+    const recipient = await resolveRecipient(page, parseRecipient(recipientArg), csrf);
+
+    let summary = { recipient: '', title: '', company: '', degree: '', inmail_restriction: '', open_link: false };
+    const profileUrl = profileApiUrl(recipient);
+    if (profileUrl) {
+      const profileResult = requireFetchResult(unwrapEvaluateResult(await page.evaluate(fetchJsonScript(profileUrl, csrf))), 'LinkedIn Sales Navigator profile API');
+      summary = requireProfileSummary(profileResult.json);
+    }
+    if (summary.inmail_restriction && summary.inmail_restriction !== 'NO_RESTRICTION') {
+      throw new CommandExecutionError('Sales Navigator InMail blocked by recipient restriction', summary.inmail_restriction);
+    }
+
+    const creditsResult = requireFetchResult(unwrapEvaluateResult(await page.evaluate(fetchJsonScript(CREDITS_URL, csrf))), 'LinkedIn Sales Navigator credits API');
+    const creditsRemaining = extractRemainingCredits(creditsResult?.json);
+
+    const payload = buildCreateMessagePayload({ recipientUrn: recipient.entityUrn, subject, body, copyToCrm: args['copy-to-crm'] });
+    if (!args.send) {
+      return [{
+        status: 'validated_dry_run',
+        recipient: summary.recipient,
+        title: summary.title,
+        company: summary.company,
+        credits_remaining: creditsRemaining,
+        credits_before: creditsRemaining,
+        credits_after: '',
+        sent_in_salesnav: false,
+        message_chars: body.length,
+        subject_chars: subject.length,
+        recipient_urn: recipient.entityUrn,
+        degree: summary.degree,
+        inmail_restriction: summary.inmail_restriction,
+        open_link: summary.open_link,
+      }];
+    }
+
+    const sendResult = requireFetchResult(unwrapEvaluateResult(await page.evaluate(fetchJsonScript(MESSAGE_ACTION_URL, csrf, {
+      method: 'POST',
+      accept: 'application/vnd.linkedin.normalized+json+2.1',
+      body: payload,
+    }))), 'LinkedIn Sales Navigator message API', { requireJson: false });
+    void sendResult;
+    await page.wait(3);
+    const creditsAfterResult = requireFetchResult(unwrapEvaluateResult(await page.evaluate(fetchJsonScript(CREDITS_URL, csrf))), 'LinkedIn Sales Navigator credits API after send');
+    const creditsAfter = extractRemainingCredits(creditsAfterResult?.json);
+    await page.goto(salesLeadUrlFromParts(recipient));
+    await page.wait(6);
+    const salesPageText = unwrapEvaluateResult(await page.evaluate('document.body ? document.body.innerText : ""'));
+    const sentInSalesNav = salesPageShowsSentMessage(salesPageText, summary.recipient);
+    if (!sentInSalesNav) throw new CommandExecutionError('Sales Navigator post-send verification failed', 'Sent activity was not found on the Sales Navigator lead page.');
+    return [{
+      status: 'sent',
+      recipient: summary.recipient,
+      title: summary.title,
+      company: summary.company,
+      credits_remaining: creditsAfter,
+      credits_before: creditsRemaining,
+      credits_after: creditsAfter,
+      sent_in_salesnav: sentInSalesNav,
+      message_chars: body.length,
+      subject_chars: subject.length,
+      recipient_urn: recipient.entityUrn,
+      degree: summary.degree,
+      inmail_restriction: summary.inmail_restriction,
+      open_link: summary.open_link,
+    }];
+  },
+});
+
+export const __test__ = {
+  normalizeWhitespace,
+  parseSalesProfileUrn,
+  isResolvedSalesProfileParts,
+  parseRecipient,
+  salesLeadUrlFromParts,
+  profileApiUrl,
+  buildCreateMessagePayload,
+  extractRemainingCredits,
+  profileSummary,
+  requireProfileSummary,
+  salesPageShowsSentMessage,
+};