@jackwener/opencli 1.8.0 → 1.8.1

package/clis/linkedin/profile-read.js

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

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

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

package/clis/linkedin/services-read.js

@@ -0,0 +1,213 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import {
+  assertLinkedInAuthenticated,
+  assertSafeLinkedinUrl,
+  normalizeWhitespace,
+  unwrapEvaluateResult,
+} from './shared.js';
+
+function normalizeProfileUrl(value) {
+  const url = assertSafeLinkedinUrl(value || 'https://www.linkedin.com/in/me/', 'profile-url', '/in/me/');
+  const parsed = new URL(url);
+  if (!/^\/in\/[^/?#]+\/?$/.test(parsed.pathname)) {
+    throw new CommandExecutionError('LinkedIn services-read requires a /in/<handle>/ profile URL');
+  }
+  return parsed.toString();
+}
+
+function normalizeServicesUrl(value) {
+  const url = assertSafeLinkedinUrl(value, 'services-url', '/services/page/');
+  const parsed = new URL(url);
+  if (!/^\/services\/page\/[^/?#]+\/?$/.test(parsed.pathname)) {
+    throw new CommandExecutionError('LinkedIn services-read requires a /services/page/<id>/ URL');
+  }
+  return parsed.toString();
+}
+
+function buildFindServicesUrlScript() {
+  return String.raw`(() => {
+    const link = Array.from(document.querySelectorAll('a[href*="/services/page/"]'))
+      .map((a) => a.href || '')
+      .find(Boolean);
+    return { services_url: link || '' };
+  })()`;
+}
+
+function buildServicesPageScript() {
+  return String.raw`(() => {
+    const clean = (s) => String(s || '').replace(/[\u00a0\u202f]+/g, ' ').replace(/\s+/g, ' ').trim();
+    const lines = (document.body?.innerText || '').split(/\n+/).map(clean).filter(Boolean);
+    const unique = (items) => Array.from(new Set(items.filter(Boolean)));
+    const collectAfter = (label, stops) => {
+      const index = lines.findIndex((line) => line === label);
+      if (index < 0) return [];
+      const out = [];
+      for (let i = index + 1; i < lines.length; i++) {
+        if (stops.includes(lines[i])) break;
+        if (lines[i] !== label) out.push(lines[i]);
+      }
+      return unique(out);
+    };
+    return {
+      service_url: location.href,
+      page_title: clean(document.querySelector('main h1, h1')?.innerText || document.title || ''),
+      overview: collectAfter('Overview', ['Availability', 'Pricing', 'Services provided', 'Media', 'Reviews']).join('\n'),
+      availability: collectAfter('Availability', ['Pricing', 'Services provided', 'Media', 'Reviews']).join('; '),
+      pricing: collectAfter('Pricing', ['Services provided', 'Media', 'Reviews']).join('; '),
+      services_provided: collectAfter('Services provided', ['Media', 'Reviews', 'Pricing', 'Availability', 'Overview']),
+    };
+  })()`;
+}
+
+function buildMediaPageScript() {
+  return String.raw`(() => {
+    const clean = (s) => String(s || '').replace(/[\u00a0\u202f]+/g, ' ').replace(/\s+/g, ' ').trim();
+    const lines = (document.body?.innerText || '').split(/\n+/).map(clean).filter(Boolean);
+    const start = lines.findIndex((line) => line === 'Add media');
+    const end = lines.findIndex((line, index) => index > start && line === 'Done');
+    const media_lines = start >= 0 && end > start ? lines.slice(start + 1, end) : [];
+    return { media_lines };
+  })()`;
+}
+
+function buildServicesEditScript() {
+  return String.raw`(() => {
+    const clean = (s) => String(s || '').replace(/[\u00a0\u202f]+/g, ' ').replace(/\s+/g, ' ').trim();
+    const dialog = document.querySelector('dialog') || document;
+    const overview = dialog.querySelector('textarea')?.value || '';
+    const checked = Array.from(dialog.querySelectorAll('[role="checkbox"], [role="switch"], input[type="checkbox"]'))
+      .map((el) => ({
+        label: clean(el.getAttribute('aria-label') || el.innerText || el.closest('div')?.innerText || el.parentElement?.innerText || ''),
+        checked: el.getAttribute('aria-checked') === 'true' || el.checked === true,
+      }));
+    const radios = Array.from(dialog.querySelectorAll('[role="radio"], input[type="radio"]'))
+      .map((el) => ({
+        label: clean(el.getAttribute('aria-label') || el.innerText || el.closest('div')?.innerText || el.parentElement?.innerText || ''),
+        checked: el.getAttribute('aria-checked') === 'true' || el.checked === true,
+      }));
+    return {
+      overview,
+      work_locations: checked.filter((item) => item.checked && !/message|linkedin members|reviews?/i.test(item.label)).map((item) => item.label),
+      messages: checked.find((item) => /message|open profile/i.test(item.label))?.checked ? 'on' : 'off',
+      reviews_visibility: checked.find((item) => /all linkedin members/i.test(item.label))?.checked ? 'on' : 'off',
+      pricing: radios.find((item) => item.checked)?.label || '',
+    };
+  })()`;
+}
+
+function pairsToMedia(items) {
+  const lines = Array.isArray(items) ? items.map(normalizeWhitespace).filter(Boolean) : [];
+  const pairs = [];
+  for (let i = 0; i < lines.length; i += 2) {
+    const title = lines[i] || '';
+    const description = lines[i + 1] || '';
+    if (title) pairs.push(description ? `${title} — ${description}` : title);
+  }
+  return pairs;
+}
+
+function normalizeServices(row) {
+  if (!row || typeof row !== 'object') {
+    throw new CommandExecutionError('LinkedIn services-read returned malformed extraction payload');
+  }
+  const services = Array.isArray(row.services_provided) ? row.services_provided.map(normalizeWhitespace).filter(Boolean) : [];
+  const mediaItems = pairsToMedia(row.media_lines);
+  const publicMedia = [];
+  const serviceUrl = normalizeWhitespace(row.service_url);
+  const pageTitle = normalizeWhitespace(row.page_title);
+  const overview = normalizeWhitespace(row.overview);
+  const availability = normalizeWhitespace(row.availability);
+  if (!serviceUrl || (!pageTitle && !overview && services.length === 0)) {
+    throw new CommandExecutionError('LinkedIn services-read could not find stable Services page content');
+  }
+  return {
+    service_url: serviceUrl,
+    page_title: pageTitle,
+    overview,
+    availability,
+    work_locations: Array.isArray(row.work_locations) ? row.work_locations.map((item) => {
+      const text = normalizeWhitespace(item);
+      const words = text.split(' ');
+      if (words.length % 2 === 0) {
+        const half = words.length / 2;
+        const left = words.slice(0, half).join(' ');
+        if (left === words.slice(half).join(' ')) return left;
+      }
+      return text;
+    }).filter(Boolean).join('; ') : '',
+    pricing: normalizeWhitespace(row.pricing).replace(/^Pricing,\s*Select one option,\s*/i, '').replace(/,\s*required$/i, ''),
+    services_provided: services.join('; '),
+    services_count: String(services.length),
+    media: (mediaItems.length > 0 ? mediaItems : publicMedia).join('\n'),
+    media_count: String(mediaItems.length || publicMedia.length),
+    messages: normalizeWhitespace(row.messages),
+    reviews_visibility: normalizeWhitespace(row.reviews_visibility),
+  };
+}
+
+async function readOwnerOnlyServicesEdit(page, servicesUrl) {
+  const editUrl = new URL(servicesUrl);
+  editUrl.pathname = editUrl.pathname.replace(/\/?$/, '/edit/');
+  await page.goto(editUrl.toString());
+  await page.wait(4);
+  await assertLinkedInAuthenticated(page, 'LinkedIn services-read edit');
+  return unwrapEvaluateResult(await page.evaluate(buildServicesEditScript()));
+}
+
+cli({
+  site: 'linkedin',
+  name: 'services-read',
+  access: 'read',
+  description: 'Read LinkedIn Services page details including services, overview, availability, pricing, and media titles/descriptions',
+  domain: 'www.linkedin.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    { name: 'profile-url', type: 'string', required: false, help: 'LinkedIn /in/<handle>/ profile URL. Defaults to /in/me/.' },
+    { name: 'services-url', type: 'string', required: false, help: 'LinkedIn /services/page/<id>/ URL. If omitted, it is discovered from the profile.' },
+  ],
+  columns: ['service_url', 'page_title', 'overview', 'availability', 'work_locations', 'pricing', 'services_provided', 'services_count', 'media', 'media_count', 'messages', 'reviews_visibility'],
+  func: async (page, args) => {
+    if (!page) throw new CommandExecutionError('Browser session required for linkedin services-read');
+    let servicesUrl = normalizeWhitespace(args['services-url']);
+    const shouldReadOwnerEdit = !servicesUrl && !normalizeWhitespace(args['profile-url']);
+    if (servicesUrl) {
+      servicesUrl = normalizeServicesUrl(servicesUrl);
+    } else {
+      await page.goto(normalizeProfileUrl(args['profile-url']));
+      await page.wait(5);
+      await assertLinkedInAuthenticated(page, 'LinkedIn services-read profile');
+      const found = unwrapEvaluateResult(await page.evaluate(buildFindServicesUrlScript()));
+      servicesUrl = normalizeWhitespace(found?.services_url);
+      if (!servicesUrl) throw new EmptyResultError('linkedin services-read', 'No LinkedIn Services page link was found on the profile.');
+      servicesUrl = normalizeServicesUrl(servicesUrl);
+    }
+
+    await page.goto(servicesUrl);
+    await page.wait(5);
+    await assertLinkedInAuthenticated(page, 'LinkedIn services-read');
+    const services = unwrapEvaluateResult(await page.evaluate(buildServicesPageScript()));
+
+    const edit = shouldReadOwnerEdit ? await readOwnerOnlyServicesEdit(page, servicesUrl) : {};
+
+    let media = {};
+    if (shouldReadOwnerEdit) {
+      const mediaUrl = new URL(servicesUrl);
+      mediaUrl.pathname = mediaUrl.pathname.replace(/\/?$/, '/media/');
+      await page.goto(mediaUrl.toString());
+      await page.wait(4);
+      await assertLinkedInAuthenticated(page, 'LinkedIn services-read media');
+      media = unwrapEvaluateResult(await page.evaluate(buildMediaPageScript()));
+    }
+
+    return [normalizeServices({ ...services, ...edit, ...media })];
+  },
+});
+
+export const __test__ = {
+  normalizeProfileUrl,
+  normalizeServicesUrl,
+  pairsToMedia,
+  normalizeServices,
+};

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

@@ -0,0 +1,105 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import './services-read.js';
+
+const {
+  normalizeProfileUrl,
+  normalizeServicesUrl,
+  normalizeServices,
+  pairsToMedia,
+} = await import('./services-read.js').then((m) => m.__test__);
+
+describe('linkedin services-read adapter', () => {
+  const command = getRegistry().get('linkedin/services-read');
+
+  it('registers command shape', () => {
+    expect(command).toBeDefined();
+    expect(command.strategy).toBe('cookie');
+    expect(command.browser).toBe(true);
+    expect(command.columns).toEqual([
+      'service_url',
+      'page_title',
+      'overview',
+      'availability',
+      'work_locations',
+      'pricing',
+      'services_provided',
+      'services_count',
+      'media',
+      'media_count',
+      'messages',
+      'reviews_visibility',
+    ]);
+  });
+
+  it('normalizes profile and services URLs', () => {
+    expect(normalizeProfileUrl(undefined)).toBe('https://www.linkedin.com/in/me/');
+    expect(normalizeProfileUrl('https://www.linkedin.com/in/gauravsaxena1997/')).toBe('https://www.linkedin.com/in/gauravsaxena1997/');
+    expect(normalizeServicesUrl('https://www.linkedin.com/services/page/854507342066b51989/')).toBe('https://www.linkedin.com/services/page/854507342066b51989/');
+  });
+
+  it('rejects invalid URL shapes', () => {
+    expect(() => normalizeProfileUrl('https://www.linkedin.com/jobs/')).toThrow(CommandExecutionError);
+    expect(() => normalizeServicesUrl('https://www.linkedin.com/in/gauravsaxena1997/')).toThrow(CommandExecutionError);
+  });
+
+  it('pairs media title and description lines', () => {
+    expect(pairsToMedia(['Portfolio', 'Builds AI products', 'GitHub', 'Open source work']))
+      .toEqual(['Portfolio — Builds AI products', 'GitHub — Open source work']);
+  });
+
+  it('normalizes services payload into command columns', () => {
+    expect(normalizeServices({
+      service_url: 'https://www.linkedin.com/services/page/abc/',
+      page_title: 'Gaurav Services',
+      overview: ' Builds AI ',
+      availability: 'Remote',
+      work_locations: ['Greater Jaipur Area', 'I am available to work remotely'],
+      pricing: 'Pricing, Select one option, Contact for pricing, required',
+      services_provided: ['Web Development', 'SaaS Development'],
+      media_lines: ['Portfolio', 'AI products'],
+      messages: 'on',
+      reviews_visibility: 'off',
+    })).toEqual({
+      service_url: 'https://www.linkedin.com/services/page/abc/',
+      page_title: 'Gaurav Services',
+      overview: 'Builds AI',
+      availability: 'Remote',
+      work_locations: 'Greater Jaipur Area; I am available to work remotely',
+      pricing: 'Contact for pricing',
+      services_provided: 'Web Development; SaaS Development',
+      services_count: '2',
+      media: 'Portfolio — AI products',
+      media_count: '1',
+      messages: 'on',
+      reviews_visibility: 'off',
+    });
+  });
+
+  it('fails closed when a services page payload has no stable content', () => {
+    expect(() => normalizeServices({ service_url: 'https://www.linkedin.com/services/page/abc/' }))
+      .toThrow(CommandExecutionError);
+    expect(() => normalizeServices({ page_title: 'Alice Services' }))
+      .toThrow(CommandExecutionError);
+  });
+
+  it('does not require edit access when reading an explicit services URL', async () => {
+    const page = {
+      goto: vi.fn(async () => {}),
+      wait: vi.fn(async () => {}),
+      evaluate: vi.fn()
+        .mockResolvedValueOnce(false)
+        .mockResolvedValueOnce({
+          service_url: 'https://www.linkedin.com/services/page/abc/',
+          page_title: 'Alice Services',
+          overview: 'Builds AI',
+          services_provided: ['AI Consulting'],
+        }),
+    };
+
+    await expect(command.func(page, { 'services-url': 'https://www.linkedin.com/services/page/abc/' }))
+      .resolves.toMatchObject([{ page_title: 'Alice Services', services_count: '1' }]);
+    expect(page.goto.mock.calls.map(([url]) => String(url))).toEqual(['https://www.linkedin.com/services/page/abc/']);
+  });
+});

package/clis/linkedin/shared.js

@@ -0,0 +1,124 @@
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+
+export const LINKEDIN_DOMAIN = 'www.linkedin.com';
+
+export function unwrapEvaluateResult(payload) {
+  if (payload && typeof payload === 'object' && 'data' in payload && 'session' in payload) return payload.data;
+  return payload;
+}
+
+export function normalizeWhitespace(value) {
+  return String(value ?? '').replace(/[\u00a0\u202f]+/g, ' ').replace(/\s+/g, ' ').trim();
+}
+
+export function normalizeHttpUrl(value, base) {
+  const raw = normalizeWhitespace(value);
+  if (!raw) return '';
+  try {
+    const parsed = base ? new URL(raw, base) : new URL(raw);
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') return '';
+    if (parsed.username || parsed.password) return '';
+    return parsed.toString();
+  } catch {
+    return '';
+  }
+}
+
+export function compactRepeatedText(value) {
+  const text = normalizeWhitespace(value);
+  if (!text) return '';
+  if (text.length % 2 === 0) {
+    const half = text.length / 2;
+    const left = text.slice(0, half);
+    if (left === text.slice(half)) return left;
+  }
+  const words = text.split(' ');
+  if (words.length % 2 === 0) {
+    const half = words.length / 2;
+    const left = words.slice(0, half).join(' ');
+    if (left === words.slice(half).join(' ')) return left;
+  }
+  return text;
+}
+
+export 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);
+}
+
+export function assertSafeLinkedinUrl(value, label, fallbackPath = '/') {
+  const raw = normalizeWhitespace(value || `https://www.linkedin.com${fallbackPath}`);
+  let parsed;
+  try {
+    parsed = new URL(raw, 'https://www.linkedin.com');
+  } catch {
+    throw new ArgumentError(`${label} must be a LinkedIn URL`);
+  }
+  const host = parsed.hostname.toLowerCase();
+  if (parsed.protocol !== 'https:' || parsed.username || parsed.password || parsed.port) {
+    throw new ArgumentError(`${label} must be an https LinkedIn URL without credentials or port`);
+  }
+  if (host !== 'linkedin.com' && host !== 'www.linkedin.com') {
+    throw new ArgumentError(`${label} must point to linkedin.com`);
+  }
+  return parsed.toString();
+}
+
+export function requireStringArg(args, key, label = key) {
+  const value = normalizeWhitespace(args?.[key]);
+  if (!value) throw new ArgumentError(`${label} is required`);
+  return value;
+}
+
+export function parseLimit(value, fallback, max) {
+  if (value === undefined || value === null || value === '') return fallback;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > max) {
+    throw new ArgumentError(`--limit must be an integer between 1 and ${max}`);
+  }
+  return parsed;
+}
+
+export async function requireLinkedInCookie(page, context) {
+  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, `${context} requires an active signed-in LinkedIn browser session.`);
+  }
+  return jsession.replace(/^"|"$/g, '');
+}
+
+export function buildAuthProbeScript() {
+  return String.raw`(() => {
+    const text = [
+      window.location.href || '',
+      document.title || '',
+      document.body ? (document.body.innerText || '').slice(0, 4000) : '',
+    ].join('\n');
+    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);
+  })()`;
+}
+
+export async function assertLinkedInAuthenticated(page, context) {
+  const authRequired = unwrapEvaluateResult(await page.evaluate(buildAuthProbeScript()));
+  if (authRequired) {
+    throw new AuthRequiredError(LINKEDIN_DOMAIN, `${context} requires an active signed-in LinkedIn browser session.`);
+  }
+}
+
+export function splitVisibleLines(text) {
+  return String(text || '').split(/\n+/).map(normalizeWhitespace).filter(Boolean);
+}