@jackwener/opencli 1.7.22 → 1.8.0

package/clis/jike/user.js

@@ -1,4 +1,5 @@
 import { cli } from '@jackwener/opencli/registry';
+import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
 cli({
     site: 'jike',
     name: 'user',
@@ -17,14 +18,15 @@ cli({
         { name: 'limit', type: 'int', default: 20, help: 'Number of posts' },
     ],
     columns: ['id', 'content', 'type', 'likes', 'comments', 'time', 'url'],
-    pipeline: [
-        { navigate: 'https://m.okjike.com/users/${{ args.username }}' },
-        { evaluate: `(() => {
+    func: async (page, args) => {
+        await page.goto(`https://m.okjike.com/users/${args.username}`);
+        const limit = Number(args.limit) || 20;
+        const data = await page.evaluate(`(() => {
+  const el = document.querySelector('script[type="application/json"]');
+  if (!el) return { ok: false, reason: 'missing-data-script' };
   try {
-    const el = document.querySelector('script[type="application/json"]');
-    if (!el) return [];
-    const data = JSON.parse(el.textContent);
-    const posts = data?.props?.pageProps?.posts || [];
+    const data = JSON.parse(el.textContent || '{}');
+    const posts = Array.isArray(data?.props?.pageProps?.posts) ? data.props.pageProps.posts : [];
     return posts.map(p => ({
       content: (p.content || '').replace(/\\n/g, ' ').slice(0, 80),
       type: p.type === 'ORIGINAL_POST' ? 'post' : p.type === 'REPOST' ? 'repost' : p.type || '',
@@ -34,19 +36,30 @@ cli({
       id: p.id || '',
     }));
   } catch (e) {
-    return [];
+    return { ok: false, reason: 'parse-error', message: e?.message || String(e) };
   }
 })()
-` },
-        { map: {
-                id: '${{ item.id }}',
-                content: '${{ item.content }}',
-                type: '${{ item.type }}',
-                likes: '${{ item.likes }}',
-                comments: '${{ item.comments }}',
-                time: '${{ item.time }}',
-                url: 'https://web.okjike.com/originalPost/${{ item.id }}',
-            } },
-        { limit: '${{ args.limit }}' },
-    ],
+`);
+        if (Array.isArray(data)) {
+            if (data.length === 0) {
+                throw new EmptyResultError('jike user', `No posts were returned for user ${args.username}. Confirm the username and login state.`);
+            }
+            return data.slice(0, limit).map((item) => ({
+                id: item.id ?? '',
+                content: item.content ?? '',
+                type: item.type ?? '',
+                likes: item.likes ?? 0,
+                comments: item.comments ?? 0,
+                time: item.time ?? '',
+                url: `https://web.okjike.com/originalPost/${item.id ?? ''}`,
+            }));
+        }
+        if (data?.reason === 'missing-data-script') {
+            throw new CommandExecutionError('Jike user page did not expose the expected data script');
+        }
+        if (data?.reason === 'parse-error') {
+            throw new CommandExecutionError(`Failed to parse Jike user data: ${data.message || 'unknown error'}`);
+        }
+        throw new CommandExecutionError('Jike user returned an unreadable payload');
+    },
 });

package/clis/lesswrong/comments.js

@@ -56,7 +56,7 @@ cli({
             rows.push({
                 rank: i + 1,
                 score: item.baseScore ?? 0,
-                author: user?.displayName ?? 'Unknown',
+                author: user?.displayName ?? '',
                 text: raw.length > 500 ? `${raw.slice(0, 500)}...` : raw,
             });
         }

package/clis/lesswrong/curated.js

@@ -22,7 +22,7 @@ cli({
         return posts.map((item, i) => ({
             rank: i + 1,
             title: item.title ?? '',
-            author: item.user?.displayName ?? 'Unknown',
+            author: item.user?.displayName ?? '',
             karma: item.baseScore ?? 0,
             comments: item.commentCount ?? 0,
             url: `https://${DOMAIN}/posts/${item._id}/${item.slug}`,

package/clis/lesswrong/frontpage.js

@@ -22,7 +22,7 @@ cli({
         return posts.map((item, i) => ({
             rank: i + 1,
             title: item.title ?? '',
-            author: item.user?.displayName ?? 'Unknown',
+            author: item.user?.displayName ?? '',
             karma: item.baseScore ?? 0,
             comments: item.commentCount ?? 0,
             url: `https://${DOMAIN}/posts/${item._id}/${item.slug}`,

package/clis/lesswrong/frontpage.test.js

@@ -0,0 +1,37 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+
+const { gqlRequestMock } = vi.hoisted(() => ({ gqlRequestMock: vi.fn() }));
+vi.mock('./_helpers.js', async () => {
+    const actual = await vi.importActual('./_helpers.js');
+    return { ...actual, gqlRequest: gqlRequestMock };
+});
+
+import './frontpage.js';
+
+describe('lesswrong frontpage', () => {
+    beforeEach(() => {
+        gqlRequestMock.mockReset();
+    });
+
+    it('emits empty-string for missing user.displayName instead of a sentinel', async () => {
+        const command = getRegistry().get('lesswrong/frontpage');
+        expect(command?.func).toBeDefined();
+        gqlRequestMock.mockResolvedValueOnce({
+            posts: {
+                results: [
+                    { _id: 'a1', slug: 'post-a', title: 'Has author', user: { displayName: 'Real Person' }, baseScore: 10, commentCount: 3 },
+                    { _id: 'b2', slug: 'post-b', title: 'Deleted user', user: null, baseScore: 5, commentCount: 0 },
+                    { _id: 'c3', slug: 'post-c', title: 'Missing name', user: {}, baseScore: 7, commentCount: 1 },
+                ],
+            },
+        });
+        const rows = await command.func({ limit: 3 });
+        expect(rows).toHaveLength(3);
+        expect(rows[0]).toMatchObject({ rank: 1, title: 'Has author', author: 'Real Person', karma: 10, comments: 3 });
+        expect(rows[1].author).toBe('');
+        expect(rows[1].title).toBe('Deleted user');
+        expect(rows[2].author).toBe('');
+        expect(rows[2].title).toBe('Missing name');
+    });
+});

package/clis/lesswrong/new.js

@@ -22,7 +22,7 @@ cli({
         return posts.map((item, i) => ({
             rank: i + 1,
             title: item.title ?? '',
-            author: item.user?.displayName ?? 'Unknown',
+            author: item.user?.displayName ?? '',
             karma: item.baseScore ?? 0,
             comments: item.commentCount ?? 0,
             url: `https://${DOMAIN}/posts/${item._id}/${item.slug}`,

package/clis/lesswrong/read.js

@@ -34,7 +34,7 @@ cli({
         return [
             {
                 title: post.title ?? '',
-                author: post.user?.displayName ?? 'Unknown',
+                author: post.user?.displayName ?? '',
                 karma: post.baseScore ?? 0,
                 comments: post.commentCount ?? 0,
                 tags: (post.tags ?? []).map((tag) => tag.name ?? '').filter(Boolean).join(', '),

package/clis/lesswrong/sequences.js

@@ -22,7 +22,7 @@ cli({
         return sequences.map((item, i) => ({
             rank: i + 1,
             title: item.title ?? '',
-            author: item.user?.displayName ?? 'Unknown',
+            author: item.user?.displayName ?? '',
         }));
     },
 });

package/clis/lesswrong/shortform.js

@@ -22,7 +22,7 @@ cli({
         return posts.map((item, i) => ({
             rank: i + 1,
             title: item.title ?? '',
-            author: item.user?.displayName ?? 'Unknown',
+            author: item.user?.displayName ?? '',
             karma: item.baseScore ?? 0,
             comments: item.commentCount ?? 0,
             url: `https://${DOMAIN}/posts/${item._id}/${item.slug}`,

package/clis/lesswrong/tag.js

@@ -37,7 +37,7 @@ cli({
         return posts.map((item, i) => ({
             rank: i + 1,
             title: item.title ?? '',
-            author: item.user?.displayName ?? 'Unknown',
+            author: item.user?.displayName ?? '',
             karma: item.baseScore ?? 0,
             comments: item.commentCount ?? 0,
             url: `https://${DOMAIN}/posts/${item._id}/${item.slug}`,

package/clis/lesswrong/top-month.js

@@ -22,7 +22,7 @@ cli({
         return posts.map((item, i) => ({
             rank: i + 1,
             title: item.title ?? '',
-            author: item.user?.displayName ?? 'Unknown',
+            author: item.user?.displayName ?? '',
             karma: item.baseScore ?? 0,
             comments: item.commentCount ?? 0,
             url: `https://${DOMAIN}/posts/${item._id}/${item.slug}`,

package/clis/lesswrong/top-week.js

@@ -22,7 +22,7 @@ cli({
         return posts.map((item, i) => ({
             rank: i + 1,
             title: item.title ?? '',
-            author: item.user?.displayName ?? 'Unknown',
+            author: item.user?.displayName ?? '',
             karma: item.baseScore ?? 0,
             comments: item.commentCount ?? 0,
             url: `https://${DOMAIN}/posts/${item._id}/${item.slug}`,

package/clis/lesswrong/top-year.js

@@ -22,7 +22,7 @@ cli({
         return posts.map((item, i) => ({
             rank: i + 1,
             title: item.title ?? '',
-            author: item.user?.displayName ?? 'Unknown',
+            author: item.user?.displayName ?? '',
             karma: item.baseScore ?? 0,
             comments: item.commentCount ?? 0,
             url: `https://${DOMAIN}/posts/${item._id}/${item.slug}`,

package/clis/lesswrong/top.js

@@ -22,7 +22,7 @@ cli({
         return posts.map((item, i) => ({
             rank: i + 1,
             title: item.title ?? '',
-            author: item.user?.displayName ?? 'Unknown',
+            author: item.user?.displayName ?? '',
             karma: item.baseScore ?? 0,
             comments: item.commentCount ?? 0,
             url: `https://${DOMAIN}/posts/${item._id}/${item.slug}`,

package/clis/linkedin/connect.js

@@ -0,0 +1,401 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/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,
+};