@jackwener/opencli 1.7.22 → 1.8.1

package/clis/linkedin/profile-read.js

@@ -0,0 +1,148 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import {
+  assertLinkedInAuthenticated,
+  assertSafeLinkedinUrl,
+  compactRepeatedText,
+  normalizeWhitespace,
+  unwrapEvaluateResult,
+} from './shared.js';
+
+function normalizeProfileReadUrl(value) {
+  const url = assertSafeLinkedinUrl(value || 'https://www.linkedin.com/in/me/', 'profile-url', '/in/me/');
+  const parsed = new URL(url);
+  if (!/^\/in\/[^/?#]+\/?$/.test(parsed.pathname)) {
+    throw new CommandExecutionError('LinkedIn profile-read requires a /in/<handle>/ profile URL');
+  }
+  return parsed.toString();
+}
+
+function buildProfileExtractionScript() {
+  return String.raw`(() => {
+    const clean = (s) => String(s || '').replace(/[\u00a0\u202f]+/g, ' ').replace(/\s+/g, ' ').trim();
+    const compact = (s) => {
+      const text = clean(s);
+      if (!text) return '';
+      if (text.length % 2 === 0 && text.slice(0, text.length / 2) === text.slice(text.length / 2)) {
+        return text.slice(0, text.length / 2);
+      }
+      return text;
+    };
+    const readSection = (headingPattern) => {
+      const headings = Array.from(document.querySelectorAll('section h2, section h3, h2, h3'));
+      const heading = headings.find((el) => headingPattern.test(clean(el.innerText || el.textContent || '')));
+      const section = heading?.closest('section');
+      if (!section) return '';
+      const text = clean(section.innerText || section.textContent || '');
+      return clean(text.replace(headingPattern, '').replace(/\bShow all.*$/i, '').replace(/\bSee more.*$/i, ''));
+    };
+    const nameHeading = document.querySelector('main h1, main h2');
+    const intro = nameHeading?.closest('section') || document.querySelector('main section') || document.body;
+    const lines = (intro.innerText || intro.textContent || '').split(/\n+/).map(clean).filter(Boolean);
+    const name = compact(clean(nameHeading?.innerText || nameHeading?.textContent || lines[0] || ''));
+    const skipIntro = (line) => !line
+      || line === name
+      || /^(1st|2nd|3rd|contact info|message|more|follow|connect|open to|add section|enhance profile|resources|self employed)$/i.test(line)
+      || /^\d[\d,]*\s+(followers|connections)/i.test(line)
+      || line === '·';
+    const headline = compact(lines.find((line) => !skipIntro(line) && line.length > 20) || '');
+    const locationText = lines.find((line) => /(area|india|jaipur|bangalore|bengaluru|delhi|mumbai|hyderabad|pune)/i.test(line) && line.length < 120) || '';
+    const about = readSection(/^About$/i);
+    const experience = readSection(/^Experience$/i);
+    const education = readSection(/^Education$/i);
+    const featured = readSection(/^Featured$/i);
+    const services = readSection(/^Services$/i) || readSection(/^Providing services$/i);
+    return {
+      profile_url: window.location.href,
+      name,
+      headline,
+      location: locationText,
+      about,
+      experience,
+      education,
+      services,
+      featured,
+    };
+  })()`;
+}
+
+function buildAboutEditExtractionScript() {
+  return String.raw`(() => {
+    const clean = (s) => String(s || '').replace(/[\u00a0\u202f]+/g, ' ').replace(/\s+/g, ' ').trim();
+    const dialog = document.querySelector('dialog') || document;
+    const editor = dialog.querySelector('[contenteditable="true"]');
+    const about = Array.from(editor?.querySelectorAll('p') || [])
+      .map((p) => clean(p.innerText || p.textContent || ''))
+      .join('\n')
+      .trim();
+    const about_skills = Array.from(dialog.querySelectorAll('[role="listitem"][aria-label]'))
+      .map((el) => clean(el.getAttribute('aria-label') || ''))
+      .filter(Boolean);
+    const about_character_count = Array.from(dialog.querySelectorAll('span, p'))
+      .map((el) => clean(el.innerText || el.textContent || ''))
+      .find((text) => /^\d[\d,]*\/2,600$/.test(text)) || '';
+    return { about, about_skills, about_character_count };
+  })()`;
+}
+
+function normalizeProfile(row) {
+  if (!row || typeof row !== 'object') {
+    throw new CommandExecutionError('LinkedIn profile-read returned malformed extraction payload');
+  }
+  const name = compactRepeatedText(row.name);
+  if (!name) throw new CommandExecutionError('LinkedIn profile-read could not find a profile name');
+  return {
+    profile_url: normalizeWhitespace(row.profile_url),
+    name,
+    headline: compactRepeatedText(row.headline),
+    location: normalizeWhitespace(row.location),
+    about: normalizeWhitespace(row.about),
+    about_character_count: normalizeWhitespace(row.about_character_count),
+    about_skills: Array.isArray(row.about_skills) ? row.about_skills.map(normalizeWhitespace).filter(Boolean).join('; ') : '',
+    experience: normalizeWhitespace(row.experience),
+    education: normalizeWhitespace(row.education),
+    services: normalizeWhitespace(row.services),
+    featured: normalizeWhitespace(row.featured),
+  };
+}
+
+cli({
+  site: 'linkedin',
+  name: 'profile-read',
+  access: 'read',
+  description: 'Read visible LinkedIn profile sections: headline, About, experience, education, services, and featured sections',
+  domain: 'www.linkedin.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    { name: 'profile-url', type: 'string', required: false, help: 'LinkedIn /in/<handle>/ profile URL. Defaults to /in/me/.' },
+  ],
+  columns: ['profile_url', 'name', 'headline', 'location', 'about', 'about_character_count', 'about_skills', 'experience', 'education', 'services', 'featured'],
+  func: async (page, args) => {
+    if (!page) throw new CommandExecutionError('Browser session required for linkedin profile-read');
+    const profileUrl = normalizeProfileReadUrl(args['profile-url']);
+    const shouldReadEditor = !normalizeWhitespace(args['profile-url']);
+    await page.goto(profileUrl);
+    await page.wait(5);
+    await assertLinkedInAuthenticated(page, 'LinkedIn profile-read');
+    await page.autoScroll({ times: 4, delayMs: 700 });
+    await page.wait(1);
+    const row = unwrapEvaluateResult(await page.evaluate(buildProfileExtractionScript()));
+    let aboutEdit = {};
+    if (shouldReadEditor) {
+      const currentProfileUrl = normalizeWhitespace(row?.profile_url) || profileUrl;
+      const profilePath = new URL(currentProfileUrl).pathname.replace(/\/?$/, '/');
+      const aboutEditUrl = new URL(`${profilePath}edit/forms/summary/new/`, 'https://www.linkedin.com').toString();
+      await page.goto(aboutEditUrl);
+      await page.wait(4);
+      await assertLinkedInAuthenticated(page, 'LinkedIn profile-read about editor');
+      aboutEdit = unwrapEvaluateResult(await page.evaluate(buildAboutEditExtractionScript()));
+    }
+    return [normalizeProfile({ ...row, ...aboutEdit })];
+  },
+});
+
+export const __test__ = {
+  normalizeProfileReadUrl,
+  normalizeProfile,
+};

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

@@ -0,0 +1,77 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import './profile-read.js';
+
+const { normalizeProfileReadUrl, normalizeProfile } = await import('./profile-read.js').then((m) => m.__test__);
+
+describe('linkedin profile-read adapter', () => {
+  const command = getRegistry().get('linkedin/profile-read');
+
+  it('registers command shape', () => {
+    expect(command).toBeDefined();
+    expect(command.strategy).toBe('cookie');
+    expect(command.browser).toBe(true);
+    expect(command.columns).toEqual([
+      'profile_url',
+      'name',
+      'headline',
+      'location',
+      'about',
+      'about_character_count',
+      'about_skills',
+      'experience',
+      'education',
+      'services',
+      'featured',
+    ]);
+  });
+
+  it('normalizes profile url default and explicit /in URL', () => {
+    expect(normalizeProfileReadUrl(undefined)).toBe('https://www.linkedin.com/in/me/');
+    expect(normalizeProfileReadUrl('https://www.linkedin.com/in/gauravsaxena1997?x=1')).toBe('https://www.linkedin.com/in/gauravsaxena1997?x=1');
+  });
+
+  it('rejects non-profile URLs', () => {
+    expect(() => normalizeProfileReadUrl('https://www.linkedin.com/jobs/')).toThrow(CommandExecutionError);
+  });
+
+  it('normalizes duplicated profile text and requires a name', () => {
+    expect(() => normalizeProfile({ name: '' })).toThrow(CommandExecutionError);
+    expect(normalizeProfile({
+      name: 'AliceAlice',
+      headline: 'EngineerEngineer',
+      about: '  Builds AI  ',
+      about_character_count: '1,100/2,600',
+      about_skills: ['AI', 'TypeScript'],
+    })).toMatchObject({
+      name: 'Alice',
+      headline: 'Engineer',
+      about: 'Builds AI',
+      about_character_count: '1,100/2,600',
+      about_skills: 'AI; TypeScript',
+    });
+  });
+
+  it('does not require edit access when reading an explicit profile URL', async () => {
+    const page = {
+      goto: vi.fn(async () => {}),
+      wait: vi.fn(async () => {}),
+      autoScroll: vi.fn(async () => {}),
+      evaluate: vi.fn()
+        .mockResolvedValueOnce(false)
+        .mockResolvedValueOnce({
+          profile_url: 'https://www.linkedin.com/in/alice/',
+          name: 'Alice',
+          headline: 'Engineer',
+          about: 'Builds products',
+        }),
+    };
+
+    await expect(command.func(page, { 'profile-url': 'https://www.linkedin.com/in/alice/' }))
+      .resolves.toMatchObject([{ name: 'Alice', about: 'Builds products' }]);
+    expect(page.goto).toHaveBeenCalledTimes(1);
+    expect(page.goto).toHaveBeenCalledWith('https://www.linkedin.com/in/alice/');
+    expect(page.goto.mock.calls.some(([url]) => String(url).includes('/edit/forms/'))).toBe(false);
+  });
+});

package/clis/linkedin/safe-send.js

@@ -0,0 +1,357 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { createHash } from 'node:crypto';
+
+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 normalizeName(value) {
+  return normalizeWhitespace(value)
+    .replace(/\s*[•·]\s*(?:1st|2nd|3rd\+?|degree connection).*$/i, '')
+    .replace(/\s+LinkedIn.*$/i, '')
+    .toLowerCase();
+}
+
+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 hashText(value) {
+  return createHash('sha256').update(normalizeWhitespace(value)).digest('hex');
+}
+
+function textContainsNormalized(haystack, needle) {
+  const h = normalizeWhitespace(haystack).toLowerCase();
+  const n = normalizeWhitespace(needle).toLowerCase();
+  return !n || h.includes(n);
+}
+
+function selectBestHeaderName(headerNames, expectedName) {
+  const expected = normalizeName(expectedName);
+  const names = (Array.isArray(headerNames) ? headerNames : [])
+    .map(normalizeWhitespace)
+    .filter(Boolean);
+  return names.find((name) => normalizeName(name) === expected) || names[0] || '';
+}
+
+function assessThreadSafety(probe, expected) {
+  const expectedName = normalizeWhitespace(expected.expectedName);
+  const actualName = selectBestHeaderName(probe?.headerNames, expectedName);
+  const expectedThreadUrl = canonicalizeLinkedInThreadUrl(expected.threadUrl);
+  const actualThreadUrl = canonicalizeLinkedInThreadUrl(probe?.url || '');
+  const bodyText = String(probe?.bodyText || '');
+
+  if (probe?.authRequired) {
+    return { ok: false, blockReason: 'auth_required', expectedValue: expectedName, actualValue: actualName, observedUrl: actualThreadUrl };
+  }
+
+  if (probe?.searchFailure || /we didn't find anything|no results found|no results for/i.test(bodyText)) {
+    return { ok: false, blockReason: 'search_failure_visible', expectedValue: expectedName, actualValue: actualName, observedUrl: actualThreadUrl };
+  }
+
+  if (expectedThreadUrl && actualThreadUrl && expectedThreadUrl !== actualThreadUrl) {
+    return { ok: false, blockReason: 'thread_url_mismatch', expectedValue: expectedThreadUrl, actualValue: actualThreadUrl, observedUrl: actualThreadUrl };
+  }
+
+  if (!actualName || normalizeName(actualName) !== normalizeName(expectedName)) {
+    return { ok: false, blockReason: 'recipient_header_mismatch', expectedValue: expectedName, actualValue: actualName, observedUrl: actualThreadUrl };
+  }
+
+  if (!probe?.composerFound) {
+    return { ok: false, blockReason: 'composer_not_found', expectedValue: expectedName, actualValue: actualName, observedUrl: actualThreadUrl };
+  }
+
+  const expectedLastHash = normalizeWhitespace(expected.expectedLastHash);
+  if (expectedLastHash && expectedLastHash !== probe?.latestMessageHash) {
+    return { ok: false, blockReason: 'latest_message_mismatch', expectedValue: expectedLastHash, actualValue: probe?.latestMessageHash || '', observedUrl: actualThreadUrl };
+  }
+
+  const expectedLastText = normalizeWhitespace(expected.expectedLastText);
+  if (expectedLastText && !textContainsNormalized(bodyText, expectedLastText)) {
+    return { ok: false, blockReason: 'latest_message_mismatch', expectedValue: expectedLastText, actualValue: '', observedUrl: actualThreadUrl };
+  }
+
+  return { ok: true, blockReason: 'verified', expectedValue: expectedName, actualValue: actualName, observedUrl: actualThreadUrl };
+}
+
+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 buildThreadProbeScript() {
+  return String.raw`(() => {
+    const marker = '__OPENCLI_LINKEDIN_PROBE__';
+    void marker;
+    const clean = (s) => String(s || '').replace(/[\u00a0\u202f]/g, ' ').replace(/\s+/g, ' ').trim();
+    const text = document.body ? (document.body.innerText || '') : '';
+    const lower = text.toLowerCase();
+    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 searchFailure = /we didn't find anything|no results found|no results for/i.test(text);
+
+    const headerCandidates = [];
+    const selectors = [
+      '.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 selectors) {
+      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 composer = Array.from(document.querySelectorAll('[contenteditable="true"][role="textbox"], div.msg-form__contenteditable[contenteditable="true"], [aria-label*="Write a message" i]'))
+      .find((el) => !el.closest('[aria-hidden="true"]') && el.offsetParent !== null);
+
+    const messageText = Array.from(document.querySelectorAll('.msg-s-message-list__event, .msg-s-event-listitem, [data-event-urn], .msg-s-message-group__meta, .msg-s-message-list-content'))
+      .map((el) => clean(el.innerText || el.textContent))
+      .filter(Boolean)
+      .join('\n');
+    const sourceText = messageText || text;
+    const sourceLines = sourceText.split(/\n+/).map(clean).filter(Boolean);
+    const lastMeaningfulLine = [...sourceLines].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: text,
+      composerFound: Boolean(composer),
+      composerText: composer ? clean(composer.innerText || composer.textContent) : '',
+      authRequired,
+      searchFailure,
+      latestMessageText: lastMeaningfulLine,
+      latestMessageHash: '',
+    };
+  })()`;
+}
+
+function buildFocusComposerScript() {
+  return String.raw`(() => {
+    const marker = '__OPENCLI_LINKEDIN_FOCUS_COMPOSER__';
+    void marker;
+    const clean = (s) => String(s || '').replace(/[\u00a0\u202f]/g, ' ').replace(/\s+/g, ' ').trim();
+    const composer = Array.from(document.querySelectorAll('[contenteditable="true"][role="textbox"], div.msg-form__contenteditable[contenteditable="true"], [aria-label*="Write a message" i]'))
+      .find((el) => !el.closest('[aria-hidden="true"]') && el.offsetParent !== null);
+    if (!composer) return { ok: false, error: 'composer_not_found', composerText: '' };
+    composer.focus();
+    composer.innerHTML = '';
+    composer.dispatchEvent(new InputEvent('input', { bubbles: true, inputType: 'deleteContentBackward', data: null }));
+    return { ok: true, composerText: clean(composer.innerText || composer.textContent) };
+  })()`;
+}
+
+function buildReadComposerScript() {
+  return String.raw`(() => {
+    const marker = '__OPENCLI_LINKEDIN_READ_COMPOSER__';
+    void marker;
+    const clean = (s) => String(s || '').replace(/[\u00a0\u202f]/g, ' ').replace(/\s+/g, ' ').trim();
+    const composer = Array.from(document.querySelectorAll('[contenteditable="true"][role="textbox"], div.msg-form__contenteditable[contenteditable="true"], [aria-label*="Write a message" i]'))
+      .find((el) => !el.closest('[aria-hidden="true"]') && el.offsetParent !== null);
+    return { ok: Boolean(composer), composerText: composer ? clean(composer.innerText || composer.textContent) : '' };
+  })()`;
+}
+
+function buildClickSendScript() {
+  return String.raw`(() => {
+    const marker = '__OPENCLI_LINKEDIN_CLICK_SEND__';
+    void marker;
+    const buttons = Array.from(document.querySelectorAll('button'));
+    const send = buttons.find((button) => {
+      const text = (button.innerText || button.textContent || button.getAttribute('aria-label') || '').trim().toLowerCase();
+      return text === 'send' || text === 'send message';
+    });
+    if (!send) return { ok: false, error: 'send_button_not_found', sent: false };
+    if (send.disabled || send.getAttribute('aria-disabled') === 'true') return { ok: false, error: 'send_button_disabled', sent: false };
+    send.click();
+    return { ok: true, sent: true };
+  })()`;
+}
+
+async function probeThread(page) {
+  const result = unwrapEvaluateResult(await page.evaluate(buildThreadProbeScript()));
+  const latestText = normalizeWhitespace(result?.latestMessageText || '');
+  return {
+    ...(result || {}),
+    latestMessageText: latestText,
+    latestMessageHash: latestText ? hashText(latestText) : '',
+  };
+}
+
+cli({
+  site: 'linkedin',
+  name: 'safe-send',
+  access: 'write',
+  description: 'Fail-closed LinkedIn message sender that verifies exact thread, recipient, and latest message before filling/sending',
+  domain: LINKEDIN_DOMAIN,
+  strategy: Strategy.UI,
+  browser: true,
+  args: [
+    { name: 'thread-url', required: true, help: 'Exact LinkedIn messaging thread URL to open and verify' },
+    { name: 'expected-name', required: true, help: 'Expected visible recipient name in the active thread header' },
+    { name: 'message', required: true, help: 'Message body to send or dry-run' },
+    { name: 'expected-last-text', help: 'Substring expected in the currently visible latest conversation context' },
+    { name: 'expected-last-hash', help: 'SHA-256 hash of expected latest visible message text' },
+    { name: 'send', type: 'bool', default: false, help: 'Actually click Send. Default is dry-run verification only.' },
+    { name: 'screenshot', type: 'bool', default: false, help: 'Capture a screenshot during verification' },
+  ],
+  columns: ['status', 'recipient', 'reason', 'thread_url', 'message_chars', 'screenshot'],
+  func: async (page, args) => {
+    if (!page) throw new CommandExecutionError('Browser session required for linkedin safe-send');
+
+    const threadUrl = requireLinkedInThreadUrl(requireStringArg(args, 'thread-url', '--thread-url'), '--thread-url');
+    const expectedName = requireStringArg(args, 'expected-name', '--expected-name');
+    const message = requireStringArg(args, 'message', '--message');
+
+    await page.goto('https://www.linkedin.com/messaging/');
+    await page.wait(4);
+    await page.goto(threadUrl);
+    // LinkedIn messaging often renders the shell first and hydrates the active
+    // thread header/messages a few seconds later. Wait long enough for the
+    // recipient header to appear so we fail closed on a real mismatch, not on
+    // a premature blank DOM snapshot.
+    await page.wait(12);
+
+    let beforeProbe = await probeThread(page);
+    const expectedLastText = normalizeWhitespace(args['expected-last-text']);
+    for (let attempt = 0; expectedLastText && attempt < 6 && !textContainsNormalized(beforeProbe.bodyText, expectedLastText); attempt += 1) {
+      await page.wait(2);
+      beforeProbe = await probeThread(page);
+    }
+
+    const safety = assessThreadSafety(beforeProbe, {
+      expectedName,
+      threadUrl,
+      expectedLastText: args['expected-last-text'],
+      expectedLastHash: args['expected-last-hash'],
+    });
+
+    if (safety.blockReason === 'auth_required') {
+      throw new AuthRequiredError(LINKEDIN_DOMAIN, 'LinkedIn safe-send requires an active signed-in LinkedIn browser session.');
+    }
+
+    if (!safety.ok) {
+      const observed = [
+        `Expected ${safety.expectedValue}; actual ${safety.actualValue || 'not_visible'} at ${safety.observedUrl || 'url_not_available'}`,
+        `Observed headers: ${(beforeProbe.headerNames || []).join(' | ') || 'no_visible_headers'}`,
+        `Title: ${beforeProbe.title || 'title_not_available'}`,
+        `Body: ${normalizeWhitespace(beforeProbe.bodyText || '').slice(0, 500)}`,
+      ].join('\n');
+      throw new CommandExecutionError(
+        `LinkedIn safe-send blocked: ${safety.blockReason}`,
+        observed,
+      );
+    }
+
+    let screenshot = '';
+    if (args.screenshot && typeof page.screenshot === 'function') {
+      screenshot = await page.screenshot({ fullPage: false });
+    }
+
+    if (!args.send) {
+      return [{
+        status: 'verified_dry_run',
+        recipient: safety.actualValue,
+        reason: safety.blockReason,
+        thread_url: safety.observedUrl,
+        message_chars: message.length,
+        screenshot: screenshot ? 'captured' : '',
+      }];
+    }
+
+    const focus = unwrapEvaluateResult(await page.evaluate(buildFocusComposerScript()));
+    if (!focus?.ok) throw new CommandExecutionError(`LinkedIn safe-send blocked: ${focus?.error || 'composer_focus_failed'}`);
+
+    await page.insertText(message);
+    await page.wait(0.6 + Math.random() * 0.8);
+
+    const composer = unwrapEvaluateResult(await page.evaluate(buildReadComposerScript()));
+    if (!composer?.ok || normalizeWhitespace(composer.composerText) !== normalizeWhitespace(message)) {
+      throw new CommandExecutionError(
+        'LinkedIn safe-send blocked: composer_text_mismatch',
+        `Composer text did not exactly match intended message for ${expectedName}.`,
+      );
+    }
+
+    const afterFillProbe = await probeThread(page);
+    const afterFillSafety = assessThreadSafety(afterFillProbe, {
+      expectedName,
+      threadUrl,
+      expectedLastText: args['expected-last-text'],
+      expectedLastHash: args['expected-last-hash'],
+    });
+    if (!afterFillSafety.ok) {
+      throw new CommandExecutionError(`LinkedIn safe-send blocked after fill: ${afterFillSafety.blockReason}`);
+    }
+
+    const sent = unwrapEvaluateResult(await page.evaluate(buildClickSendScript()));
+    if (!sent?.ok || !sent.sent) {
+      throw new CommandExecutionError(`LinkedIn safe-send blocked: ${sent?.error || 'send_click_failed'}`);
+    }
+
+    await page.wait(0.8 + Math.random() * 1.2);
+    return [{
+      status: 'sent',
+      recipient: safety.actualValue,
+      reason: safety.blockReason,
+      thread_url: safety.observedUrl,
+      message_chars: message.length,
+      screenshot: screenshot ? 'captured' : '',
+    }];
+  },
+});
+
+export const __test__ = {
+  normalizeWhitespace,
+  unwrapEvaluateResult,
+  normalizeName,
+  canonicalizeLinkedInThreadUrl,
+  hashText,
+  assessThreadSafety,
+};