@jackwener/opencli 1.7.22 → 1.8.1

package/clis/linkedin/job-detail.js

@@ -0,0 +1,167 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError } from '@jackwener/opencli/errors';
+import {
+  assertLinkedInAuthenticated,
+  assertSafeLinkedinUrl,
+  normalizeHttpUrl,
+  normalizeWhitespace,
+  unwrapEvaluateResult,
+} from './shared.js';
+
+function normalizeJobUrl(value) {
+  const url = assertSafeLinkedinUrl(value, 'job-url');
+  const parsed = new URL(url);
+  const match = parsed.pathname.match(/^\/jobs\/view\/(\d+)/) || parsed.search.match(/[?&]currentJobId=(\d+)/);
+  if (!match) throw new ArgumentError('job-url must be a https://www.linkedin.com/jobs/view/<id> URL');
+  return `https://www.linkedin.com/jobs/search/?currentJobId=${match[1]}`;
+}
+
+function decodeLinkedinRedirect(url) {
+  if (!url) return '';
+  try {
+    const parsed = new URL(url);
+    if (parsed.pathname === '/redir/redirect/') return normalizeHttpUrl(parsed.searchParams.get('url') || '');
+  } catch {}
+  return normalizeHttpUrl(url);
+}
+
+function buildExtractionScript() {
+  return String.raw`(() => {
+    const clean = (s) => String(s || '').replace(/[\u00a0\u202f]+/g, ' ').replace(/\s+/g, ' ').trim();
+    const readRenderedDescription = () => {
+      const expanders = Array.from(document.querySelectorAll('button, a'))
+        .filter((el) => /\b(show more|see more|more)\b/i.test(clean(el.innerText || el.textContent || el.getAttribute('aria-label') || '')));
+      for (const expander of expanders.slice(0, 3)) {
+        try { expander.click(); } catch {}
+      }
+      const aboutHeading = Array.from(document.querySelectorAll('h1,h2,h3,h4'))
+        .find((el) => /^about the job$/i.test(clean(el.innerText || el.textContent || '')));
+      const aboutRoot = aboutHeading?.closest('section, article, div');
+      if (aboutRoot) {
+        const value = clean((aboutRoot.innerText || aboutRoot.textContent || '').replace(/^About the job\s*/i, ''));
+        if (value && !/^show more$/i.test(value)) return value;
+      }
+      const candidates = Array.from(document.querySelectorAll(
+        '.jobs-description-content__text, .jobs-box__html-content, .jobs-description__content, [class*="jobs-description"], [class*="description-content"]'
+      ));
+      for (const candidate of candidates) {
+        const value = clean(candidate.innerText || candidate.textContent || '');
+        if (value && value.length > 40 && !/^show more$/i.test(value)) return value.replace(/^About the job\s*/i, '');
+      }
+      return '';
+    };
+    const parseInlineJobData = () => {
+      const codes = Array.from(document.querySelectorAll('code[id^="bpr-guid-"]'));
+      for (const code of codes) {
+        let payload;
+        try { payload = JSON.parse(code.textContent || '{}'); } catch { continue; }
+        const included = Array.isArray(payload.included) ? payload.included : [];
+        const topCard = included.find((item) => item && (item.jobPostingTitle || item.primaryDescription || item.tertiaryDescription));
+        if (!topCard) continue;
+        const apply = included.find((item) => item && item.companyApplyUrl);
+        const workplace = included.find((item) => item && (item.workplaceTypeEnum || item.localizedName));
+        const company = included.find((item) => item && item.name && /company/i.test(String(item.entityUrn || item.$type || '')));
+        return {
+          url: location.href,
+          title: clean(topCard.jobPostingTitle || topCard.title?.text || topCard.title?.accessibilityText || ''),
+          company: clean(topCard.primaryDescription?.text || company?.name || ''),
+          company_url: clean(topCard.primaryDescription?.attributesV2?.[0]?.detailData?.hyperlink || topCard.logo?.actionTarget || ''),
+          location: clean(topCard.navigationBarSubtitle || topCard.secondaryDescription?.text || ''),
+          workplace_type: clean(workplace?.localizedName || workplace?.workplaceTypeEnum || ''),
+          job_type: clean((topCard.jobInsightsV2ResolutionResults || []).flatMap((x) => x?.jobInsightViewModel?.description || []).map((x) => x?.text?.text || '').find((x) => /full-time|part-time|contract|internship/i.test(x)) || ''),
+          applicants: clean((topCard.tertiaryDescription?.text || '').match(/Over\s+\d+|\d[\d,]*\s+people clicked apply|\d[\d,]*\s+applicants?/i)?.[0] || ''),
+          listed: clean((topCard.tertiaryDescription?.text || '').match(/\d+\s+(?:hour|hours|day|days|week|weeks|month|months)\s+ago/i)?.[0] || ''),
+          apply_url: clean(apply?.companyApplyUrl || ''),
+          description: '',
+        };
+      }
+      return null;
+    };
+    const inline = parseInlineJobData();
+    const renderedDescription = readRenderedDescription();
+    if (inline && inline.title) return { ...inline, description: clean(inline.description || renderedDescription) };
+    const text = document.body ? document.body.innerText || '' : '';
+    const lines = text.split(/\n+/).map(clean).filter(Boolean);
+    const h1 = clean(document.querySelector('h1')?.innerText || document.querySelector('h1')?.textContent || document.querySelector('.job-details-jobs-unified-top-card__job-title, [class*="job-title"]')?.textContent || '');
+    const companyLink = document.querySelector('a[href*="/company/"]');
+    const company = clean(companyLink?.innerText || companyLink?.textContent || '');
+    const company_url = companyLink?.href ? new URL(companyLink.href, location.origin).toString().replace(/[?#].*$/, '') : '';
+    const description = renderedDescription;
+    const applyLink = Array.from(document.querySelectorAll('a[href], button')).find((el) => {
+      const label = clean(el.innerText || el.textContent || el.getAttribute('aria-label') || '');
+      return /\b(apply|easy apply)\b/i.test(label);
+    });
+    const apply_url = applyLink?.href ? new URL(applyLink.href, location.origin).toString() : '';
+    const fullText = lines.join(' ');
+    const workplaceMatch = fullText.match(/\b(Remote|Hybrid|On-site|Onsite)\b/i);
+    const jobTypeMatch = fullText.match(/\b(Full-time|Part-time|Contract|Temporary|Internship|Volunteer)\b/i);
+    const applicantsMatch = fullText.match(/(\d[\d,]*)\s+applicants?/i);
+    const listedMatch = fullText.match(/(?:Reposted|Posted|Listed)\s+(\d+\s+(?:hour|hours|day|days|week|weeks|month|months)\s+ago)/i);
+    const locationLine = lines.find((line) => /\b(Remote|Hybrid|On-site|Onsite)\b/i.test(line) && line.length < 180)
+      || lines.find((line) => /,\s*[A-Z][A-Za-z\s]+/.test(line) && line.length < 120)
+      || '';
+    return {
+      url: location.href,
+      title: h1,
+      company,
+      company_url,
+      location: locationLine,
+      workplace_type: workplaceMatch ? workplaceMatch[1] : '',
+      job_type: jobTypeMatch ? jobTypeMatch[1] : '',
+      applicants: applicantsMatch ? applicantsMatch[1] : '',
+      listed: listedMatch ? listedMatch[1] : '',
+      apply_url,
+      description,
+    };
+  })()`;
+}
+
+function normalizeDetail(row) {
+  if (!row || typeof row !== 'object') {
+    throw new CommandExecutionError('LinkedIn job detail returned malformed extraction payload');
+  }
+  const title = normalizeWhitespace(row.title);
+  if (!title) throw new CommandExecutionError('LinkedIn job detail could not find a job title');
+  return {
+    title,
+    company: normalizeWhitespace(row.company),
+    location: normalizeWhitespace(row.location),
+    workplace_type: normalizeWhitespace(row.workplace_type),
+    job_type: normalizeWhitespace(row.job_type),
+    applicants: normalizeWhitespace(row.applicants),
+    listed: normalizeWhitespace(row.listed),
+    apply_url: decodeLinkedinRedirect(normalizeWhitespace(row.apply_url)),
+    company_url: normalizeHttpUrl(row.company_url),
+    url: normalizeHttpUrl(row.url),
+    description: normalizeWhitespace(row.description),
+  };
+}
+
+cli({
+  site: 'linkedin',
+  name: 'job-detail',
+  access: 'read',
+  description: 'Read one LinkedIn job page with description, apply URL, workplace type, applicants, and company metadata',
+  domain: 'www.linkedin.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    { name: 'job-url', type: 'string', required: true, positional: true, help: 'Exact LinkedIn job URL, e.g. https://www.linkedin.com/jobs/view/123/' },
+  ],
+  columns: ['title', 'company', 'location', 'workplace_type', 'job_type', 'applicants', 'listed', 'apply_url', 'company_url', 'url', 'description'],
+  func: async (page, args) => {
+    if (!page) throw new CommandExecutionError('Browser session required for linkedin job-detail');
+    const jobUrl = normalizeJobUrl(args['job-url']);
+    await page.goto(jobUrl);
+    await page.wait(4);
+    await assertLinkedInAuthenticated(page, 'LinkedIn job-detail');
+    const row = unwrapEvaluateResult(await page.evaluate(buildExtractionScript()));
+    return [normalizeDetail(row)];
+  },
+});
+
+export const __test__ = {
+  normalizeJobUrl,
+  decodeLinkedinRedirect,
+  normalizeDetail,
+};

package/clis/linkedin/job-detail.test.js

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError } from '@jackwener/opencli/errors';
+import './job-detail.js';
+
+const { normalizeJobUrl, decodeLinkedinRedirect, normalizeDetail } = await import('./job-detail.js').then((m) => m.__test__);
+
+describe('linkedin job-detail adapter', () => {
+  const command = getRegistry().get('linkedin/job-detail');
+
+  it('registers command shape', () => {
+    expect(command).toBeDefined();
+    expect(command.strategy).toBe('cookie');
+    expect(command.browser).toBe(true);
+    expect(command.columns).toContain('description');
+  });
+
+  it('normalizes exact LinkedIn job urls', () => {
+    expect(normalizeJobUrl('https://www.linkedin.com/jobs/view/123456?x=1')).toBe('https://www.linkedin.com/jobs/search/?currentJobId=123456');
+  });
+
+  it('rejects non-job URLs', () => {
+    expect(() => normalizeJobUrl('https://www.linkedin.com/feed/')).toThrow(ArgumentError);
+    expect(() => normalizeJobUrl('https://example.com/jobs/view/1')).toThrow(ArgumentError);
+  });
+
+  it('decodes LinkedIn redirect apply urls', () => {
+    expect(decodeLinkedinRedirect('https://www.linkedin.com/redir/redirect/?url=https%3A%2F%2Fexample.com%2Fapply')).toBe('https://example.com/apply');
+    expect(decodeLinkedinRedirect('https://www.linkedin.com/redir/redirect/?url=javascript%3Aalert(1)')).toBe('');
+    expect(decodeLinkedinRedirect('javascript:alert(1)')).toBe('');
+  });
+
+  it('requires stable title in extracted detail', () => {
+    expect(() => normalizeDetail({ title: '' })).toThrow(CommandExecutionError);
+    expect(normalizeDetail({ title: 'Senior Engineer', company: 'Acme', description: 'Build things' }))
+      .toMatchObject({ title: 'Senior Engineer', company: 'Acme', description: 'Build things' });
+  });
+});

package/clis/linkedin/jobs-preferences.js

@@ -0,0 +1,113 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import {
+  assertLinkedInAuthenticated,
+  normalizeWhitespace,
+  unwrapEvaluateResult,
+} from './shared.js';
+
+const PREFERENCES_URL = 'https://www.linkedin.com/jobs/preferences/';
+const ALERTS_URL = 'https://www.linkedin.com/jobs/alerts/';
+
+function inferOpenToWork(text) {
+  const normalized = normalizeWhitespace(text).toLowerCase();
+  if (/\bopen to work\b.{0,80}\b(on|status on|visible to recruiters|job preferences visible)\b/.test(normalized)) return 'on';
+  if (/\bopen to work\b.{0,80}\b(off|status off|not visible|turned off|inactive)\b/.test(normalized)) return 'off';
+  if (/\bopen to work\b/.test(normalized) && /\b(off|not visible|turned off|inactive)\b/.test(normalized)) return 'off';
+  if (/\bopen to work\b/.test(normalized) && /\b(on|visible|actively|turned on)\b/.test(normalized)) return 'on';
+  if (/\bopen to work\b/.test(normalized)) return 'visible';
+  return 'unknown';
+}
+
+function buildPreferencesScript() {
+  return String.raw`(() => {
+    const clean = (s) => String(s || '').replace(/[\u00a0\u202f]+/g, ' ').replace(/\s+/g, ' ').trim();
+    const text = document.body ? document.body.innerText || '' : '';
+    const preferencesText = text.split(/Top job picks for you|Recommended jobs|Similar jobs|Explore jobs/i)[0] || text;
+    const lines = preferencesText.split(/\n+/).map(clean).filter(Boolean);
+    const jobTitles = [];
+    const locations = [];
+    for (const line of lines) {
+      if (/senior|engineer|developer|architect|manager|designer|analyst|product/i.test(line) && line.length < 90) jobTitles.push(line);
+      if (/(remote|india|bangalore|bengaluru|delhi|mumbai|hyderabad|pune|jaipur|within\s+\d+\s+miles?)/i.test(line) && line.length < 120) locations.push(line);
+    }
+    return {
+      preferences_url: location.href,
+      raw_preferences: clean(text).slice(0, 3000),
+      job_titles: Array.from(new Set(jobTitles)).slice(0, 12),
+      locations: Array.from(new Set(locations)).slice(0, 12),
+    };
+  })()`;
+}
+
+function buildAlertsScript() {
+  return String.raw`(() => {
+    const clean = (s) => String(s || '').replace(/[\u00a0\u202f]+/g, ' ').replace(/\s+/g, ' ').trim();
+    const text = document.body ? document.body.innerText || '' : '';
+    const lines = text.split(/\n+/).map(clean).filter(Boolean);
+    const alerts = [];
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (/alert/i.test(line) && line.length < 160) {
+        alerts.push([line, lines[i + 1], lines[i + 2]].filter(Boolean).join(' | '));
+      }
+    }
+    return {
+      alerts_url: location.href,
+      job_alerts: Array.from(new Set(alerts)).slice(0, 20),
+      raw_preferences: clean(text).slice(0, 3000),
+    };
+  })()`;
+}
+
+function normalizePreferences(preferences, alerts) {
+  if (!preferences || typeof preferences !== 'object') {
+    throw new CommandExecutionError('LinkedIn jobs preferences returned malformed preferences payload');
+  }
+  if (!alerts || typeof alerts !== 'object') {
+    throw new CommandExecutionError('LinkedIn jobs preferences returned malformed alerts payload');
+  }
+  const preferenceText = normalizeWhitespace(preferences.raw_preferences);
+  const alertText = normalizeWhitespace(alerts.raw_preferences);
+  if (!preferenceText && !alertText) {
+    throw new CommandExecutionError('LinkedIn jobs preferences could not find stable preferences content');
+  }
+  return {
+    open_to_work: inferOpenToWork(`${preferenceText} ${alertText}`),
+    job_titles: Array.isArray(preferences.job_titles) ? preferences.job_titles.map(normalizeWhitespace).filter(Boolean).join('; ') : '',
+    locations: Array.isArray(preferences.locations) ? preferences.locations.map(normalizeWhitespace).filter(Boolean).join('; ') : '',
+    job_alerts: Array.isArray(alerts.job_alerts) ? alerts.job_alerts.map(normalizeWhitespace).filter(Boolean).join('; ') : '',
+    preferences_url: normalizeWhitespace(preferences.preferences_url),
+    alerts_url: normalizeWhitespace(alerts.alerts_url),
+    raw_preferences: preferenceText.slice(0, 1200),
+  };
+}
+
+cli({
+  site: 'linkedin',
+  name: 'jobs-preferences',
+  access: 'read',
+  description: 'Read visible LinkedIn Jobs preferences and alert settings without changing them',
+  domain: 'www.linkedin.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [],
+  columns: ['open_to_work', 'job_titles', 'locations', 'job_alerts', 'preferences_url', 'alerts_url', 'raw_preferences'],
+  func: async (page) => {
+    if (!page) throw new CommandExecutionError('Browser session required for linkedin jobs-preferences');
+    await page.goto(PREFERENCES_URL);
+    await page.wait(5);
+    await assertLinkedInAuthenticated(page, 'LinkedIn jobs-preferences');
+    const preferences = unwrapEvaluateResult(await page.evaluate(buildPreferencesScript()));
+    await page.goto(ALERTS_URL);
+    await page.wait(5);
+    await assertLinkedInAuthenticated(page, 'LinkedIn jobs-preferences alerts');
+    const alerts = unwrapEvaluateResult(await page.evaluate(buildAlertsScript()));
+    return [normalizePreferences(preferences, alerts)];
+  },
+});
+
+export const __test__ = {
+  inferOpenToWork,
+  normalizePreferences,
+};

package/clis/linkedin/jobs-preferences.test.js

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import './jobs-preferences.js';
+
+const { inferOpenToWork, normalizePreferences } = await import('./jobs-preferences.js').then((m) => m.__test__);
+
+describe('linkedin jobs-preferences adapter', () => {
+  const command = getRegistry().get('linkedin/jobs-preferences');
+
+  it('registers command shape', () => {
+    expect(command).toBeDefined();
+    expect(command.strategy).toBe('cookie');
+    expect(command.browser).toBe(true);
+    expect(command.columns).toContain('open_to_work');
+  });
+
+  it('infers Open to Work visible states conservatively', () => {
+    expect(inferOpenToWork('Open to work turned off')).toBe('off');
+    expect(inferOpenToWork('Open to work turned on visible to recruiters')).toBe('on');
+    expect(inferOpenToWork('Open to work')).toBe('visible');
+    expect(inferOpenToWork('Job preferences')).toBe('unknown');
+  });
+
+  it('normalizes preferences and alerts', () => {
+    const out = normalizePreferences(
+      { raw_preferences: 'Open to work turned off', job_titles: ['Senior Software Engineer'], locations: ['Bangalore within 20 miles'], preferences_url: 'https://www.linkedin.com/jobs/preferences/' },
+      { raw_preferences: 'Job alert', job_alerts: ['Senior Software Engineer | Bangalore'], alerts_url: 'https://www.linkedin.com/jobs/alerts/' },
+    );
+    expect(out).toMatchObject({
+      open_to_work: 'off',
+      job_titles: 'Senior Software Engineer',
+      locations: 'Bangalore within 20 miles',
+      job_alerts: 'Senior Software Engineer | Bangalore',
+    });
+  });
+
+  it('rejects malformed payloads', () => {
+    expect(() => normalizePreferences(null, {})).toThrow(CommandExecutionError);
+    expect(() => normalizePreferences({}, null)).toThrow(CommandExecutionError);
+    expect(() => normalizePreferences({ raw_preferences: '' }, { raw_preferences: '' })).toThrow(CommandExecutionError);
+  });
+});

package/clis/linkedin/people-search.js

@@ -0,0 +1,262 @@
+/**
+ * LinkedIn people-search via SSR DOM text-slice. Voyager people-search
+ * REST returns HTTP 500 from a web context; LinkedIn renders results
+ * server-side now. One navigation per call consumes one CUL query.
+ */
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+const LINKEDIN_DOMAIN = 'www.linkedin.com';
+const SEARCH_URL_BASE = 'https://www.linkedin.com/search/results/people/';
+const MAX_LIMIT = 10;
+
+function normalizeWhitespace(value) {
+    return String(value ?? '').replace(/[  ]/g, ' ').replace(/\s+/g, ' ').trim();
+}
+
+function requireStringArg(args, key, label = key) {
+    const value = normalizeWhitespace(args[key]);
+    if (!value) throw new ArgumentError(`${label} is required`);
+    return value;
+}
+
+function parseLimit(value) {
+    if (value === undefined || value === null || value === '') return 5;
+    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;
+}
+
+function buildSearchUrl(keywords) {
+    return SEARCH_URL_BASE + '?keywords=' + encodeURIComponent(keywords);
+}
+
+function looksLinkedInAuthWall(value) {
+    const text = normalizeWhitespace(value).toLowerCase();
+    if (!text) return false;
+    return /linkedin\.com\/(?:login|checkpoint|authwall|uas)/i.test(text)
+        || /\b(sign in|log in|join linkedin|captcha|verification required)\b/i.test(text)
+        || /(请登录|登录领英|安全验证)/.test(text);
+}
+
+function normalizeProfileUrl(value) {
+    const raw = normalizeWhitespace(value);
+    if (!raw) return '';
+    try {
+        const parsed = new URL(raw);
+        const host = parsed.hostname.toLowerCase();
+        if (parsed.protocol !== 'https:' || parsed.username || parsed.password || parsed.port) return '';
+        if (host !== 'linkedin.com' && host !== 'www.linkedin.com') return '';
+        const match = parsed.pathname.match(/^\/in\/([^/?#]+)\/?$/);
+        if (!match || !match[1]) return '';
+        return `https://www.linkedin.com/in/${match[1]}/`;
+    } catch {
+        return '';
+    }
+}
+
+function normalizePeopleRows(rows) {
+    if (!Array.isArray(rows)) {
+        throw new CommandExecutionError('LinkedIn people search returned malformed extraction payload: missing rows array');
+    }
+    return rows.map((row, index) => {
+        if (!row || typeof row !== 'object') {
+            throw new CommandExecutionError(`LinkedIn people search returned malformed row at index ${index}`);
+        }
+        const name = normalizeWhitespace(row.name);
+        const profileUrl = normalizeProfileUrl(row.profile_url);
+        if (!name || !profileUrl) {
+            throw new CommandExecutionError(`LinkedIn people search returned row without stable profile identity at index ${index}`);
+        }
+        return {
+            name,
+            headline: normalizeWhitespace(row.headline),
+            location: normalizeWhitespace(row.location),
+            profile_url: profileUrl,
+        };
+    });
+}
+
+function parseNonNegativeCount(value, label) {
+    const count = Number(value);
+    if (!Number.isInteger(count) || count < 0) {
+        throw new CommandExecutionError(`LinkedIn people search returned malformed extraction payload: invalid ${label}`);
+    }
+    return count;
+}
+
+function extractionScript() {
+    // Class-based selectors are dead (LinkedIn rotates hashed class
+    // names on every deploy) and display:contents flattens the DOM
+    // tree so per-card containers don't exist. Read main.innerText
+    // and slice between consecutive person-name lines instead.
+    return String.raw`(() => {
+    if (!/search\/results\/people/.test(window.location.href)) {
+      return { error: 'not on people search page', url: window.location.href };
+    }
+    const main = document.querySelector('main') || document.body;
+    const normalize = (s) => String(s || '').replace(/[\s\u00a0\u202f]+/g, ' ').trim();
+    const skip = (l) => !l
+      || /^Status is/.test(l)
+      || /^(Message|Connect|Follow|View profile|Pending|Remove)$/i.test(l)
+      || /^[•·]\s*(?:1st|2nd|3rd\+?|degree)/i.test(l)
+      || /^[•·]/.test(l)
+      || l.includes('mutual connection')
+      || l.includes('shared connection')
+      || /^Summary:/i.test(l)
+      || /^About this profile/i.test(l);
+
+    const anchors = Array.from(main.querySelectorAll('a[href*="/in/"]'));
+    const personEntries = [];
+    const seenHandles = new Set();
+    for (const a of anchors) {
+      const m = (a.getAttribute('href') || '').match(/\/in\/([^/?#]+)/);
+      if (!m || !m[1]) continue;
+      const profileHandle = m[1];
+      if (seenHandles.has(profileHandle)) continue;
+      const aria = a.querySelector('span[aria-hidden="true"]');
+      let name = normalize(aria ? aria.textContent : a.textContent);
+      name = name.replace(/^Status is (online|offline)\.?\s*/i, '')
+                 .replace(/'?s profile$/i, '')
+                 .replace(/\s*[•·].*$/, '').trim();
+      if (!name) continue;
+      seenHandles.add(profileHandle);
+      personEntries.push({ profileHandle, displayName: name });
+    }
+
+    const lines = (main.innerText || '').split(/\n+/).map(normalize).filter(Boolean);
+
+    // skip() rejects mutual-connection lines, so candidates that only
+    // appear as mutual-connection links inside another card's row
+    // never resolve a name index and get filtered out below.
+    const nameToIndex = new Map();
+    for (const { displayName } of personEntries) {
+      if (nameToIndex.has(displayName)) continue;
+      const match = lines.findIndex((l) =>
+        !skip(l) && (
+          l === displayName
+          || l.startsWith(displayName + ' ')
+          || l.startsWith(displayName + ',')
+          || l.startsWith(displayName + "'")
+        )
+      );
+      if (match >= 0) nameToIndex.set(displayName, match);
+    }
+
+    const resolved = personEntries.filter((p) => nameToIndex.has(p.displayName));
+    const rows = [];
+    for (let i = 0; i < resolved.length; i++) {
+      const { profileHandle, displayName } = resolved[i];
+      const startIdx = nameToIndex.get(displayName);
+      let stopIdx = lines.length;
+      for (let j = i + 1; j < resolved.length; j++) {
+        const otherStart = nameToIndex.get(resolved[j].displayName);
+        if (otherStart != null && otherStart > startIdx) {
+          stopIdx = otherStart;
+          break;
+        }
+      }
+      const slice = lines.slice(startIdx + 1, stopIdx).filter((l) => l !== displayName && !skip(l));
+      rows.push({
+        name: displayName,
+        headline: slice[0] || '',
+        location: slice[1] || '',
+        profile_url: 'https://www.linkedin.com/in/' + profileHandle + '/',
+      });
+    }
+    return {
+      rows,
+      candidate_count: personEntries.length,
+      person_entries_count: personEntries.length,
+      resolved_count: resolved.length,
+    };
+  })()`;
+}
+
+cli({
+    site: 'linkedin',
+    name: 'people-search',
+    access: 'read',
+    description: 'Search standard LinkedIn (not Sales Navigator) for people by keyword. Each invocation consumes against LinkedIn\'s monthly Commercial Use Limit on people search; throttle accordingly.',
+    domain: LINKEDIN_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'keywords', type: 'string', required: true, positional: true, help: 'People search keywords, e.g. "site reliability engineer berlin"' },
+        { name: 'limit', type: 'int', default: 5, help: `Maximum people to return (1-${MAX_LIMIT}); each query counts toward LinkedIn's monthly CUL` },
+    ],
+    columns: ['rank', 'name', 'headline', 'location', 'profile_url'],
+    func: async (page, args) => {
+        if (!page) throw new CommandExecutionError('Browser session required for linkedin people-search');
+        const keywords = requireStringArg(args, 'keywords', '--keywords');
+        const limit = parseLimit(args.limit);
+
+        try {
+            await page.goto(buildSearchUrl(keywords));
+            await page.wait(6);
+        } catch (error) {
+            throw new CommandExecutionError(`LinkedIn people search navigation failed: ${error?.message || error}`);
+        }
+
+        let cookies;
+        try {
+            cookies = await page.getCookies({ url: 'https://www.linkedin.com' });
+        } catch (error) {
+            throw new CommandExecutionError(`LinkedIn cookie lookup failed: ${error?.message || error}`);
+        }
+        if (!Array.isArray(cookies)) {
+            throw new CommandExecutionError('LinkedIn cookie lookup returned malformed payload');
+        }
+        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 in the browser.');
+        }
+
+        let result;
+        try {
+            result = unwrapEvaluateResult(await page.evaluate(extractionScript()));
+        } catch (error) {
+            throw new CommandExecutionError(`LinkedIn people search extraction failed: ${error?.message || error}`);
+        }
+        if (result?.error) {
+            if (looksLinkedInAuthWall(`${result.url || ''} ${result.error || ''}`)) {
+                throw new AuthRequiredError(LINKEDIN_DOMAIN, 'LinkedIn people search requires an active signed-in browser session.');
+            }
+            // If LinkedIn redirected away from the search page that
+            // usually means CUL was reached or the account is gated.
+            throw new CommandExecutionError(`LinkedIn redirected away from the search page (${result.error}). Likely Commercial Use Limit reached - the limit resets on the 1st of next month.`);
+        }
+        if (!result || typeof result !== 'object') {
+            throw new CommandExecutionError('LinkedIn people search returned malformed extraction payload');
+        }
+        const candidateCount = parseNonNegativeCount(result.candidate_count, 'candidate_count');
+        parseNonNegativeCount(result.person_entries_count, 'person_entries_count');
+        const resolvedCount = parseNonNegativeCount(result.resolved_count, 'resolved_count');
+        const rows = normalizePeopleRows(result.rows);
+        if (rows.length === 0 && (candidateCount > 0 || resolvedCount > 0)) {
+            throw new CommandExecutionError('LinkedIn people search found profile candidates but could not parse stable result rows');
+        }
+        if (rows.length === 0) {
+            throw new EmptyResultError(`No people found on the rendered page for "${keywords}". The search may have returned zero results, or the DOM markup may have changed.`);
+        }
+        return rows.slice(0, limit).map((p, i) => ({ rank: i + 1, ...p }));
+    },
+});
+
+export const __test__ = {
+    normalizeWhitespace,
+    parseLimit,
+    buildSearchUrl,
+    looksLinkedInAuthWall,
+    normalizeProfileUrl,
+    normalizePeopleRows,
+    parseNonNegativeCount,
+    extractionScript,
+};