@sovovs/bycli 1.8.0

package/clis/linkedin/connect.js

@@ -0,0 +1,401 @@
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@sovovs/bycli/errors';
+
+const LINKEDIN_DOMAIN = 'www.linkedin.com';
+
+function normalizeWhitespace(value) {
+    return String(value ?? '').replace(/[\u00a0\u202f]/g, ' ').replace(/\s+/g, ' ').trim();
+}
+
+function normalizeName(value) {
+    return normalizeWhitespace(value)
+        .replace(/\s*[•·]\s*(?:1st|2nd|3rd\+?|degree connection).*$/i, '')
+        .replace(/\s+LinkedIn.*$/i, '')
+        .replace(/\b(p\.?eng\.?|cpa|mba|ph\.?d\.?)\b/ig, '')
+        .replace(/[^\p{L}\p{N}\s.'-]+/gu, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .toLowerCase();
+}
+
+function nameTokens(value) {
+    return normalizeName(value)
+        .replace(/[.'-]+/g, ' ')
+        .split(/\s+/)
+        .map((token) => token.trim())
+        .filter((token) => token.length >= 2);
+}
+
+function matchInvitationName(candidate, expected) {
+    const candidateName = normalizeName(candidate);
+    const expectedName = normalizeName(expected);
+    if (!candidateName || !expectedName) return false;
+    if (candidateName === expectedName) return true;
+    if (candidateName.includes(expectedName) || expectedName.includes(candidateName)) return true;
+    const candidateTokens = new Set(nameTokens(candidateName));
+    const expectedTokens = nameTokens(expectedName);
+    if (expectedTokens.length < 2 || candidateTokens.size < 2) return false;
+    const matched = expectedTokens.filter((token) => candidateTokens.has(token)).length;
+    return matched >= 2 && matched / expectedTokens.length >= 0.8;
+}
+
+function isLinkedInHost(hostname) {
+    const host = String(hostname || '').toLowerCase();
+    return host === 'linkedin.com' || host.endsWith('.linkedin.com');
+}
+
+function canonicalizeLinkedInProfileUrl(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(/^\/in\/([^/]+)\/?$/i);
+        if (!match || !match[1]) return '';
+        // LinkedIn redirects country subdomains (ca./uk./...) to www.; normalize the
+        // host so an expected `ca.linkedin.com/in/x` matches the landed `www.linkedin.com/in/x`.
+        url.hostname = 'www.linkedin.com';
+        url.hash = '';
+        url.search = '';
+        if (!url.pathname.endsWith('/')) url.pathname += '/';
+        return url.toString();
+    }
+    catch {
+        return '';
+    }
+}
+
+function requireStringArg(args, key, label = key) {
+    const value = normalizeWhitespace(args[key]);
+    if (!value) throw new ArgumentError(`${label} is required`);
+    return value;
+}
+
+function requireLinkedInProfileUrl(value, label) {
+    const url = canonicalizeLinkedInProfileUrl(value);
+    if (!url) throw new ArgumentError(`${label} must be an exact https://www.linkedin.com/in/<profile>/ URL`);
+    return url;
+}
+
+function unwrapEvaluateResult(payload) {
+    if (payload && typeof payload === 'object' && 'data' in payload && 'session' in payload) return payload.data;
+    return payload;
+}
+
+function clampNote(note) {
+    const value = normalizeWhitespace(note);
+    if (value.length > 300) throw new ArgumentError('--note must be 300 characters or fewer for LinkedIn connection requests');
+    return value;
+}
+
+function canonicalizeLinkedInInviteUrl(value) {
+    try {
+        const url = new URL(normalizeWhitespace(value), 'https://www.linkedin.com');
+        if (url.protocol !== 'https:' || url.username || url.password || url.port || !isLinkedInHost(url.hostname)) return '';
+        if (!/^\/preload\/custom-invite\/?$/i.test(url.pathname)) return '';
+        url.hostname = 'www.linkedin.com';
+        url.hash = '';
+        if (!url.pathname.endsWith('/')) url.pathname += '/';
+        return url.toString();
+    }
+    catch {
+        return '';
+    }
+}
+
+function assessProfileSafety(probe, expectedName, expectedProfileUrl) {
+    const expected = normalizeWhitespace(expectedName);
+    const actual = normalizeWhitespace(probe?.name || '');
+    const expectedUrl = canonicalizeLinkedInProfileUrl(expectedProfileUrl);
+    const actualUrl = canonicalizeLinkedInProfileUrl(probe?.url || '');
+    if (probe?.authRequired) return { ok: false, safety: 'unsafe_block', connectable: null, blockReason: 'auth_required', expectedValue: expected, actualValue: actual, observedUrl: actualUrl };
+    if (!actual) return { ok: false, safety: 'unsafe_block', connectable: null, blockReason: 'profile_name_not_found', expectedValue: expected, actualValue: actual, observedUrl: actualUrl };
+    if (expected && normalizeName(actual) !== normalizeName(expected)) {
+        return { ok: false, safety: 'unsafe_block', connectable: null, blockReason: 'profile_name_mismatch', expectedValue: expected, actualValue: actual, observedUrl: actualUrl };
+    }
+    if (expectedUrl && actualUrl && expectedUrl !== actualUrl) {
+        return { ok: false, safety: 'unsafe_block', connectable: null, blockReason: 'profile_url_mismatch', expectedValue: expectedUrl, actualValue: actualUrl, observedUrl: actualUrl };
+    }
+    if (probe?.alreadyConnected) return { ok: false, safety: 'routine_non_connectable', connectable: false, blockReason: 'already_connected', expectedValue: expected, actualValue: actual, observedUrl: actualUrl };
+    if (probe?.pending) return { ok: false, safety: 'routine_non_connectable', connectable: false, blockReason: 'connection_pending', expectedValue: expected, actualValue: actual, observedUrl: actualUrl };
+    if (!probe?.connectAvailable) return { ok: false, safety: 'routine_non_connectable', connectable: false, blockReason: 'connect_button_not_found', expectedValue: expected, actualValue: actual, observedUrl: actualUrl };
+    return { ok: true, safety: 'connectable', connectable: true, blockReason: 'verified', expectedValue: expected, actualValue: actual, observedUrl: actualUrl };
+}
+
+function buildProfileProbeScript() {
+    return String.raw`(() => {
+    const clean = (s) => String(s || '').replace(/[\u00a0\u202f]/g, ' ').replace(/\s+/g, ' ').trim();
+    const text = document.body ? (document.body.innerText || '') : '';
+    const authRequired = /\b(sign in|log in|join linkedin)\b/i.test(text)
+      || /linkedin\.com\/(login|checkpoint|authwall)/i.test(location.href)
+      || /captcha|verification required/i.test(text);
+    const main = document.querySelector('main') || document.body;
+    // LinkedIn profile pages no longer expose the name in an <h1>; the heading
+    // markup churns, but document.title is a stable "Name | LinkedIn" pattern.
+    const heading = main?.querySelector('h1, .text-heading-xlarge, [class*="heading-xlarge"]');
+    const titleName = clean((document.title || '')
+      .replace(/^\(\d+\+?\)\s*/, '')
+      .replace(/\s*[|｜]\s*LinkedIn\s*$/i, ''));
+    const name = clean(heading?.innerText || heading?.textContent || '') || titleName;
+    const buttons = Array.from(document.querySelectorAll('button, [role="button"], a')).filter((el) => el.offsetParent !== null);
+    const buttonLabels = buttons.map((button) => clean(button.innerText || button.textContent || button.getAttribute('aria-label'))).filter(Boolean);
+    const lowerLabels = buttonLabels.map((label) => label.toLowerCase());
+    const alreadyConnected = lowerLabels.some((label) => label === 'message' || label.includes('1st degree connection'));
+    const pending = lowerLabels.some((label) => label === 'pending' || label.includes('pending'));
+    const connectAvailable = lowerLabels.some((label) => label === 'connect' || label.startsWith('connect ') || label.includes(' invite '));
+    // The Connect control is an <a> linking to LinkedIn's invitation route
+    // (/preload/custom-invite/?vanityName=...). Capture it so the sender can
+    // navigate straight to the invite dialog.
+    const connectAnchor = buttons.find((el) => el.tagName === 'A'
+      && /^connect$/i.test(clean(el.innerText || el.textContent || el.getAttribute('aria-label'))));
+    const connectHref = connectAnchor ? (connectAnchor.getAttribute('href') || '') : '';
+    return {
+      url: location.href,
+      title: document.title || '',
+      name,
+      authRequired,
+      alreadyConnected,
+      pending,
+      connectAvailable,
+      connectHref,
+      buttonLabels: buttonLabels.slice(0, 30),
+      bodyText: text,
+    };
+  })()`;
+}
+
+// Runs in-page on LinkedIn's invitation route (/preload/custom-invite/...),
+// where the "Add a note to your invitation?" dialog is already open.
+
+function buildSentInvitationsProbeScript(expectedName, expectedProfileUrl) {
+    return String.raw`(() => {
+    const expectedName = ${JSON.stringify(expectedName)};
+    const expectedUrl = ${JSON.stringify(canonicalizeLinkedInProfileUrl(expectedProfileUrl))};
+    const clean = (s) => String(s || '').replace(/[\u00a0\u202f]/g, ' ').replace(/\s+/g, ' ').trim();
+    const normName = (s) => clean(s)
+      .replace(/\s*[•·]\s*(?:1st|2nd|3rd\+?|degree connection).*$/i, '')
+      .replace(/\s+LinkedIn.*$/i, '')
+      .replace(/\b(p\.?eng\.?|cpa|mba|ph\.?d\.?)\b/ig, '')
+      .replace(/[^\p{L}\p{N}\s.'-]+/gu, ' ')
+      .replace(/\s+/g, ' ')
+      .trim()
+      .toLowerCase();
+    const tokens = (s) => normName(s).replace(/[.'-]+/g, ' ').split(/\s+/).map((t) => t.trim()).filter((t) => t.length >= 2);
+    const nameMatchesReasonably = (candidate, expected) => {
+      const c = normName(candidate);
+      const e = normName(expected);
+      if (!c || !e) return false;
+      if (c === e || c.includes(e) || e.includes(c)) return true;
+      const candidateTokens = new Set(tokens(c));
+      const expectedTokens = tokens(e);
+      if (expectedTokens.length < 2 || candidateTokens.size < 2) return false;
+      const matched = expectedTokens.filter((token) => candidateTokens.has(token)).length;
+      return matched >= 2 && matched / expectedTokens.length >= 0.8;
+    };
+    const canon = (value) => {
+      try {
+        const url = new URL(value, 'https://www.linkedin.com');
+        if (!/^\/in\/[^/]+\/?$/i.test(url.pathname)) return '';
+        url.protocol = 'https:';
+        url.hostname = 'www.linkedin.com';
+        url.hash = '';
+        url.search = '';
+        if (!url.pathname.endsWith('/')) url.pathname += '/';
+        return url.toString();
+      } catch { return ''; }
+    };
+    const text = document.body ? (document.body.innerText || '') : '';
+    const authRequired = /\b(sign in|log in|join linkedin)\b/i.test(text)
+      || /linkedin\.com\/(login|checkpoint|authwall)/i.test(location.href)
+      || /captcha|verification required/i.test(text);
+    if (authRequired) return { authRequired: true, found: false, matchedName: '', matchedUrl: '', visibleNames: [] };
+    const structuralRows = Array.from(document.querySelectorAll('li, article, [data-view-name], .mn-invitation-card'));
+    const linkRows = Array.from(document.querySelectorAll('a[href*="/in/"]'))
+      .map((a) => a.closest('li') || a.closest('[data-view-name]') || a.closest('[class*="invitation"]') || a.closest('div'))
+      .filter(Boolean);
+    const rows = Array.from(new Set([...structuralRows, ...linkRows]));
+    const visibleNames = [];
+    for (const row of rows.slice(0, 25)) {
+      const rowText = clean(row.innerText || row.textContent || '');
+      if (!rowText) continue;
+      const link = Array.from(row.querySelectorAll('a[href*="/in/"]'))
+        .map((a) => ({ href: canon(a.href || a.getAttribute('href') || ''), text: clean(a.innerText || a.textContent || '') }))
+        .find((a) => a.href || a.text);
+      const candidateName = clean(link?.text || row.querySelector('span[aria-hidden="true"], h3, h2')?.textContent || rowText.split('\n')[0]);
+      if (candidateName) visibleNames.push(candidateName);
+      const candidateUrl = link?.href || '';
+      const nameMatches = expectedName && candidateName && nameMatchesReasonably(candidateName, expectedName);
+      const urlMatches = expectedUrl && candidateUrl && candidateUrl === expectedUrl;
+      if (urlMatches || nameMatches) return { authRequired: false, found: true, matchedName: candidateName, matchedUrl: candidateUrl, visibleNames: visibleNames.slice(0, 20) };
+    }
+    return { authRequired: false, found: false, matchedName: '', matchedUrl: '', visibleNames: visibleNames.slice(0, 20) };
+  })()`;
+}
+
+function buildInviteScript(note) {
+    return String.raw`(async () => {
+    const note = ${JSON.stringify(note)};
+    const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    const jitter = async (min = 450, max = 1150) => sleep(min + Math.floor(Math.random() * (max - min + 1)));
+    const clean = (s) => String(s || '').replace(/[\u00a0\u202f]/g, ' ').replace(/\s+/g, ' ').trim();
+    const visible = (el) => el && el.offsetParent !== null;
+    const label = (el) => clean(el?.innerText || el?.textContent || el?.getAttribute('aria-label'));
+    const dialog = () => document.querySelector('[role="dialog"]');
+    const dialogButton = (pattern) => {
+      const dlg = dialog();
+      if (!dlg) return null;
+      return Array.from(dlg.querySelectorAll('button, [role="button"]')).filter(visible)
+        .find((button) => pattern.test(label(button)));
+    };
+
+    if (!dialog()) return { ok: false, status: 'blocked', reason: 'invite_dialog_not_found' };
+
+    if (!note) {
+      const sendDirect = dialogButton(/^send without a note$/i) || dialogButton(/^send$/i);
+      if (!sendDirect) return { ok: false, status: 'blocked', reason: 'send_button_not_found' };
+      await jitter();
+      sendDirect.click();
+      await jitter(1400, 2400);
+      return { ok: true, status: 'sent', reason: 'invitation_sent_without_note' };
+    }
+
+    const addNote = dialogButton(/^add a note$/i);
+    if (!addNote) return { ok: false, status: 'blocked', reason: 'add_note_button_not_found' };
+    await jitter();
+    addNote.click();
+    await jitter(800, 1400);
+
+    const textarea = document.querySelector('#custom-message')
+      || Array.from(document.querySelectorAll('textarea')).find(visible);
+    if (!textarea) return { ok: false, status: 'blocked', reason: 'note_textarea_not_found' };
+    textarea.focus();
+    // React tracks textarea values through the native setter; assigning .value
+    // directly would leave component state (and the Send button) unchanged.
+    const nativeSetter = Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, 'value').set;
+    nativeSetter.call(textarea, note);
+    textarea.dispatchEvent(new Event('input', { bubbles: true }));
+    textarea.dispatchEvent(new Event('change', { bubbles: true }));
+    await jitter(700, 1300);
+
+    const send = dialogButton(/^send$/i);
+    if (!send) return { ok: false, status: 'blocked', reason: 'send_button_not_found' };
+    if (send.disabled || send.getAttribute('aria-disabled') === 'true') {
+      return { ok: false, status: 'blocked', reason: 'send_button_disabled' };
+    }
+    send.click();
+    await jitter(1400, 2400);
+    return { ok: true, status: 'sent', reason: 'invitation_sent_with_note' };
+  })()`;
+}
+
+async function probeProfile(page) {
+    return unwrapEvaluateResult(await page.evaluate(buildProfileProbeScript()));
+}
+
+cli({
+    site: 'linkedin',
+    name: 'connect',
+    access: 'write',
+    description: 'Fail-closed LinkedIn connection request sender that verifies the exact profile before optionally sending a note',
+    domain: LINKEDIN_DOMAIN,
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        { name: 'profile-url', type: 'string', required: true, positional: true, help: 'Exact LinkedIn profile URL to open and verify' },
+        { name: 'expected-name', type: 'string', required: true, help: 'Expected visible profile name' },
+        { name: 'note', type: 'string', required: false, default: '', help: 'Optional connection note, max 300 chars' },
+        { name: 'send', type: 'bool', required: false, default: false, help: 'Actually click Send. Default is dry-run verification only.' },
+    ],
+    columns: ['status', 'recipient', 'reason', 'profile_url', 'note_chars', 'connectable', 'delivery_verified', 'matched_invitation_name', 'matched_invitation_url', 'actualValue', 'blockReason', 'expectedValue', 'observedUrl', 'safety'],
+    func: async (page, args) => {
+        if (!page) throw new CommandExecutionError('Browser session required for linkedin connect');
+        const profileUrl = requireLinkedInProfileUrl(requireStringArg(args, 'profile-url', '--profile-url'), '--profile-url');
+        const expectedName = requireStringArg(args, 'expected-name', '--expected-name');
+        const note = clampNote(args.note || '');
+
+        await page.goto(profileUrl);
+        await page.wait(6);
+        let probe = await probeProfile(page);
+        // The name resolves early (from document.title), but the profile action
+        // buttons (Connect / Message / Pending) render later. Keep probing until
+        // the action state has resolved, not merely until the name is visible.
+        for (let attempt = 0; attempt < 8; attempt += 1) {
+            const resolved = probe?.name
+                && (probe.connectAvailable || probe.alreadyConnected || probe.pending);
+            if (resolved) break;
+            await page.wait(2);
+            probe = await probeProfile(page);
+        }
+        const safety = assessProfileSafety(probe, expectedName, profileUrl);
+        if (safety.blockReason === 'auth_required') {
+            throw new AuthRequiredError(LINKEDIN_DOMAIN, 'LinkedIn connect requires an active signed-in LinkedIn browser session.');
+        }
+        if (!safety.ok && safety.safety === 'routine_non_connectable') {
+            return [{ status: 'not_connectable', recipient: safety.actualValue, reason: safety.blockReason, profile_url: safety.observedUrl, note_chars: note.length, connectable: false }];
+        }
+        if (!safety.ok) {
+            throw new CommandExecutionError(
+                `LinkedIn connect blocked: ${safety.blockReason}`,
+                `Expected ${safety.expectedValue}; actual ${safety.actualValue || 'not_visible'} at ${safety.observedUrl || 'url_not_available'}\nButtons: ${(probe?.buttonLabels || []).join(' | ')}`,
+            );
+        }
+        if (!args.send) {
+            return [{ status: 'connectable_dry_run', recipient: safety.actualValue, reason: safety.blockReason, profile_url: safety.observedUrl, note_chars: note.length, connectable: true }];
+        }
+        const inviteHref = probe?.connectHref || '';
+        if (!inviteHref) {
+            throw new CommandExecutionError('LinkedIn connect blocked: connect_link_not_found');
+        }
+        const inviteUrl = canonicalizeLinkedInInviteUrl(inviteHref);
+        if (!inviteUrl) {
+            throw new CommandExecutionError('LinkedIn connect blocked: invalid_connect_link');
+        }
+        await page.goto(inviteUrl);
+        await page.wait(6);
+        let result = unwrapEvaluateResult(await page.evaluate(buildInviteScript(note)));
+        if (result?.reason === 'invite_dialog_not_found') {
+            await page.wait(5);
+            result = unwrapEvaluateResult(await page.evaluate(buildInviteScript(note)));
+        }
+        if (!result?.ok) throw new CommandExecutionError(`LinkedIn connect blocked: ${result?.reason || 'send_failed'}`);
+        // LinkedIn can take a few seconds after the Send click to materialize the
+        // new invite in /mynetwork/invitation-manager/sent/. Wait before the
+        // first check, then retry page loads for propagation lag.
+        await page.wait(8);
+        let sentProbe = null;
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+            await page.goto('https://www.linkedin.com/mynetwork/invitation-manager/sent/');
+            await page.wait(attempt === 0 ? 6 : 4);
+            sentProbe = unwrapEvaluateResult(await page.evaluate(buildSentInvitationsProbeScript(expectedName, profileUrl)));
+            if (sentProbe?.found || sentProbe?.authRequired) break;
+            if (attempt < 2) await page.wait(5);
+        }
+        if (sentProbe?.authRequired) {
+            throw new AuthRequiredError(LINKEDIN_DOMAIN, 'LinkedIn sent-invitations verification requires an active signed-in LinkedIn browser session.');
+        }
+        const verified = Boolean(sentProbe?.found);
+        return [{
+            status: verified ? 'sent_verified' : 'send_unverified',
+            recipient: safety.actualValue,
+            reason: verified ? 'sent_invitation_verified' : 'sent_invitation_not_found_after_retries',
+            profile_url: safety.observedUrl,
+            note_chars: note.length,
+            connectable: true,
+            delivery_verified: verified,
+            matched_invitation_name: sentProbe?.matchedName || '',
+            matched_invitation_url: sentProbe?.matchedUrl || '',
+        }];
+    },
+});
+
+export const __test__ = {
+    normalizeWhitespace,
+    normalizeName,
+    matchInvitationName,
+    canonicalizeLinkedInProfileUrl,
+    canonicalizeLinkedInInviteUrl,
+    unwrapEvaluateResult,
+    clampNote,
+    assessProfileSafety,
+    buildSentInvitationsProbeScript,
+};

package/clis/linkedin/connect.test.js

@@ -0,0 +1,213 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@sovovs/bycli/registry';
+import { ArgumentError, CommandExecutionError } from '@sovovs/bycli/errors';
+import './connect.js';
+
+const {
+    normalizeName,
+    matchInvitationName,
+    canonicalizeLinkedInProfileUrl,
+    canonicalizeLinkedInInviteUrl,
+    unwrapEvaluateResult,
+    clampNote,
+    assessProfileSafety,
+} = await import('./connect.js').then((m) => m.__test__);
+
+function makeFakePage(probe, sendResult = { ok: true, status: 'sent', reason: 'connection_request_sent' }) {
+    return {
+        goto: vi.fn(async () => undefined),
+        wait: vi.fn(async () => undefined),
+        evaluate: vi.fn(async (script) => {
+            const text = String(script);
+            if (text.includes('custom-message') || text.includes('invite_dialog_not_found')) return sendResult;
+            return probe;
+        }),
+    };
+}
+
+function makeSequentialFakePage(values) {
+    let index = 0;
+    return {
+        goto: vi.fn(async () => undefined),
+        wait: vi.fn(async () => undefined),
+        evaluate: vi.fn(async (script) => {
+            const text = String(script);
+            if (text.includes('custom-message') || text.includes('invite_dialog_not_found')) return { ok: true, status: 'sent', reason: 'connection_request_sent' };
+            const value = values[Math.min(index, values.length - 1)];
+            index += 1;
+            return value;
+        }),
+    };
+}
+
+describe('linkedin connect helpers', () => {
+    it('normalizes names and profile URLs', () => {
+        expect(normalizeName('Jane Doe • 2nd degree connection')).toBe('jane doe');
+        expect(matchInvitationName('Jane Doe, P.Eng.', ' jane   doe ')).toBe(true);
+        expect(matchInvitationName('Jane Q. Doe', 'Jane Doe')).toBe(true);
+        expect(matchInvitationName('Janet Doe', 'Jane Doe')).toBe(false);
+        expect(canonicalizeLinkedInProfileUrl('https://www.linkedin.com/in/jane/?mini=true#x'))
+            .toBe('https://www.linkedin.com/in/jane/');
+        expect(canonicalizeLinkedInProfileUrl('https://ca.linkedin.com/in/jane/?mini=true#x'))
+            .toBe('https://www.linkedin.com/in/jane/');
+        expect(canonicalizeLinkedInProfileUrl('https://www.linkedin.com/company/bycli/')).toBe('');
+        expect(canonicalizeLinkedInProfileUrl('https://evil-linkedin.com/in/jane/')).toBe('');
+        expect(canonicalizeLinkedInProfileUrl('http://www.linkedin.com/in/jane/')).toBe('');
+    });
+
+    it('only accepts LinkedIn invitation route hrefs for sending', () => {
+        expect(canonicalizeLinkedInInviteUrl('/preload/custom-invite/?vanityName=jane'))
+            .toBe('https://www.linkedin.com/preload/custom-invite/?vanityName=jane');
+        expect(canonicalizeLinkedInInviteUrl('https://www.linkedin.com/feed/')).toBe('');
+        expect(canonicalizeLinkedInInviteUrl('https://evil-linkedin.com/preload/custom-invite/?vanityName=jane')).toBe('');
+    });
+
+    it('unwraps browser bridge evaluate envelopes', () => {
+        expect(unwrapEvaluateResult({ session: 'site:linkedin:1', data: { ok: true } })).toEqual({ ok: true });
+        const raw = { ok: true };
+        expect(unwrapEvaluateResult(raw)).toBe(raw);
+    });
+
+    it('enforces LinkedIn note length', () => {
+        expect(clampNote(' hello\nthere ')).toBe('hello there');
+        expect(() => clampNote('x'.repeat(301))).toThrow('--note must be 300 characters or fewer');
+    });
+
+    it('fails closed on wrong profile name, pending state, or missing connect button', () => {
+        expect(assessProfileSafety({ name: 'Jane Doe', url: 'https://www.linkedin.com/in/jane/', connectAvailable: true }, 'Janet Doe', 'https://www.linkedin.com/in/jane/').blockReason)
+            .toBe('profile_name_mismatch');
+        expect(assessProfileSafety({ name: 'Jane Doe', url: 'https://www.linkedin.com/in/jane/', pending: true, connectAvailable: true }, 'Jane Doe', 'https://www.linkedin.com/in/jane/').blockReason)
+            .toBe('connection_pending');
+        expect(assessProfileSafety({ name: 'Jane Doe', url: 'https://www.linkedin.com/in/jane/' }, 'Jane Doe', 'https://www.linkedin.com/in/jane/').blockReason)
+            .toBe('connect_button_not_found');
+    });
+
+    it('classifies routine non-connectable profiles separately from unsafe blocks', () => {
+        expect(assessProfileSafety({ name: 'Jane Doe', url: 'https://www.linkedin.com/in/jane/', alreadyConnected: true }, 'Jane Doe', 'https://www.linkedin.com/in/jane/'))
+            .toMatchObject({ ok: false, safety: 'routine_non_connectable', connectable: false, blockReason: 'already_connected' });
+        expect(assessProfileSafety({ name: 'Jane Doe', url: 'https://www.linkedin.com/in/jane/', pending: true }, 'Jane Doe', 'https://www.linkedin.com/in/jane/'))
+            .toMatchObject({ ok: false, safety: 'routine_non_connectable', connectable: false, blockReason: 'connection_pending' });
+        expect(assessProfileSafety({ name: 'Wrong Person', url: 'https://www.linkedin.com/in/wrong/', connectAvailable: true }, 'Jane Doe', 'https://www.linkedin.com/in/jane/'))
+            .toMatchObject({ ok: false, safety: 'unsafe_block', connectable: null, blockReason: 'profile_name_mismatch' });
+    });
+
+    it('passes only when profile url, name, and connect affordance all match', () => {
+        const result = assessProfileSafety({ name: 'Jane Doe', url: 'https://www.linkedin.com/in/jane/?mini=true', connectAvailable: true }, 'Jane Doe', 'https://www.linkedin.com/in/jane/');
+        expect(result).toMatchObject({ ok: true, blockReason: 'verified', actualValue: 'Jane Doe', connectable: true });
+    });
+});
+
+describe('linkedin connect command', () => {
+    it('registers as a write command and dry-runs by default', async () => {
+        const command = getRegistry().get('linkedin/connect');
+        expect(command).toBeDefined();
+        expect(command.access).toBe('write');
+        const page = makeFakePage({ name: 'Jane Doe', url: 'https://www.linkedin.com/in/jane/', connectAvailable: true, connectHref: '/preload/custom-invite/?vanityName=jane', buttonLabels: ['Connect'] });
+        const rows = await command.func(page, {
+            'profile-url': 'https://www.linkedin.com/in/jane/',
+            'expected-name': 'Jane Doe',
+            note: 'quick note',
+        });
+        expect(rows[0]).toMatchObject({ status: 'connectable_dry_run', recipient: 'Jane Doe', reason: 'verified', connectable: true });
+        expect(page.evaluate).toHaveBeenCalledTimes(1);
+    });
+
+    it('returns a clean not_connectable dry-run row for routine blocked states', async () => {
+        const command = getRegistry().get('linkedin/connect');
+        const page = makeFakePage({ name: 'Jane Doe', url: 'https://www.linkedin.com/in/jane/', alreadyConnected: true, buttonLabels: ['Message'] });
+        const rows = await command.func(page, {
+            'profile-url': 'https://www.linkedin.com/in/jane/',
+            'expected-name': 'Jane Doe',
+            note: 'quick note',
+        });
+        expect(rows[0]).toMatchObject({ status: 'not_connectable', recipient: 'Jane Doe', reason: 'already_connected', connectable: false });
+    });
+
+    it('does not send when recipient verification fails', async () => {
+        const command = getRegistry().get('linkedin/connect');
+        const page = makeFakePage({ name: 'Wrong Person', url: 'https://www.linkedin.com/in/wrong/', connectAvailable: true, buttonLabels: ['Connect'] });
+        await expect(command.func(page, {
+            'profile-url': 'https://www.linkedin.com/in/jane/',
+            'expected-name': 'Jane Doe',
+            note: 'quick note',
+            send: true,
+        })).rejects.toBeInstanceOf(CommandExecutionError);
+        expect(page.evaluate).toHaveBeenCalledTimes(1);
+    });
+
+    it('rejects non-profile URLs before navigating', async () => {
+        const command = getRegistry().get('linkedin/connect');
+        const page = makeFakePage({});
+
+        await expect(command.func(page, {
+            'profile-url': 'https://www.linkedin.com/company/bycli/',
+            'expected-name': 'Jane Doe',
+            send: true,
+        })).rejects.toBeInstanceOf(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+
+    it('blocks send when the connect link is not LinkedIn invitation route', async () => {
+        const command = getRegistry().get('linkedin/connect');
+        const page = makeFakePage({ name: 'Jane Doe', url: 'https://www.linkedin.com/in/jane/', connectAvailable: true, connectHref: 'https://www.linkedin.com/feed/', buttonLabels: ['Connect'] });
+
+        await expect(command.func(page, {
+            'profile-url': 'https://www.linkedin.com/in/jane/',
+            'expected-name': 'Jane Doe',
+            send: true,
+        })).rejects.toThrow('invalid_connect_link');
+    });
+
+    it('sends only when --send is true after verification and sent-invitations confirms delivery', async () => {
+        const command = getRegistry().get('linkedin/connect');
+        const page = makeSequentialFakePage([
+            { name: 'Jane Doe', url: 'https://www.linkedin.com/in/jane/', connectAvailable: true, connectHref: '/preload/custom-invite/?vanityName=jane', buttonLabels: ['Connect'] },
+            { found: true, matchedName: 'Jane Doe', matchedUrl: 'https://www.linkedin.com/in/jane/' },
+        ]);
+        const rows = await command.func(page, {
+            'profile-url': 'https://www.linkedin.com/in/jane/',
+            'expected-name': 'Jane Doe',
+            note: 'quick note',
+            send: true,
+        });
+        expect(rows[0]).toMatchObject({ status: 'sent_verified', recipient: 'Jane Doe', reason: 'sent_invitation_verified', delivery_verified: true });
+        expect(page.goto).toHaveBeenCalledWith('https://www.linkedin.com/mynetwork/invitation-manager/sent/');
+    });
+
+    it('retries sent-invitations verification before reporting unverified', async () => {
+        const command = getRegistry().get('linkedin/connect');
+        const page = makeSequentialFakePage([
+            { name: 'Jane Doe', url: 'https://www.linkedin.com/in/jane/', connectAvailable: true, connectHref: '/preload/custom-invite/?vanityName=jane', buttonLabels: ['Connect'] },
+            { found: false, matchedName: '', matchedUrl: '', visibleNames: ['Other Person'] },
+            { found: false, matchedName: '', matchedUrl: '', visibleNames: ['Other Person'] },
+            { found: true, matchedName: 'Jane Doe, P.Eng.', matchedUrl: '' },
+        ]);
+        const rows = await command.func(page, {
+            'profile-url': 'https://www.linkedin.com/in/jane/',
+            'expected-name': 'Jane Doe',
+            note: 'quick note',
+            send: true,
+        });
+        expect(rows[0]).toMatchObject({ status: 'sent_verified', recipient: 'Jane Doe', reason: 'sent_invitation_verified', delivery_verified: true, matched_invitation_name: 'Jane Doe, P.Eng.' });
+        expect(page.goto).toHaveBeenCalledWith('https://www.linkedin.com/mynetwork/invitation-manager/sent/');
+        expect(page.evaluate).toHaveBeenCalledTimes(5);
+    });
+
+    it('does not report sent when sent-invitations verification fails after retries', async () => {
+        const command = getRegistry().get('linkedin/connect');
+        const page = makeSequentialFakePage([
+            { name: 'Jane Doe', url: 'https://www.linkedin.com/in/jane/', connectAvailable: true, connectHref: '/preload/custom-invite/?vanityName=jane', buttonLabels: ['Connect'] },
+            { found: false, matchedName: '', matchedUrl: '' },
+            { found: false, matchedName: '', matchedUrl: '' },
+            { found: false, matchedName: '', matchedUrl: '' },
+        ]);
+        const rows = await command.func(page, {
+            'profile-url': 'https://www.linkedin.com/in/jane/',
+            'expected-name': 'Jane Doe',
+            note: 'quick note',
+            send: true,
+        });
+        expect(rows[0]).toMatchObject({ status: 'send_unverified', recipient: 'Jane Doe', reason: 'sent_invitation_not_found_after_retries', delivery_verified: false });
+        expect(page.evaluate).toHaveBeenCalledTimes(5);
+    });
+});