@jackwener/opencli 1.8.0 → 1.8.1

package/clis/jira/search.js

@@ -0,0 +1,47 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { jiraConfig, issueSummaryRow, jiraRowsOrEmpty, parseJiraLimit } from './shared.js';
+import { atlassianRequest, requirePayloadArray, requirePayloadObject, requireString } from '../_atlassian/shared.js';
+
+function searchPath(config) {
+    return config.deployment === 'cloud' ? '/rest/api/3/search/jql' : '/rest/api/2/search';
+}
+
+function searchPayload(config, jql, limit) {
+    const fields = ['summary', 'issuetype', 'status', 'priority', 'assignee', 'updated'];
+    if (config.deployment === 'cloud') return { jql, maxResults: limit, fields };
+    return { jql, startAt: 0, maxResults: limit, fields };
+}
+
+cli({
+    site: 'jira',
+    name: 'search',
+    access: 'read',
+    description: 'Search Jira issues with JQL',
+    domain: 'atlassian.net',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'jql', positional: true, required: true, help: 'JQL query, e.g. "project = PROJ order by updated desc"' },
+        { name: 'limit', type: 'int', default: 20, help: 'Max issues to return (1-100)' },
+    ],
+    columns: ['key', 'summary', 'issueType', 'status', 'priority', 'assignee', 'updated', 'url'],
+    func: async (args) => {
+        const config = jiraConfig();
+        const jql = requireString(args.jql, 'JQL');
+        const limit = parseJiraLimit(args.limit, 20, 100);
+        const data = await atlassianRequest(config, searchPath(config), {
+            method: 'POST',
+            body: searchPayload(config, jql, limit),
+            label: 'jira search',
+        });
+        const payload = requirePayloadObject(data, 'jira search');
+        const issues = requirePayloadArray(payload.issues, 'jira search issues');
+        return jiraRowsOrEmpty(
+            issues.map((issue) => issueSummaryRow(issue, config)),
+            'jira search',
+            `No Jira issues matched "${jql}".`,
+        );
+    },
+});
+
+export const __test__ = { searchPath, searchPayload };

package/clis/jira/shared.js

@@ -0,0 +1,256 @@
+import {
+    adfToMarkdown,
+    atlassianRequest,
+    getJiraConfig,
+    htmlToMarkdown,
+    parseLimit,
+    queryString,
+    requireNonEmptyRows,
+    requirePayloadArray,
+    requirePayloadObject,
+    requirePayloadString,
+    requireString,
+} from '../_atlassian/shared.js';
+import { ArgumentError } from '@jackwener/opencli/errors';
+
+const DEFAULT_ISSUE_FIELDS = [
+    'summary',
+    'issuetype',
+    'status',
+    'priority',
+    'labels',
+    'description',
+    'comment',
+    'attachment',
+    'issuelinks',
+    'fixVersions',
+    'versions',
+    'components',
+    'project',
+    'reporter',
+    'assignee',
+    'created',
+    'updated',
+];
+
+function jiraApiPrefix(config) {
+    return `/rest/api/${config.deployment === 'cloud' ? '3' : '2'}`;
+}
+
+export function jiraApiPath(config, resource, params) {
+    return `${jiraApiPrefix(config)}${resource.startsWith('/') ? resource : `/${resource}`}${params ? queryString(params) : ''}`;
+}
+
+export async function jiraRequest(config, resource, options = {}) {
+    return atlassianRequest(config, jiraApiPath(config, resource, options.params), options);
+}
+
+function configuredFieldNames() {
+    return {
+        acceptanceCriteria: process.env.ATLASSIAN_JIRA_ACCEPTANCE_FIELD?.trim() || '',
+        sprint: process.env.ATLASSIAN_JIRA_SPRINT_FIELD?.trim() || '',
+        storyPoints: process.env.ATLASSIAN_JIRA_STORY_POINTS_FIELD?.trim() || '',
+    };
+}
+
+function issueFields(extraFields = []) {
+    const configured = Object.values(configuredFieldNames()).filter(Boolean);
+    return [...new Set([...DEFAULT_ISSUE_FIELDS, ...configured, ...extraFields.filter(Boolean)])].join(',');
+}
+
+export function parseJiraLimit(value, fallback = 20, max = 100) {
+    return parseLimit(value, fallback, max, 'jira limit');
+}
+
+export function requireIssueKey(value) {
+    const key = requireString(value, 'Jira issue key');
+    if (!/^[A-Za-z][A-Za-z0-9_]+-\d+$/.test(key)) {
+        throw new ArgumentError(`Invalid Jira issue key: ${key}`, 'Expected a key like PROJECT-123.');
+    }
+    return key.toUpperCase();
+}
+
+function displayUser(user) {
+    if (!user || typeof user !== 'object') return '';
+    return String(user.displayName ?? user.name ?? user.emailAddress ?? user.accountId ?? '');
+}
+
+function valueName(value) {
+    if (!value) return '';
+    if (typeof value === 'string') return value;
+    if (typeof value === 'object') return String(value.name ?? value.value ?? value.key ?? value.id ?? '');
+    return String(value);
+}
+
+function valueNames(values) {
+    return Array.isArray(values) ? values.map(valueName).filter(Boolean) : [];
+}
+
+export function jiraBodyToMarkdown(raw, rendered) {
+    if (rendered) return htmlToMarkdown(rendered);
+    if (raw && typeof raw === 'object') return adfToMarkdown(raw);
+    if (typeof raw === 'string') return raw.trim();
+    return '';
+}
+
+export function normalizeComment(comment) {
+    const row = requirePayloadObject(comment, 'jira comment');
+    return {
+        id: requirePayloadString(row.id, 'comment id', 'jira comment'),
+        author: displayUser(row.author),
+        created: row.created ? String(row.created) : '',
+        updated: row.updated ? String(row.updated) : undefined,
+        markdown: jiraBodyToMarkdown(row.body, row.renderedBody),
+    };
+}
+
+export function normalizeAttachment(attachment) {
+    const row = requirePayloadObject(attachment, 'jira attachment');
+    return {
+        id: requirePayloadString(row.id, 'attachment id', 'jira attachment'),
+        filename: requirePayloadString(row.filename, 'filename', 'jira attachment'),
+        mimeType: row.mimeType ? String(row.mimeType) : undefined,
+        size: row.size != null ? Number(row.size) : undefined,
+        url: requirePayloadString(row.content ?? row.self, 'attachment url', 'jira attachment'),
+    };
+}
+
+export function normalizeIssueLink(link) {
+    const row = requirePayloadObject(link, 'jira issue link');
+    const outward = row.outwardIssue;
+    const inward = row.inwardIssue;
+    const issue = outward ?? inward ?? {};
+    const key = requirePayloadString(issue.key, 'linked issue key', 'jira issue link');
+    return {
+        key,
+        type: String(row.type?.name ?? (outward ? row.type?.outward : row.type?.inward) ?? ''),
+        direction: outward ? 'outward' : 'inward',
+    };
+}
+
+function customValueToMarkdown(value) {
+    if (!value) return '';
+    if (typeof value === 'string') return value.trim();
+    if (value && typeof value === 'object' && value.type === 'doc') return adfToMarkdown(value);
+    if (Array.isArray(value)) return value.map(valueName).filter(Boolean).join(', ');
+    return valueName(value);
+}
+
+function inlineComments(fields, key, options) {
+    if (options.comments !== undefined) return requirePayloadArray(options.comments, `jira issue ${key} comments`);
+    if (options.requireNestedCollections === false) return [];
+    const commentBlock = requirePayloadObject(fields.comment, `jira issue ${key} comment field`);
+    return requirePayloadArray(commentBlock.comments, `jira issue ${key} comment field comments`);
+}
+
+export function normalizeJiraIssue(issue, config, options = {}) {
+    const row = requirePayloadObject(issue, 'jira issue');
+    const key = requirePayloadString(row.key, 'issue key', 'jira issue');
+    const fields = requirePayloadObject(row.fields, `jira issue ${key} fields`);
+    const rendered = row.renderedFields && typeof row.renderedFields === 'object' && !Array.isArray(row.renderedFields)
+        ? row.renderedFields
+        : {};
+    const custom = configuredFieldNames();
+    const comments = inlineComments(fields, key, options);
+    const requireNestedCollections = options.requireNestedCollections !== false;
+    const attachments = requireNestedCollections
+        ? requirePayloadArray(fields.attachment, `jira issue ${key} attachment field`)
+        : [];
+    const issueLinks = requireNestedCollections
+        ? requirePayloadArray(fields.issuelinks, `jira issue ${key} issuelinks field`)
+        : [];
+    const normalized = {
+        key,
+        id: row.id != null ? String(row.id) : '',
+        url: `${config.baseUrl}/browse/${key}`,
+        summary: String(fields.summary ?? ''),
+        issueType: valueName(fields.issuetype) || undefined,
+        status: valueName(fields.status) || undefined,
+        priority: valueName(fields.priority) || undefined,
+        project: valueName(fields.project) || undefined,
+        reporter: displayUser(fields.reporter) || undefined,
+        assignee: displayUser(fields.assignee) || undefined,
+        labels: Array.isArray(fields.labels) ? fields.labels.map(String) : [],
+        description: {
+            raw: fields.description ?? null,
+            markdown: jiraBodyToMarkdown(fields.description, rendered.description),
+        },
+        comments: comments.map(normalizeComment),
+        attachments: attachments.map(normalizeAttachment),
+        linkedIssues: issueLinks.map(normalizeIssueLink),
+        fixVersions: valueNames(fields.fixVersions),
+        affectedVersions: valueNames(fields.versions),
+        components: valueNames(fields.components),
+        created: fields.created ? String(fields.created) : undefined,
+        updated: fields.updated ? String(fields.updated) : undefined,
+    };
+    if (custom.acceptanceCriteria && fields[custom.acceptanceCriteria] !== undefined) {
+        normalized.acceptanceCriteria = {
+            raw: fields[custom.acceptanceCriteria],
+            markdown: customValueToMarkdown(fields[custom.acceptanceCriteria]),
+        };
+    }
+    if (custom.sprint && fields[custom.sprint] !== undefined) {
+        normalized.sprint = customValueToMarkdown(fields[custom.sprint]);
+    }
+    if (custom.storyPoints && fields[custom.storyPoints] !== undefined) {
+        normalized.storyPoints = Number(fields[custom.storyPoints]);
+    }
+    return normalized;
+}
+
+export function issueSummaryRow(issue, config) {
+    const normalized = normalizeJiraIssue(issue, config, { comments: [], requireNestedCollections: false });
+    return {
+        key: normalized.key,
+        summary: normalized.summary,
+        issueType: normalized.issueType,
+        status: normalized.status,
+        priority: normalized.priority,
+        assignee: normalized.assignee,
+        updated: normalized.updated,
+        url: normalized.url,
+    };
+}
+
+export async function fetchIssue(config, key, extraFields = []) {
+    const issue = await jiraRequest(config, `/issue/${encodeURIComponent(key)}`, {
+        params: {
+            fields: issueFields(extraFields),
+            expand: 'renderedFields',
+        },
+        label: `jira issue ${key}`,
+    });
+    return requirePayloadObject(issue, `jira issue ${key}`);
+}
+
+export async function fetchComments(config, key, limit = 100) {
+    const maxResults = parseJiraLimit(limit, 100, 100);
+    const data = await jiraRequest(config, `/issue/${encodeURIComponent(key)}/comment`, {
+        params: { startAt: 0, maxResults, expand: 'renderedBody' },
+        label: `jira comments ${key}`,
+    });
+    const payload = requirePayloadObject(data, `jira comments ${key}`);
+    return requirePayloadArray(payload.comments, `jira comments ${key}`);
+}
+
+export function jiraRowsOrEmpty(rows, label, hint) {
+    return requireNonEmptyRows(rows, label, hint);
+}
+
+export function jiraConfig() {
+    return getJiraConfig();
+}
+
+export const __test__ = {
+    configuredFieldNames,
+    fetchIssue,
+    issueSummaryRow,
+    jiraApiPath,
+    jiraBodyToMarkdown,
+    normalizeAttachment,
+    normalizeComment,
+    normalizeIssueLink,
+    normalizeJiraIssue,
+    requireIssueKey,
+};

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);
+  });
+});