publishport-opencli 1.8.4-pp.1

package/clis/imdb/utils.test.js

@@ -0,0 +1,88 @@
+import { describe, expect, it, vi } from 'vitest';
+import { extractJsonLd, forceEnglishUrl, formatDuration, getCurrentImdbId, isChallengePage, normalizeImdbTitleType, normalizeImdbId, waitForImdbPath, waitForImdbReviewsReady, waitForImdbSearchReady, } from './utils.js';
+describe('normalizeImdbId', () => {
+    it('passes through bare ids', () => {
+        expect(normalizeImdbId('tt1375666', 'tt')).toBe('tt1375666');
+        expect(normalizeImdbId('nm0634240', 'nm')).toBe('nm0634240');
+    });
+    it('extracts ids from supported urls', () => {
+        expect(normalizeImdbId('https://www.imdb.com/title/tt1375666/', 'tt')).toBe('tt1375666');
+        expect(normalizeImdbId('https://m.imdb.com/title/tt1375666/', 'tt')).toBe('tt1375666');
+        expect(normalizeImdbId('https://www.imdb.com/de/title/tt1375666/?ref_=nv_sr_srsg_0', 'tt')).toBe('tt1375666');
+        expect(normalizeImdbId('https://www.imdb.com/name/nm0634240/', 'nm')).toBe('nm0634240');
+    });
+    it('throws on invalid or mismatched ids', () => {
+        expect(() => normalizeImdbId('invalid', 'tt')).toThrow('Invalid IMDb ID');
+        expect(() => normalizeImdbId('tt1', 'tt')).toThrow('Invalid IMDb ID');
+        expect(() => normalizeImdbId('nm0634240', 'tt')).toThrow('Invalid IMDb ID');
+    });
+});
+describe('formatDuration', () => {
+    it('converts ISO-8601 durations to a short human format', () => {
+        expect(formatDuration('PT2H28M')).toBe('2h 28m');
+        expect(formatDuration('PT1H')).toBe('1h');
+        expect(formatDuration('PT45M')).toBe('45m');
+        expect(formatDuration('PT2H')).toBe('2h');
+    });
+    it('returns an empty string for invalid input', () => {
+        expect(formatDuration('')).toBe('');
+        expect(formatDuration('invalid')).toBe('');
+    });
+});
+describe('forceEnglishUrl', () => {
+    it('adds the English language parameter', () => {
+        expect(forceEnglishUrl('https://www.imdb.com/title/tt1375666/')).toContain('language=en-US');
+    });
+    it('preserves existing query parameters', () => {
+        const result = forceEnglishUrl('https://www.imdb.com/title/tt1375666/?ref_=nv');
+        expect(result).toContain('language=en-US');
+        expect(result).toContain('ref_=nv');
+    });
+});
+describe('normalizeImdbTitleType', () => {
+    it('maps internal imdb ids to readable labels', () => {
+        expect(normalizeImdbTitleType({ id: 'movie', text: '' })).toBe('Movie');
+        expect(normalizeImdbTitleType({ id: 'tvSeries', text: '' })).toBe('TV Series');
+        expect(normalizeImdbTitleType('short')).toBe('Short');
+    });
+    it('preserves explicit text labels', () => {
+        expect(normalizeImdbTitleType({ id: 'movie', text: 'Feature Film' })).toBe('Feature Film');
+    });
+});
+describe('extractJsonLd', () => {
+    it('returns the evaluated JSON-LD payload', async () => {
+        const page = {
+            evaluate: vi.fn().mockResolvedValue({ '@type': 'Movie', name: 'Inception' }),
+        };
+        await expect(extractJsonLd(page, 'Movie')).resolves.toEqual({ '@type': 'Movie', name: 'Inception' });
+        expect(page.evaluate).toHaveBeenCalledTimes(1);
+        expect(page.evaluate).toHaveBeenCalledWith(expect.stringContaining('"Movie"'));
+    });
+});
+describe('isChallengePage', () => {
+    it('returns true when the page evaluation matches a challenge', async () => {
+        const page = {
+            evaluate: vi.fn().mockResolvedValue(true),
+        };
+        await expect(isChallengePage(page)).resolves.toBe(true);
+        expect(page.evaluate).toHaveBeenCalledTimes(1);
+    });
+});
+describe('imdb browser helpers', () => {
+    it('reads the current imdb id from page metadata', async () => {
+        const page = {
+            evaluate: vi.fn().mockResolvedValue('nm0634240'),
+        };
+        await expect(getCurrentImdbId(page, 'nm')).resolves.toBe('nm0634240');
+        expect(page.evaluate).toHaveBeenCalledTimes(1);
+    });
+    it('wait helpers resolve mocked readiness booleans', async () => {
+        const page = {
+            evaluate: vi.fn().mockResolvedValue(true),
+        };
+        await expect(waitForImdbPath(page, '^/find/?$')).resolves.toBe(true);
+        await expect(waitForImdbSearchReady(page)).resolves.toBe(true);
+        await expect(waitForImdbReviewsReady(page)).resolves.toBe(true);
+        expect(page.evaluate).toHaveBeenCalledTimes(3);
+    });
+});

package/clis/indeed/indeed.test.js

@@ -0,0 +1,375 @@
+import { describe, expect, it, vi } from 'vitest';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { getRegistry } from '@jackwener/opencli/registry';
+import {
+    INDEED_ORIGIN,
+    SEARCH_COLUMNS,
+    JOB_COLUMNS,
+    coerceInt,
+    requireBoundedInt,
+    requireNonNegativeInt,
+    requireJobKey,
+    requireQuery,
+    requireFromage,
+    requireSort,
+    buildSearchUrl,
+    buildJobUrl,
+    dedupeTags,
+    searchCardToRow,
+} from './utils.js';
+import './search.js';
+import './job.js';
+
+function createPageMock(evaluateResult) {
+    const evaluate = typeof evaluateResult === 'function'
+        ? vi.fn(evaluateResult)
+        : vi.fn().mockResolvedValue(evaluateResult);
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        wait: vi.fn().mockResolvedValue(undefined),
+        evaluate,
+    };
+}
+
+describe('indeed adapter — registration', () => {
+    it('registers search and job commands with the expected shape', () => {
+        const search = getRegistry().get('indeed/search');
+        const job = getRegistry().get('indeed/job');
+
+        expect(search).toBeDefined();
+        expect(search.browser).toBe(true);
+        expect(search.strategy).toBe('cookie');
+        expect(search.navigateBefore).toBe(false);
+        expect(search.columns).toEqual(SEARCH_COLUMNS);
+
+        expect(job).toBeDefined();
+        expect(job.browser).toBe(true);
+        expect(job.strategy).toBe('cookie');
+        expect(job.navigateBefore).toBe(false);
+        expect(job.columns).toEqual(JOB_COLUMNS);
+        expect(job.aliases).toContain('detail');
+        expect(job.aliases).toContain('view');
+    });
+
+    it('declares no overlap between search and job columns shape', () => {
+        expect(SEARCH_COLUMNS).toContain('rank');
+        expect(SEARCH_COLUMNS).toContain('id');
+        expect(SEARCH_COLUMNS).toContain('url');
+        expect(JOB_COLUMNS).toContain('description');
+        expect(JOB_COLUMNS).not.toContain('rank');
+    });
+});
+
+describe('indeed adapter — coerceInt', () => {
+    it('accepts integers and integer strings', () => {
+        expect(coerceInt(5)).toBe(5);
+        expect(coerceInt('5')).toBe(5);
+        expect(coerceInt(0)).toBe(0);
+    });
+    it('rejects floats / non-numeric / empty / NaN', () => {
+        expect(coerceInt(1.5)).toBeNaN();
+        expect(coerceInt('1.5')).toBeNaN();
+        expect(coerceInt('abc')).toBeNaN();
+        expect(coerceInt('')).toBeNaN();
+        expect(coerceInt(null)).toBeNaN();
+        expect(coerceInt(undefined)).toBeNaN();
+    });
+});
+
+describe('indeed adapter — argument validators', () => {
+    it('requireBoundedInt enforces bounds', () => {
+        expect(requireBoundedInt(15, 15, 25, 'limit')).toBe(15);
+        expect(requireBoundedInt('20', 15, 25, 'limit')).toBe(20);
+        expect(() => requireBoundedInt(0, 15, 25, 'limit')).toThrow(/positive integer/);
+        expect(() => requireBoundedInt(-5, 15, 25, 'limit')).toThrow(/positive integer/);
+        expect(() => requireBoundedInt(30, 15, 25, 'limit')).toThrow(/<= 25/);
+        expect(() => requireBoundedInt('abc', 15, 25, 'limit')).toThrow(/positive integer/);
+        expect(() => requireBoundedInt(1.5, 15, 25, 'limit')).toThrow(/positive integer/);
+    });
+
+    it('requireNonNegativeInt allows zero', () => {
+        expect(requireNonNegativeInt(0, 0, 'start')).toBe(0);
+        expect(requireNonNegativeInt('20', 0, 'start')).toBe(20);
+        expect(() => requireNonNegativeInt(-1, 0, 'start')).toThrow(/non-negative/);
+        expect(() => requireNonNegativeInt('1.5', 0, 'start')).toThrow(/non-negative/);
+    });
+
+    it('requireJobKey validates the 16-char hex shape', () => {
+        expect(requireJobKey('dccc07ac5a6a3683')).toBe('dccc07ac5a6a3683');
+        expect(requireJobKey('DCCC07AC5A6A3683')).toBe('dccc07ac5a6a3683');
+        expect(requireJobKey('  abc123def4567890  ')).toBe('abc123def4567890');
+        expect(() => requireJobKey('')).toThrow(/required/);
+        expect(() => requireJobKey('   ')).toThrow(/required/);
+        expect(() => requireJobKey('not-hex')).toThrow(/valid jk/);
+        expect(() => requireJobKey('abc123')).toThrow(/valid jk/); // too short
+        expect(() => requireJobKey('xyz123def456789012')).toThrow(/valid jk/); // non-hex chars
+    });
+
+    it('requireQuery rejects empty / whitespace', () => {
+        expect(requireQuery('software engineer')).toBe('software engineer');
+        expect(requireQuery('  rust  ')).toBe('rust');
+        expect(() => requireQuery('')).toThrow(/cannot be empty/);
+        expect(() => requireQuery('   ')).toThrow(/cannot be empty/);
+        expect(() => requireQuery(null)).toThrow(/cannot be empty/);
+    });
+
+    it('requireFromage allows empty + whitelist values only', () => {
+        expect(requireFromage('')).toBe('');
+        expect(requireFromage(undefined)).toBe('');
+        expect(requireFromage('1')).toBe('1');
+        expect(requireFromage('14')).toBe('14');
+        expect(() => requireFromage('30')).toThrow(/1\/3\/7\/14/);
+        expect(() => requireFromage('abc')).toThrow(/1\/3\/7\/14/);
+    });
+
+    it('requireSort accepts only relevance/date', () => {
+        expect(requireSort('relevance')).toBe('relevance');
+        expect(requireSort('date')).toBe('date');
+        expect(requireSort('DATE')).toBe('date');
+        expect(requireSort(undefined)).toBe('relevance');
+        expect(() => requireSort('newest')).toThrow(/relevance.*date/);
+    });
+});
+
+describe('indeed adapter — URL builders', () => {
+    it('buildSearchUrl encodes query and omits empty params', () => {
+        const url = buildSearchUrl({ query: 'software engineer', location: '', fromage: '', sort: 'relevance', start: 0 });
+        expect(url).toBe(`${INDEED_ORIGIN}/jobs?q=software+engineer`);
+    });
+
+    it('buildSearchUrl includes location, fromage, sort=date, start when set', () => {
+        const url = buildSearchUrl({ query: 'rust', location: 'remote', fromage: '7', sort: 'date', start: 20 });
+        expect(url).toBe(`${INDEED_ORIGIN}/jobs?q=rust&l=remote&fromage=7&sort=date&start=20`);
+    });
+
+    it('buildSearchUrl omits sort when relevance (the default) and start when 0', () => {
+        const url = buildSearchUrl({ query: 'go', location: 'NY', fromage: '', sort: 'relevance', start: 0 });
+        expect(url).toBe(`${INDEED_ORIGIN}/jobs?q=go&l=NY`);
+    });
+
+    it('buildJobUrl points at /viewjob with the jk', () => {
+        expect(buildJobUrl('dccc07ac5a6a3683')).toBe(`${INDEED_ORIGIN}/viewjob?jk=dccc07ac5a6a3683`);
+    });
+});
+
+describe('indeed adapter — DOM normalizers', () => {
+    it('dedupeTags drops the salary duplicate and trims', () => {
+        const tags = ['$50 - $100 an hour', 'Contract', 'Hourly pay', 'Flexible schedule', 'Contract'];
+        expect(dedupeTags(tags, '$50 - $100 an hour')).toBe('Contract · Hourly pay · Flexible schedule');
+    });
+
+    it('dedupeTags handles empty / no-salary input', () => {
+        expect(dedupeTags([], '')).toBe('');
+        expect(dedupeTags(['', '  ', null, 'Full-time'], '')).toBe('Full-time');
+    });
+
+    it('searchCardToRow normalizes a fully populated card', () => {
+        const card = {
+            jk: 'a0021a1886f32d09',
+            title: '  Senior  Software   Engineer ',
+            company: 'Somos, Inc.',
+            location: 'Remote',
+            salary: '$150,000 - $179,000 a year',
+            tags: [
+                '$150,000 - $179,000 a year',
+                'Full-time',
+                '401(k)',
+            ],
+        };
+        const row = searchCardToRow(card, 1);
+        expect(row).toEqual({
+            rank: 1,
+            id: 'a0021a1886f32d09',
+            title: 'Senior Software Engineer',
+            company: 'Somos, Inc.',
+            location: 'Remote',
+            salary: '$150,000 - $179,000 a year',
+            tags: 'Full-time · 401(k)',
+            url: `${INDEED_ORIGIN}/viewjob?jk=a0021a1886f32d09`,
+        });
+    });
+
+    it('searchCardToRow drops url when jk is missing rather than emit a broken URL', () => {
+        const row = searchCardToRow({ title: 'X' }, 5);
+        expect(row.id).toBe('');
+        expect(row.url).toBe('');
+        expect(row.rank).toBe(5);
+    });
+});
+
+describe('indeed adapter — search runtime', () => {
+    it('fails fast on invalid limit before opening the page', async () => {
+        const page = createPageMock({ cards: [], challenge: false, ready: true });
+        const search = getRegistry().get('indeed/search');
+
+        await expect(search.func(page, { query: 'rust engineer', limit: 0 })).rejects.toBeInstanceOf(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+        expect(page.evaluate).not.toHaveBeenCalled();
+    });
+
+    it('maps a Cloudflare challenge page to CommandExecutionError', async () => {
+        const page = createPageMock({ cards: [], challenge: true, ready: true });
+        const search = getRegistry().get('indeed/search');
+
+        await expect(search.func(page, { query: 'rust engineer' })).rejects.toBeInstanceOf(CommandExecutionError);
+        expect(page.goto).toHaveBeenCalledWith(`${INDEED_ORIGIN}/jobs?q=rust+engineer`);
+        expect(page.wait).toHaveBeenCalledWith(4);
+        expect(page.evaluate).toHaveBeenCalledTimes(1);
+    });
+
+    it('treats poll timeout / selector drift as CommandExecutionError, not EmptyResultError', async () => {
+        const page = createPageMock({ cards: [], challenge: false, ready: false });
+        const search = getRegistry().get('indeed/search');
+
+        await expect(search.func(page, { query: 'rust engineer' })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('does not misclassify data-jk-only drift as EmptyResultError', async () => {
+        const page = createPageMock({ cards: [], challenge: false, ready: false });
+        const search = getRegistry().get('indeed/search');
+
+        await expect(search.func(page, { query: 'rust engineer' })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('maps an empty but ready page to EmptyResultError', async () => {
+        const page = createPageMock({ cards: [], challenge: false, ready: true });
+        const search = getRegistry().get('indeed/search');
+
+        await expect(search.func(page, { query: 'zzzxxyyqqnonexistent', location: 'Remote' })).rejects.toBeInstanceOf(EmptyResultError);
+    });
+
+    it('returns normalized rows for a happy-path search result', async () => {
+        const page = createPageMock({
+            cards: [{
+                jk: 'dccc07ac5a6a3683',
+                title: ' Senior  Rust Engineer ',
+                company: 'Acme',
+                location: 'Remote',
+                salary: '$180,000 a year',
+                tags: ['$180,000 a year', 'Full-time', '401(k)'],
+            }],
+            challenge: false,
+            ready: true,
+        });
+        const search = getRegistry().get('indeed/search');
+
+        const rows = await search.func(page, {
+            query: 'rust engineer',
+            location: 'Remote',
+            fromage: '7',
+            sort: 'date',
+            start: 10,
+            limit: 1,
+        });
+
+        expect(page.goto).toHaveBeenCalledWith(`${INDEED_ORIGIN}/jobs?q=rust+engineer&l=Remote&fromage=7&sort=date&start=10`);
+        expect(rows).toEqual([{
+            rank: 11,
+            id: 'dccc07ac5a6a3683',
+            title: 'Senior Rust Engineer',
+            company: 'Acme',
+            location: 'Remote',
+            salary: '$180,000 a year',
+            tags: 'Full-time · 401(k)',
+            url: `${INDEED_ORIGIN}/viewjob?jk=dccc07ac5a6a3683`,
+        }]);
+    });
+});
+
+describe('indeed adapter — job runtime', () => {
+    it('fails fast on invalid jk before browser/network work', async () => {
+        const page = createPageMock({
+            ready: true,
+            challenge: false,
+            notFound: false,
+            title: 'Demo',
+            description: 'Demo',
+        });
+        const job = getRegistry().get('indeed/job');
+
+        await expect(job.func(page, { id: 'not-hex' })).rejects.toBeInstanceOf(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+        expect(page.evaluate).not.toHaveBeenCalled();
+    });
+
+    it('maps a Cloudflare challenge page to CommandExecutionError', async () => {
+        const page = createPageMock({
+            ready: true,
+            challenge: true,
+            notFound: false,
+            title: '',
+            company: '',
+            location: '',
+            salary: '',
+            jobType: '',
+            description: '',
+        });
+        const job = getRegistry().get('indeed/job');
+
+        await expect(job.func(page, { id: 'dccc07ac5a6a3683' })).rejects.toBeInstanceOf(CommandExecutionError);
+        expect(page.goto).toHaveBeenCalledWith(`${INDEED_ORIGIN}/viewjob?jk=dccc07ac5a6a3683`);
+        expect(page.wait).toHaveBeenCalledWith(4);
+    });
+
+    it('treats missing ready markers as CommandExecutionError, not EmptyResultError', async () => {
+        const page = createPageMock({
+            ready: false,
+            challenge: false,
+            notFound: false,
+            title: '',
+            company: '',
+            location: '',
+            salary: '',
+            jobType: '',
+            description: '',
+        });
+        const job = getRegistry().get('indeed/job');
+
+        await expect(job.func(page, { id: 'dccc07ac5a6a3683' })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('maps a not-found page to EmptyResultError', async () => {
+        const page = createPageMock({
+            ready: true,
+            challenge: false,
+            notFound: true,
+            title: '',
+            company: '',
+            location: '',
+            salary: '',
+            jobType: '',
+            description: '',
+        });
+        const job = getRegistry().get('indeed/job');
+
+        await expect(job.func(page, { id: 'dccc07ac5a6a3683' })).rejects.toBeInstanceOf(EmptyResultError);
+    });
+
+    it('returns the normalized job detail row on success', async () => {
+        const page = createPageMock({
+            ready: true,
+            challenge: false,
+            notFound: false,
+            title: ' Senior Rust Engineer ',
+            company: 'Acme',
+            location: 'Remote',
+            salary: '$180,000 a year',
+            jobType: 'Full-time',
+            description: 'Build systems',
+        });
+        const job = getRegistry().get('indeed/job');
+
+        const rows = await job.func(page, { id: 'DCCC07AC5A6A3683' });
+
+        expect(rows).toEqual([{
+            id: 'dccc07ac5a6a3683',
+            title: 'Senior Rust Engineer',
+            company: 'Acme',
+            location: 'Remote',
+            salary: '$180,000 a year',
+            job_type: 'Full-time',
+            description: 'Build systems',
+            url: `${INDEED_ORIGIN}/viewjob?jk=dccc07ac5a6a3683`,
+        }]);
+    });
+});

package/clis/indeed/job.js

@@ -0,0 +1,86 @@
+/**
+ * Indeed job detail.
+ *
+ * Reads the full job posting (title, company, location, salary, job type,
+ * description) for a given `jk` (job key, the 16-char id surfaced by
+ * `indeed search`). Browser-driven for the same Cloudflare reason as
+ * `search`.
+ */
+
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError, CommandExecutionError } from '@jackwener/opencli/errors';
+import {
+    JOB_COLUMNS,
+    requireJobKey,
+    buildJobUrl,
+} from './utils.js';
+
+cli({
+    site: 'indeed',
+    name: 'job',
+    aliases: ['detail', 'view'],
+    access: 'read',
+    description: 'Read the full Indeed job posting by jk (job key)',
+    domain: 'www.indeed.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'id', positional: true, required: true, help: 'Job key (16-char hex from `indeed search`, e.g. "dccc07ac5a6a3683")' },
+    ],
+    columns: JOB_COLUMNS,
+    func: async (page, kwargs) => {
+        const jk = requireJobKey(kwargs.id);
+        const url = buildJobUrl(jk);
+        await page.goto(url);
+        await page.wait(4);
+
+        let detail;
+        try {
+            detail = await page.evaluate(`(async () => {
+                let ready = !!document.querySelector('#jobDescriptionText, h1, [data-testid="error-page"]');
+                for (let i = 0; i < 30; i++) {
+                    if (ready) break;
+                    await new Promise(r => setTimeout(r, 500));
+                    ready = !!document.querySelector('#jobDescriptionText, h1, [data-testid="error-page"]');
+                }
+                const challenge = (document.title || '').includes('Just a moment') || !!document.querySelector('[id^="cf-"]');
+                const notFound = !!document.querySelector('[data-testid="error-page"]') || /Page Not Found|not found/i.test(document.querySelector('h1')?.textContent || '');
+                const title = document.querySelector('h1')?.textContent?.trim() ?? '';
+                const company = document.querySelector('[data-testid="inlineHeader-companyName"] a, [data-testid="inlineHeader-companyName"], [data-company-name="true"]')?.textContent?.trim() ?? '';
+                const location = document.querySelector('[data-testid="jobsearch-JobInfoHeader-companyLocation"] div, [data-testid="inlineHeader-companyLocation"]')?.textContent?.trim() ?? '';
+                const salary = document.querySelector('[id*="salaryInfoAndJobType"] span, [data-testid="job-salary"]')?.textContent?.trim() ?? '';
+                const jobType = Array.from(document.querySelectorAll('[id*="salaryInfoAndJobType"] span, [data-testid="job-type"]'))
+                    .map(s => (s.textContent || '').trim())
+                    .filter(t => t && t !== salary)
+                    .join(', ');
+                const description = document.querySelector('#jobDescriptionText')?.innerText?.trim() ?? '';
+                return { ready, challenge, notFound, title, company, location, salary, jobType, description };
+            })()`);
+        }
+        catch (e) {
+            throw new CommandExecutionError(`Failed to scrape Indeed job detail DOM: ${e?.message ?? e}`, 'The page may not have fully loaded; try again.');
+        }
+
+        if (detail?.challenge) {
+            throw new CommandExecutionError('Indeed served a Cloudflare challenge page', 'Open https://www.indeed.com in the connected browser and clear the challenge, then retry.');
+        }
+        if (!detail?.ready) {
+            throw new CommandExecutionError('Indeed job page did not expose detail or error markers within 15s', 'Indeed may still be loading or the DOM shape may have changed; retry after opening Indeed in the connected browser.');
+        }
+        if (detail?.notFound || (!detail?.title && !detail?.description)) {
+            throw new EmptyResultError('indeed job', `No Indeed job posting found for jk "${jk}"`);
+        }
+
+        return [{
+            id: jk,
+            title: detail.title.replace(/\s+/g, ' ').trim(),
+            company: detail.company.replace(/\s+/g, ' ').trim(),
+            location: detail.location.replace(/\s+/g, ' ').trim(),
+            salary: detail.salary.replace(/\s+/g, ' ').trim(),
+            job_type: detail.jobType.replace(/\s+/g, ' ').trim(),
+            description: detail.description,
+            url,
+        }];
+    },
+});

package/clis/indeed/search.js

@@ -0,0 +1,110 @@
+/**
+ * Indeed keyword search.
+ *
+ * Drives the public `/jobs?q=&l=` listing page through a real browser
+ * because Cloudflare returns 403 to bare fetches. Extraction happens
+ * inside `page.evaluate` against the rendered DOM (Indeed's JSON-island
+ * is heavily obfuscated and changes shape per A/B bucket).
+ */
+
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError, CommandExecutionError } from '@jackwener/opencli/errors';
+import {
+    SEARCH_COLUMNS,
+    requireQuery,
+    requireBoundedInt,
+    requireNonNegativeInt,
+    requireFromage,
+    requireSort,
+    buildSearchUrl,
+    searchCardToRow,
+} from './utils.js';
+
+cli({
+    site: 'indeed',
+    name: 'search',
+    access: 'read',
+    description: 'Indeed keyword job search (rendered DOM via browser session, US site)',
+    domain: 'www.indeed.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'query', positional: true, required: true, help: 'Job keyword (title / skill / company)' },
+        { name: 'location', type: 'string', default: '', help: 'Location filter (e.g. "remote", "New York, NY", "San Francisco")' },
+        { name: 'fromage', type: 'string', default: '', help: 'Recency filter, days back: 1 / 3 / 7 / 14' },
+        { name: 'sort', type: 'string', default: 'relevance', help: 'Sort order: relevance | date' },
+        { name: 'start', type: 'int', default: 0, help: 'Pagination offset (multiple of 10, 0-based)' },
+        { name: 'limit', type: 'int', default: 15, help: 'Max rows to return (1-25, capped at one page)' },
+    ],
+    columns: SEARCH_COLUMNS,
+    func: async (page, kwargs) => {
+        const query = requireQuery(kwargs.query);
+        const location = String(kwargs.location ?? '').trim();
+        const fromage = requireFromage(kwargs.fromage);
+        const sort = requireSort(kwargs.sort);
+        const start = requireNonNegativeInt(kwargs.start, 0, 'start');
+        const limit = requireBoundedInt(kwargs.limit, 15, 25, 'limit');
+
+        const url = buildSearchUrl({ query, location, fromage, sort, start });
+        await page.goto(url);
+        await page.wait(4);
+
+        let cards;
+        try {
+            cards = await page.evaluate(`(async () => {
+                const hasResults = () => !!document.querySelector('.job_seen_beacon');
+                const hasEmptyState = () => {
+                    const text = document.body?.innerText || '';
+                    return !!document.querySelector('[data-testid="searchCountPages"], [data-testid="searchCount"], [data-testid="noResultsMessage"], [data-testid="empty-serp-result"]')
+                        || /did not match any jobs|no jobs found|0 jobs/i.test(text);
+                };
+                let ready = hasResults() || hasEmptyState();
+                for (let i = 0; i < 30; i++) {
+                    if (ready) break;
+                    await new Promise(r => setTimeout(r, 500));
+                    ready = hasResults() || hasEmptyState();
+                }
+                const blocks = document.querySelectorAll('.job_seen_beacon');
+                const seen = new Set();
+                const out = [];
+                for (const b of blocks) {
+                    const titleA = b.querySelector('h2.jobTitle a, [class*="jcs-JobTitle"]');
+                    const jk = titleA?.getAttribute('data-jk');
+                    if (!jk || seen.has(jk)) continue;
+                    seen.add(jk);
+                    const tags = Array.from(b.querySelectorAll('.metadataContainer li span'))
+                        .map(s => (s.textContent || '').trim())
+                        .filter(Boolean);
+                    out.push({
+                        jk,
+                        title: b.querySelector('h2.jobTitle span')?.textContent?.trim() ?? '',
+                        company: b.querySelector('[data-testid="company-name"]')?.textContent?.trim() ?? '',
+                        location: b.querySelector('[data-testid="text-location"]')?.textContent?.trim() ?? '',
+                        salary: b.querySelector('.salary-snippet-container span')?.textContent?.trim() ?? '',
+                        tags,
+                    });
+                }
+                const blockedHeadline = document.title || '';
+                const challenge = blockedHeadline.includes('Just a moment') || !!document.querySelector('[id^="cf-"]');
+                return { cards: out, challenge, ready };
+            })()`);
+        }
+        catch (e) {
+            throw new CommandExecutionError(`Failed to scrape Indeed search DOM: ${e?.message ?? e}`, 'The page may not have fully loaded; try again.');
+        }
+
+        if (cards?.challenge) {
+            throw new CommandExecutionError('Indeed served a Cloudflare challenge page', 'Open https://www.indeed.com in the connected browser and clear the challenge, then retry.');
+        }
+        if (!cards?.ready) {
+            throw new CommandExecutionError('Indeed search page did not expose result or empty-state markers within 15s', 'Indeed may still be loading or the DOM shape may have changed; retry after opening Indeed in the connected browser.');
+        }
+
+        const list = Array.isArray(cards?.cards) ? cards.cards : [];
+        if (list.length === 0) {
+            throw new EmptyResultError('indeed search', `No Indeed jobs matched "${query}"${location ? ` in ${location}` : ''}`);
+        }
+        return list.slice(0, limit).map((c, i) => searchCardToRow(c, start + i + 1));
+    },
+});