@sovovs/bycli 1.8.0 → 2.0.0

package/clis/linkedin/salesnav-thread.test.js

@@ -1,79 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { ArgumentError, CommandExecutionError } from '@sovovs/bycli/errors';
-import './salesnav-thread.js';
-
-const {
-  parseThreadInput,
-  threadApiUrl,
-  parseSalesnavThreadMessages,
-  threadMatchesInput,
-  salesnavThreadUrl,
-} = await import('./salesnav-thread.js').then((m) => m.__test__);
-
-describe('linkedin salesnav-thread command', () => {
-  it('accepts Sales Navigator inbox URLs, raw thread ids, lead URLs, urns, and names', () => {
-    expect(parseThreadInput('https://www.linkedin.com/sales/inbox/2-abc%3D%3D')).toEqual(['thread_id', '2-abc==']);
-    expect(parseThreadInput('2-abc==')).toEqual(['thread_id', '2-abc==']);
-    expect(parseThreadInput('https://www.linkedin.com/sales/lead/P1,NAME_SEARCH,T1')).toEqual(['recipient_urn', 'urn:li:fs_salesProfile:(P1,NAME_SEARCH,T1)']);
-    expect(parseThreadInput('urn:li:fs_salesProfile:(P1,NAME_SEARCH,T1)')).toEqual(['recipient_urn', 'urn:li:fs_salesProfile:(P1,NAME_SEARCH,T1)']);
-    expect(parseThreadInput('Rachael Stolberg')).toEqual(['name', 'rachael stolberg']);
-    expect(() => parseThreadInput('urn:li:fs_salesProfile:(P1,undefined,T1)')).toThrow(ArgumentError);
-    expect(() => parseThreadInput('https://www.linkedin.com/sales/lead/P1,undefined,T1')).toThrow(ArgumentError);
-  });
-
-  it('builds the decorated thread API URL with encoded parentheses and message pagination size', () => {
-    const url = threadApiUrl('2-thread==', 40);
-    expect(url).toContain('/sales-api/salesApiMessagingThreads/2-thread%3D%3D?');
-    expect(url).toContain('messageCount=40');
-    expect(url).toContain('count=1');
-    expect(url).toContain('decoration=%28');
-    expect(url).not.toContain('decoration=(');
-  });
-
-  it('parses thread messages in chronological order with sender names and timestamps', () => {
-    const rows = parseSalesnavThreadMessages({
-      id: '2-thread',
-      participants: [
-        'urn:li:fs_salesProfile:(OTHER,NAME_SEARCH,T1)',
-        'urn:li:fs_salesProfile:(SELF,NAME_SEARCH,T2)',
-      ],
-      participantsResolutionResults: {
-        'urn:li:fs_salesProfile:(OTHER,NAME_SEARCH,T1)': { fullName: 'Rachael Stolberg', entityUrn: 'urn:li:fs_salesProfile:(OTHER,NAME_SEARCH,T1)' },
-        'urn:li:fs_salesProfile:(SELF,NAME_SEARCH,T2)': { fullName: 'Hanzi Li', entityUrn: 'urn:li:fs_salesProfile:(SELF,NAME_SEARCH,T2)' },
-      },
-      messages: [
-        { id: 'm2', author: 'urn:li:fs_salesProfile:(OTHER,NAME_SEARCH,T1)', body: 'Happy to chat', deliveredAt: 1778206803669, type: 'MEMBER_TO_MEMBER' },
-        { id: 'm1', author: 'urn:li:fs_salesProfile:(SELF,NAME_SEARCH,T2)', subject: 'Quick question', body: 'Hi Rachael', deliveredAt: 1777188013523, type: 'INMAIL' },
-      ],
-    });
-    expect(rows).toHaveLength(2);
-    expect(rows[0]).toMatchObject({
-      index: 0,
-      message_id: 'm1',
-      thread_id: '2-thread',
-      sender: 'Hanzi Li',
-      subject: 'Quick question',
-      text: 'Hi Rachael',
-      timestamp: '2026-04-26T07:20:13.523Z',
-    });
-    expect(rows[1]).toMatchObject({ index: 1, message_id: 'm2', sender: 'Rachael Stolberg', text: 'Happy to chat' });
-  });
-
-  it('fails typed on malformed thread message payloads', () => {
-    expect(() => parseSalesnavThreadMessages({ messages: [] })).toThrow(CommandExecutionError);
-    expect(() => parseSalesnavThreadMessages({ id: '2-thread' })).toThrow(CommandExecutionError);
-    expect(() => parseSalesnavThreadMessages({ id: '2-thread', messages: [null] })).toThrow(CommandExecutionError);
-  });
-
-  it('matches recipient identifiers against inbox rows', () => {
-    const row = {
-      thread_id: '2-thread',
-      person_name: 'Rachael Stolberg',
-      participants: [{ name: 'Rachael Stolberg', entity_urn: 'urn:li:fs_salesProfile:(P1,NAME_SEARCH,T1)' }],
-    };
-    expect(threadMatchesInput(row, ['thread_id', '2-thread'])).toBe(true);
-    expect(threadMatchesInput(row, ['recipient_urn', 'urn:li:fs_salesProfile:(P1,NAME_SEARCH,T1)'])).toBe(true);
-    expect(threadMatchesInput(row, ['name', 'rachael stolberg'])).toBe(true);
-    expect(salesnavThreadUrl('2-thread')).toBe('https://www.linkedin.com/sales/inbox/2-thread');
-  });
-});

package/clis/linkedin/search.test.js

@@ -1,222 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import { ArgumentError, AuthRequiredError } from '@sovovs/bycli/errors';
-import { __test__ } from './search.js';
-
-const {
-    parseCsvArg,
-    parseIntegerArg,
-    mapFilterValues,
-    decodeLinkedinRedirect,
-    looksLinkedInAuthWallText,
-    enrichJobDetails,
-    EXPERIENCE_LEVELS,
-    JOB_TYPES,
-    DATE_POSTED,
-    REMOTE_TYPES,
-} = __test__;
-
-const getSearchCommand = () => getRegistry().get('linkedin/search');
-
-describe('linkedin parseCsvArg', () => {
-    it('returns empty array for empty / null / undefined', () => {
-        expect(parseCsvArg(undefined)).toEqual([]);
-        expect(parseCsvArg(null)).toEqual([]);
-        expect(parseCsvArg('')).toEqual([]);
-    });
-
-    it('splits and trims comma-separated values', () => {
-        expect(parseCsvArg('full-time, contract')).toEqual(['full-time', 'contract']);
-        expect(parseCsvArg(' a , b , , c ')).toEqual(['a', 'b', 'c']);
-    });
-});
-
-describe('linkedin mapFilterValues', () => {
-    it('maps known values to upstream codes and dedupes', () => {
-        expect(mapFilterValues('full-time, contract, full', JOB_TYPES, 'job_type')).toEqual(['F', 'C']);
-        expect(mapFilterValues('remote, hybrid', REMOTE_TYPES, 'remote')).toEqual(['2', '3']);
-    });
-
-    it('throws ArgumentError on unknown filter values (no silent drop)', () => {
-        expect(() => mapFilterValues('martian', JOB_TYPES, 'job_type')).toThrow(ArgumentError);
-        expect(() => mapFilterValues('full-time, ufo', JOB_TYPES, 'job_type')).toThrow(ArgumentError);
-    });
-
-    it('returns empty array for empty input', () => {
-        expect(mapFilterValues('', EXPERIENCE_LEVELS, 'experience_level')).toEqual([]);
-        expect(mapFilterValues(undefined, DATE_POSTED, 'date_posted')).toEqual([]);
-    });
-});
-
-describe('linkedin argument validation', () => {
-    it('rejects --limit outside 1..100 instead of silently clamping', () => {
-        expect(() => parseIntegerArg(0, '--limit', 10, 1, 100)).toThrow(ArgumentError);
-        expect(() => parseIntegerArg(101, '--limit', 10, 1, 100)).toThrow(ArgumentError);
-        expect(() => parseIntegerArg('10.5', '--limit', 10, 1, 100)).toThrow(ArgumentError);
-    });
-
-    it('rejects negative --start instead of silently clamping to zero', () => {
-        expect(() => parseIntegerArg(-1, '--start', 0, 0)).toThrow(ArgumentError);
-        expect(parseIntegerArg(undefined, '--start', 0, 0)).toBe(0);
-        expect(parseIntegerArg('25', '--start', 0, 0)).toBe(25);
-    });
-
-    it('validates command args before browser navigation', async () => {
-        const command = getSearchCommand();
-        const page = { goto: vi.fn(), wait: vi.fn(), evaluate: vi.fn() };
-
-        await expect(command.func(page, { query: 'engineer', limit: 0 })).rejects.toBeInstanceOf(ArgumentError);
-        await expect(command.func(page, { query: 'engineer', start: -1 })).rejects.toBeInstanceOf(ArgumentError);
-        expect(page.goto).not.toHaveBeenCalled();
-    });
-});
-
-describe('linkedin auth wall detection', () => {
-    it('recognizes login/authwall signals', () => {
-        expect(looksLinkedInAuthWallText('https://www.linkedin.com/authwall?trk=guest Sign in to continue')).toBe(true);
-        expect(looksLinkedInAuthWallText('LinkedIn Login, Sign in')).toBe(true);
-        expect(looksLinkedInAuthWallText('About the job Senior infrastructure engineer')).toBe(false);
-    });
-
-    it('throws AuthRequiredError when search lands on a login wall', async () => {
-        const command = getSearchCommand();
-        const page = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            wait: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn().mockResolvedValue(true),
-        };
-
-        await expect(command.func(page, { query: 'engineer', limit: 5 })).rejects.toBeInstanceOf(AuthRequiredError);
-    });
-});
-
-describe('linkedin decodeLinkedinRedirect', () => {
-    it('extracts the underlying url from a /redir/redirect/ wrapper', () => {
-        const target = 'https://example.com/jobs/apply?id=42';
-        const wrapped = `https://www.linkedin.com/redir/redirect/?url=${encodeURIComponent(target)}&source=jobs`;
-        expect(decodeLinkedinRedirect(wrapped)).toBe(target);
-    });
-
-    it('returns the input unchanged for non-redirect urls', () => {
-        const direct = 'https://example.com/jobs/42/';
-        expect(decodeLinkedinRedirect(direct)).toBe(direct);
-    });
-
-    it('returns empty string for falsy input', () => {
-        expect(decodeLinkedinRedirect('')).toBe('');
-        expect(decodeLinkedinRedirect(null)).toBe('');
-    });
-});
-
-describe('linkedin enrichJobDetails (silent failure fix)', () => {
-    function makeFakePage({ evaluateResults = [], gotoFails = [], evaluateFails = [] } = {}) {
-        let evalCall = 0;
-        let gotoCall = 0;
-        return {
-            goto: vi.fn(async () => {
-                if (gotoFails[gotoCall++]) {
-                    throw new Error(gotoFails[gotoCall - 1]);
-                }
-            }),
-            wait: vi.fn(async () => undefined),
-            evaluate: vi.fn(async () => {
-                const idx = evalCall++;
-                if (evaluateFails[idx]) throw new Error(evaluateFails[idx]);
-                return evaluateResults[idx];
-            }),
-        };
-    }
-
-    it('surfaces detail_error="no url" when row has no URL (instead of silent empty string)', async () => {
-        const page = makeFakePage();
-        const out = await enrichJobDetails(page, [
-            { rank: 1, title: 'No URL Job', company: 'X', url: '' },
-        ]);
-        expect(out).toHaveLength(1);
-        expect(out[0]).toMatchObject({
-            description: null,
-            apply_url: null,
-            detail_error: 'no url',
-        });
-        expect(page.goto).not.toHaveBeenCalled();
-    });
-
-    it('surfaces detail_error="fetch failed: ..." when goto throws (no silent swallow)', async () => {
-        const page = makeFakePage({ gotoFails: ['network down'] });
-        const out = await enrichJobDetails(page, [
-            { rank: 1, title: 'Fetch Fail', company: 'X', url: 'https://www.linkedin.com/jobs/view/1' },
-        ]);
-        expect(out).toHaveLength(1);
-        expect(out[0].description).toBeNull();
-        expect(out[0].apply_url).toBeNull();
-        expect(out[0].detail_error).toMatch(/^fetch failed: .*network down/);
-    });
-
-    it('surfaces detail_error="missing description" on empty description (signals upstream gap, not crash)', async () => {
-        const page = makeFakePage({
-            evaluateResults: [
-                false, // auth wall probe
-                undefined, // expand-show-more click result (ignored)
-                { description: '', applyUrl: '' },
-            ],
-        });
-        const out = await enrichJobDetails(page, [
-            { rank: 1, title: 'Empty Desc', company: 'X', url: 'https://www.linkedin.com/jobs/view/2' },
-        ]);
-        expect(out[0].description).toBeNull();
-        expect(out[0].apply_url).toBeNull();
-        expect(out[0].detail_error).toBe('missing description');
-    });
-
-    it('surfaces detail_error=null on a fully successful enrichment', async () => {
-        const page = makeFakePage({
-            evaluateResults: [
-                false, // auth wall probe
-                undefined,
-                { description: '  An interesting role  ', applyUrl: 'https://example.com/apply' },
-            ],
-        });
-        const out = await enrichJobDetails(page, [
-            { rank: 1, title: 'OK', company: 'X', url: 'https://www.linkedin.com/jobs/view/3' },
-        ]);
-        expect(out[0]).toMatchObject({
-            description: 'An interesting role',
-            apply_url: 'https://example.com/apply',
-            detail_error: null,
-        });
-    });
-
-    it('processes multiple rows with mixed outcomes without aborting the batch', async () => {
-        const page = makeFakePage({
-            evaluateResults: [
-                // Row 1 (success)
-                false,
-                undefined,
-                { description: 'Good', applyUrl: 'https://a.example/' },
-                // Row 3 (success — row 2 had no URL so didn't navigate)
-                false,
-                undefined,
-                { description: 'Also good', applyUrl: 'https://b.example/' },
-            ],
-        });
-        const out = await enrichJobDetails(page, [
-            { rank: 1, title: 'A', company: 'X', url: 'https://www.linkedin.com/jobs/view/10' },
-            { rank: 2, title: 'B', company: 'X', url: '' },
-            { rank: 3, title: 'C', company: 'X', url: 'https://www.linkedin.com/jobs/view/30' },
-        ]);
-        expect(out).toHaveLength(3);
-        expect(out[0].detail_error).toBeNull();
-        expect(out[1].detail_error).toBe('no url');
-        expect(out[2].detail_error).toBeNull();
-        // Goto was only called for rows with URL (1 and 3)
-        expect(page.goto).toHaveBeenCalledTimes(2);
-    });
-
-    it('throws AuthRequiredError on detail auth wall instead of burying it in detail_error', async () => {
-        const page = makeFakePage({ evaluateResults: [true] });
-
-        await expect(enrichJobDetails(page, [
-            { rank: 1, title: 'Needs Auth', company: 'X', url: 'https://www.linkedin.com/jobs/view/4' },
-        ])).rejects.toBeInstanceOf(AuthRequiredError);
-    });
-});

package/clis/linkedin/sent-invitations.test.js

@@ -1,62 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { JSDOM } from 'jsdom';
-import { getRegistry } from '@sovovs/bycli/registry';
-import './sent-invitations.js';
-
-const { buildSentInvitationsScript } = await import('./sent-invitations.js').then((m) => m.__test__);
-
-describe('linkedin sent-invitations command', () => {
-  it('registers with structured columns that do not include raw blobs', () => {
-    const command = getRegistry().get('linkedin/sent-invitations');
-    expect(command).toBeDefined();
-    expect(command.access).toBe('read');
-    expect(command.columns).toEqual(['rank', 'name', 'profile_url', 'invited_date_text']);
-  });
-
-  it('extracts clean names and dedupes invitation cards by profile url', () => {
-    const dom = new JSDOM(`<!doctype html><body>
-      <ul>
-        <li>
-          <a href="/in/olga-magere/?miniProfileUrn=x"><span>Olga Magere</span></a>
-          <span>Pending</span><button>Withdraw</button><span>Sent 2 weeks ago</span>
-        </li>
-        <li>
-          <a href="/in/olga-magere/?trk=dup"><span>Olga Magere</span></a>
-          <span>Pending</span><button>Withdraw</button><span>Sent 2 weeks ago</span>
-        </li>
-        <li>
-          <div>Sam Founder\nSent yesterday\nWithdraw</div>
-        </li>
-      </ul>
-    </body>`, { url: 'https://www.linkedin.com/mynetwork/invitation-manager/sent/' });
-    const previousWindow = globalThis.window;
-    const previousDocument = globalThis.document;
-    const previousLocation = globalThis.location;
-    try {
-      globalThis.window = dom.window;
-      globalThis.document = dom.window.document;
-      globalThis.location = dom.window.location;
-      globalThis.getComputedStyle = dom.window.getComputedStyle;
-      Object.defineProperty(dom.window.HTMLElement.prototype, 'offsetParent', { get() { return dom.window.document.body; }, configurable: true });
-      const run = Function(`return ${buildSentInvitationsScript()}`);
-      const result = run();
-      expect(result.rows).toEqual([
-        {
-          name: 'Olga Magere',
-          profile_url: 'https://www.linkedin.com/in/olga-magere/',
-          invited_date_text: 'Sent 2 weeks ago',
-        },
-        {
-          name: 'Sam Founder',
-          profile_url: '',
-          invited_date_text: 'Sent yesterday',
-        },
-      ]);
-      expect(result.rows[0]).not.toHaveProperty('raw');
-    } finally {
-      globalThis.window = previousWindow;
-      globalThis.document = previousDocument;
-      globalThis.location = previousLocation;
-    }
-  });
-});

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

@@ -1,105 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import { CommandExecutionError } from '@sovovs/bycli/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/thread-snapshot.test.js

@@ -1,89 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import { ArgumentError, CommandExecutionError } from '@sovovs/bycli/errors';
-import './thread-snapshot.js';
-
-const { canonicalizeLinkedInThreadUrl, parseMaxScrolls } = await import('./thread-snapshot.js').then((m) => m.__test__);
-
-function makeFakePage(snapshot) {
-  return {
-    goto: vi.fn(async () => undefined),
-    wait: vi.fn(async () => undefined),
-    evaluate: vi.fn(async () => snapshot),
-  };
-}
-
-describe('linkedin thread-snapshot command', () => {
-  it('accepts only exact LinkedIn messaging thread URLs', () => {
-    expect(canonicalizeLinkedInThreadUrl('https://www.linkedin.com/messaging/thread/2-abc==/?mini=true#x'))
-      .toBe('https://www.linkedin.com/messaging/thread/2-abc==/');
-    expect(canonicalizeLinkedInThreadUrl('https://www.linkedin.com/messaging/thread/2-abc==/extra')).toBe('');
-    expect(canonicalizeLinkedInThreadUrl('https://evil-linkedin.com/messaging/thread/2-abc==/')).toBe('');
-    expect(canonicalizeLinkedInThreadUrl('http://www.linkedin.com/messaging/thread/2-abc==/')).toBe('');
-  });
-
-  it('validates max-scrolls without silent clamping', () => {
-    expect(parseMaxScrolls(undefined)).toBe(30);
-    expect(parseMaxScrolls(0)).toBe(0);
-    expect(parseMaxScrolls(80)).toBe(80);
-    expect(() => parseMaxScrolls(81)).toThrow('--max-scrolls must be an integer between 0 and 80');
-    expect(() => parseMaxScrolls(1.5)).toThrow('--max-scrolls must be an integer between 0 and 80');
-  });
-
-  it('registers as a read command for loading full thread context', () => {
-    const command = getRegistry().get('linkedin/thread-snapshot');
-    expect(command).toBeDefined();
-    expect(command.access).toBe('read');
-    expect(command.columns).toEqual(expect.arrayContaining(['thread_url', 'recipient', 'message_count', 'latest_text']));
-  });
-
-  it('opens messaging first, then exact thread, and returns extracted messages', async () => {
-    const command = getRegistry().get('linkedin/thread-snapshot');
-    const page = makeFakePage({
-      url: 'https://www.linkedin.com/messaging/thread/abc/',
-      headerNames: ['Neha Rudraraju'],
-      latestMessageText: 'safe-send test from hermes. pls ignore :)',
-      messages: [
-        { index: 0, speaker: 'Neha Rudraraju', text: 'damn i just saw ur msg sry sry' },
-        { index: 1, speaker: 'Me', text: 'safe-send test from hermes. pls ignore :)' },
-      ],
-    });
-
-    const rows = await command.func(page, {
-      'thread-url': 'https://www.linkedin.com/messaging/thread/abc/',
-      'max-scrolls': 8,
-      json: false,
-    });
-
-    expect(page.goto).toHaveBeenNthCalledWith(1, 'https://www.linkedin.com/messaging/');
-    expect(page.goto).toHaveBeenNthCalledWith(2, 'https://www.linkedin.com/messaging/thread/abc/');
-    expect(rows[0]).toMatchObject({
-      thread_url: 'https://www.linkedin.com/messaging/thread/abc/',
-      recipient: 'Neha Rudraraju',
-      message_count: 2,
-      latest_text: 'safe-send test from hermes. pls ignore :)',
-    });
-    expect(rows[0].snapshot_json).toContain('damn i just saw ur msg sry sry');
-  });
-
-  it('rejects invalid thread URL before navigation', async () => {
-    const command = getRegistry().get('linkedin/thread-snapshot');
-    const page = makeFakePage({});
-
-    await expect(command.func(page, {
-      'thread-url': 'https://www.linkedin.com/feed/',
-      'max-scrolls': 8,
-    })).rejects.toBeInstanceOf(ArgumentError);
-    expect(page.goto).not.toHaveBeenCalled();
-  });
-
-  it('fails typed on malformed snapshot payloads', async () => {
-    const command = getRegistry().get('linkedin/thread-snapshot');
-    const page = makeFakePage({ url: 'https://www.linkedin.com/messaging/thread/abc/', headerNames: ['Neha Rudraraju'] });
-
-    await expect(command.func(page, {
-      'thread-url': 'https://www.linkedin.com/messaging/thread/abc/',
-      'max-scrolls': 8,
-    })).rejects.toBeInstanceOf(CommandExecutionError);
-  });
-});

package/clis/linkedin/timeline.test.js

@@ -1,81 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import './timeline.js';
-const { parseMetric, buildPostId, mergeTimelinePosts } = await import('./timeline.js').then((m) => m.__test__);
-describe('linkedin timeline adapter', () => {
-    const command = getRegistry().get('linkedin/timeline');
-    it('registers the command with correct shape', () => {
-        expect(command).toBeDefined();
-        expect(command.site).toBe('linkedin');
-        expect(command.name).toBe('timeline');
-        expect(command.domain).toBe('www.linkedin.com');
-        expect(command.strategy).toBe('cookie');
-        expect(command.browser).toBe(true);
-        expect(typeof command.func).toBe('function');
-    });
-    it('has limit arg with default 20', () => {
-        const limitArg = command.args.find((a) => a.name === 'limit');
-        expect(limitArg).toBeDefined();
-        expect(limitArg.default).toBe(20);
-    });
-    it('includes expected columns', () => {
-        expect(command.columns).toEqual(expect.arrayContaining(['author', 'text', 'reactions', 'comments', 'url']));
-    });
-});
-describe('parseMetric', () => {
-    it('parses plain numbers', () => {
-        expect(parseMetric('42')).toBe(42);
-        expect(parseMetric('1,234')).toBe(1234);
-    });
-    it('handles k/m suffixes', () => {
-        expect(parseMetric('2.5k')).toBe(2500);
-        expect(parseMetric('1.2M')).toBe(1200000);
-    });
-    it('returns 0 for empty/undefined', () => {
-        expect(parseMetric('')).toBe(0);
-        expect(parseMetric(undefined)).toBe(0);
-        expect(parseMetric(null)).toBe(0);
-    });
-});
-describe('buildPostId', () => {
-    it('uses url when present', () => {
-        expect(buildPostId({ url: 'https://linkedin.com/post/123' })).toBe('https://linkedin.com/post/123');
-    });
-    it('falls back to composite key', () => {
-        const id = buildPostId({ author: 'Alice', posted_at: '2h', text: 'Hello world' });
-        expect(id).toBe('Alice::2h::Hello world');
-    });
-});
-describe('mergeTimelinePosts', () => {
-    it('deduplicates by url', () => {
-        const url = 'https://linkedin.com/post/1';
-        const a = {
-            id: url,
-            author: 'Alice',
-            author_url: '',
-            headline: '',
-            text: 'Hello',
-            posted_at: '1h',
-            reactions: 5,
-            comments: 1,
-            url,
-        };
-        const result = mergeTimelinePosts([a], [a]);
-        expect(result).toHaveLength(1);
-    });
-    it('skips posts without author or text', () => {
-        const empty = {
-            id: '2',
-            author: '',
-            author_url: '',
-            headline: '',
-            text: 'some text',
-            posted_at: '',
-            reactions: 0,
-            comments: 0,
-            url: '',
-        };
-        const result = mergeTimelinePosts([], [empty]);
-        expect(result).toHaveLength(0);
-    });
-});