@jackwener/opencli 1.7.22 → 1.8.1

package/clis/linkedin/thread-snapshot.js

@@ -0,0 +1,214 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+
+const LINKEDIN_DOMAIN = 'www.linkedin.com';
+
+function normalizeWhitespace(value) {
+  return String(value ?? '').replace(/[\u00a0\u202f]/g, ' ').replace(/\s+/g, ' ').trim();
+}
+
+function unwrapEvaluateResult(payload) {
+  if (payload && typeof payload === 'object' && 'data' in payload && 'session' in payload) return payload.data;
+  return payload;
+}
+
+function isLinkedInHost(hostname) {
+  const host = String(hostname || '').toLowerCase();
+  return host === 'linkedin.com' || host.endsWith('.linkedin.com');
+}
+
+function canonicalizeLinkedInThreadUrl(value) {
+  const raw = normalizeWhitespace(value);
+  if (!raw) return '';
+  try {
+    const url = new URL(raw);
+    if (url.protocol !== 'https:' || url.username || url.password || url.port || !isLinkedInHost(url.hostname)) return '';
+    const match = url.pathname.match(/^\/messaging\/thread\/([^/]+)\/?$/i);
+    if (!match || !match[1]) return '';
+    url.hostname = 'www.linkedin.com';
+    url.hash = '';
+    url.search = '';
+    if (!url.pathname.endsWith('/')) url.pathname += '/';
+    return url.toString();
+  } catch {
+    return '';
+  }
+}
+
+function requireStringArg(args, key, label = key) {
+  const value = normalizeWhitespace(args[key]);
+  if (!value) throw new ArgumentError(`${label} is required`);
+  return value;
+}
+
+function requireLinkedInThreadUrl(value, label) {
+  const url = canonicalizeLinkedInThreadUrl(value);
+  if (!url) throw new ArgumentError(`${label} must be an exact https://www.linkedin.com/messaging/thread/<id>/ URL`);
+  return url;
+}
+
+function parseMaxScrolls(value) {
+  if (value === undefined || value === null || value === '') return 30;
+  const scrolls = Number(value);
+  if (!Number.isInteger(scrolls) || scrolls < 0 || scrolls > 80) {
+    throw new ArgumentError('--max-scrolls must be an integer between 0 and 80');
+  }
+  return scrolls;
+}
+
+function buildThreadSnapshotScript(maxScrolls) {
+  const scrolls = maxScrolls;
+  return String.raw`(async () => {
+    const marker = '__OPENCLI_LINKEDIN_THREAD_SNAPSHOT__';
+    void marker;
+    const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    const clean = (s) => String(s || '').replace(/[\u00a0\u202f]/g, ' ').replace(/\s+/g, ' ').trim();
+    const text = document.body ? (document.body.innerText || '') : '';
+    const authRequired = /\b(sign in|log in|join linkedin)\b/i.test(text)
+      || /linkedin\.com\/(login|checkpoint|authwall)/i.test(location.href)
+      || /captcha|verification required/i.test(text);
+
+    const selectors = [
+      '.msg-s-message-list',
+      '.msg-s-message-list-scrollable',
+      '.msg-thread',
+      'main [role="main"]',
+      'main'
+    ];
+    let scroller = null;
+    for (const selector of selectors) {
+      const el = document.querySelector(selector);
+      if (el && (el.scrollHeight > el.clientHeight || selector === 'main')) { scroller = el; break; }
+    }
+    scroller = scroller || document.scrollingElement || document.documentElement;
+    let previousHeight = -1;
+    let stable = 0;
+    for (let i = 0; i < ${scrolls}; i += 1) {
+      scroller.scrollTop = 0;
+      window.scrollTo(0, 0);
+      await sleep(750);
+      const height = scroller.scrollHeight || document.body.scrollHeight || 0;
+      if (height === previousHeight) stable += 1; else stable = 0;
+      previousHeight = height;
+      if (stable >= 3) break;
+    }
+    await sleep(1000);
+
+    const headerCandidates = [];
+    const headerSelectors = [
+      '.msg-thread__link-to-profile',
+      '.msg-thread__link-to-profile span[aria-hidden="true"]',
+      '.msg-entity-lockup__entity-title',
+      '.msg-conversation-card__participant-names',
+      'main h1',
+      'main h2',
+      '[data-anonymize="person-name"]',
+      'a[href*="/in/"] span[aria-hidden="true"]',
+      'a[href*="/in/"]'
+    ];
+    for (const selector of headerSelectors) {
+      for (const el of Array.from(document.querySelectorAll(selector)).slice(0, 8)) {
+        const value = clean(el.innerText || el.textContent || el.getAttribute('aria-label'));
+        if (value && value.length <= 120 && !/^(message|messaging|send|profile|view profile)$/i.test(value)) {
+          headerCandidates.push(value);
+        }
+      }
+    }
+
+    const seen = new Set();
+    const messages = [];
+    const nodes = Array.from(document.querySelectorAll('.msg-s-message-list__event, .msg-s-event-listitem, [data-event-urn], .msg-s-message-list-content'));
+    for (const [nodeIndex, el] of nodes.entries()) {
+      const raw = clean(el.innerText || el.textContent);
+      if (!raw || seen.has(raw)) continue;
+      seen.add(raw);
+      const lines = raw.split(/\n+/).map(clean).filter(Boolean);
+      const speaker = lines.length > 1 && lines[0].length <= 120 ? lines[0] : '';
+      messages.push({ index: messages.length, nodeIndex, speaker, text: raw });
+    }
+
+    const refreshedText = document.body ? (document.body.innerText || '') : '';
+    const fallbackLines = refreshedText.split(/\n+/).map(clean).filter(Boolean);
+    const latestMessageText = messages.length
+      ? messages[messages.length - 1].text
+      : ([...fallbackLines].reverse().find((line) => !/^(send|reply|write a message|press enter to send)$/i.test(line)) || '');
+
+    return {
+      url: location.href,
+      title: document.title || '',
+      headerNames: Array.from(new Set(headerCandidates)).slice(0, 10),
+      bodyText: refreshedText,
+      latestMessageText,
+      messages,
+      messageCount: messages.length,
+      authRequired,
+      extractedAt: new Date().toISOString(),
+      maxScrolls: ${scrolls}
+    };
+  })()`;
+}
+
+cli({
+  site: 'linkedin',
+  name: 'thread-snapshot',
+  access: 'read',
+  description: 'Load a LinkedIn messaging thread, scroll for available history, and return a full context snapshot',
+  domain: LINKEDIN_DOMAIN,
+  strategy: Strategy.UI,
+  browser: true,
+  args: [
+    { name: 'thread-url', required: true, help: 'Exact LinkedIn messaging thread URL to open and snapshot' },
+    { name: 'max-scrolls', type: 'number', default: 30, help: 'Maximum upward scroll attempts to load older messages' },
+    { name: 'json', type: 'bool', default: false, help: 'Return only JSON snapshot string in the snapshot_json field' },
+  ],
+  columns: ['thread_url', 'recipient', 'message_count', 'latest_text', 'snapshot_json'],
+  func: async (page, args) => {
+    if (!page) throw new CommandExecutionError('Browser session required for linkedin thread-snapshot');
+    const threadUrl = requireLinkedInThreadUrl(requireStringArg(args, 'thread-url', '--thread-url'), '--thread-url');
+    const maxScrolls = parseMaxScrolls(args['max-scrolls']);
+
+    await page.goto('https://www.linkedin.com/messaging/');
+    await page.wait(4);
+    await page.goto(threadUrl);
+    await page.wait(10);
+
+    const snapshot = unwrapEvaluateResult(await page.evaluate(buildThreadSnapshotScript(maxScrolls)));
+    if (snapshot?.authRequired) {
+      throw new AuthRequiredError(LINKEDIN_DOMAIN, 'LinkedIn thread-snapshot requires an active signed-in LinkedIn browser session.');
+    }
+    if (!snapshot || typeof snapshot !== 'object' || Array.isArray(snapshot) || !Array.isArray(snapshot.headerNames) || !Array.isArray(snapshot.messages)) {
+      throw new CommandExecutionError('LinkedIn thread-snapshot returned malformed snapshot payload');
+    }
+
+    const actualUrl = canonicalizeLinkedInThreadUrl(snapshot?.url || '');
+    if (threadUrl && actualUrl && threadUrl !== actualUrl) {
+      throw new CommandExecutionError('LinkedIn thread-snapshot blocked: thread_url_mismatch', `Expected ${threadUrl}; actual ${actualUrl}`);
+    }
+
+    const recipient = normalizeWhitespace(snapshot.headerNames[0] || '');
+    const messageCount = snapshot.messages.length;
+    const normalized = {
+      ...snapshot,
+      url: actualUrl || threadUrl,
+      headerNames: snapshot.headerNames,
+      latestMessageText: normalizeWhitespace(snapshot?.latestMessageText || ''),
+      messages: snapshot.messages,
+    };
+
+    return [{
+      thread_url: normalized.url,
+      recipient,
+      message_count: messageCount,
+      latest_text: normalized.latestMessageText,
+      snapshot_json: JSON.stringify(normalized),
+    }];
+  },
+});
+
+export const __test__ = {
+  normalizeWhitespace,
+  canonicalizeLinkedInThreadUrl,
+  parseMaxScrolls,
+  unwrapEvaluateResult,
+  buildThreadSnapshotScript,
+};

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

@@ -0,0 +1,89 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError } from '@jackwener/opencli/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.js

@@ -1,5 +1,6 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { AuthRequiredError, EmptyResultError } from '@jackwener/opencli/errors';
+import { compactRepeatedText } from './shared.js';
 function normalizeWhitespace(value) {
     return String(value ?? '').replace(/\s+/g, ' ').trim();
 }
@@ -23,9 +24,9 @@ function buildPostId(post) {
     const url = normalizeWhitespace(post.url);
     if (url)
         return url;
-    const author = normalizeWhitespace(post.author);
+    const author = compactRepeatedText(post.author);
     const text = normalizeWhitespace(post.text);
-    const postedAt = normalizeWhitespace(post.posted_at);
+    const postedAt = normalizeTimestamp(post.posted_at);
     return `${author}::${postedAt}::${text.slice(0, 120)}`;
 }
 function mergeTimelinePosts(existing, batch) {
@@ -34,11 +35,11 @@ function mergeTimelinePosts(existing, batch) {
     for (const rawPost of batch) {
         const post = {
             id: buildPostId(rawPost),
-            author: normalizeWhitespace(rawPost.author),
+            author: compactRepeatedText(rawPost.author),
             author_url: normalizeWhitespace(rawPost.author_url),
-            headline: normalizeWhitespace(rawPost.headline),
+            headline: compactRepeatedText(rawPost.headline),
             text: normalizeWhitespace(rawPost.text),
-            posted_at: normalizeWhitespace(rawPost.posted_at),
+            posted_at: normalizeTimestamp(rawPost.posted_at),
             reactions: Number(rawPost.reactions) || 0,
             comments: Number(rawPost.comments) || 0,
             url: normalizeWhitespace(rawPost.url),
@@ -52,6 +53,11 @@ function mergeTimelinePosts(existing, batch) {
     }
     return merged;
 }
+function normalizeTimestamp(value) {
+    const text = normalizeWhitespace(value).replace(/[•·.]$/g, '').trim();
+    const match = text.match(/\b(\d+\s*(?:s|m|h|d|w|mo|yr|min))\b/i);
+    return match ? match[1].replace(/\s+/g, '') : text;
+}
 async function extractVisiblePosts(page) {
     return page.evaluate(`(function () {
     function normalize(value) {
@@ -376,7 +382,7 @@ async function extractVisiblePosts(page) {
           || /see more|more/i.test(normalize(el.getAttribute('aria-label')));
       })
       .slice(0, 8);
-    var cards = Array.from(document.querySelectorAll('article, .feed-shared-update-v2, .occludable-update, [role="listitem"]'));
+    var cards = Array.from(document.querySelectorAll('article, [role="article"], .feed-shared-update-v2, .occludable-update, [role="listitem"]'));
     var seen = new Set();
     var posts = [];
     var i;
@@ -397,7 +403,7 @@ async function extractVisiblePosts(page) {
 
     for (i = 0; i < cards.length; i += 1) {
       card = cards[i];
-      root = card.closest('article, .feed-shared-update-v2, .occludable-update, [role="listitem"]') || card;
+      root = card.closest('article, [role="article"], .feed-shared-update-v2, .occludable-update, [role="listitem"]') || card;
       if (!root || seen.has(root)) continue;
       seen.add(root);
 
@@ -501,4 +507,5 @@ export const __test__ = {
     parseMetric,
     buildPostId,
     mergeTimelinePosts,
+    normalizeTimestamp,
 };

package/clis/linkedin-learning/course.js

@@ -0,0 +1,138 @@
+/**
+ * LinkedIn Learning course detail by slug, via /learning-api/courses?q=slug.
+ */
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+const DOMAIN = 'www.linkedin.com';
+
+function normalizeWhitespace(value) {
+    return String(value ?? '').replace(/[  ]/g, ' ').replace(/\s+/g, ' ').trim();
+}
+
+function unwrapEvaluateResult(payload) {
+    if (payload && typeof payload === 'object' && 'data' in payload && 'session' in payload) return payload.data;
+    return payload;
+}
+
+function parseSlug(value) {
+    const s = normalizeWhitespace(value);
+    if (!s) throw new ArgumentError('<slug> is required');
+    let slug = s;
+    if (/^https?:\/\//i.test(s)) {
+        let parsed;
+        try {
+            parsed = new URL(s);
+        } catch {
+            throw new ArgumentError(`Invalid LinkedIn Learning URL: "${s}"`);
+        }
+        const host = parsed.hostname.toLowerCase();
+        if (host !== 'linkedin.com' && host !== 'www.linkedin.com') {
+            throw new ArgumentError(`Invalid LinkedIn Learning host: "${parsed.hostname}"`);
+        }
+        const m = parsed.pathname.match(/^\/learning\/([^/?#]+)/);
+        if (!m) throw new ArgumentError(`Invalid LinkedIn Learning course URL: "${s}"`);
+        slug = m[1];
+    } else {
+        const m = s.match(/^\/?learning\/([^/?#]+)/);
+        slug = m ? m[1] : s;
+    }
+    if (!/^[a-zA-Z0-9-_]+$/.test(slug)) {
+        throw new ArgumentError(`Invalid LinkedIn Learning slug: "${slug}"`);
+    }
+    return slug;
+}
+
+function buildFetchScript(url, csrf) {
+    return String.raw`(async () => {
+    try {
+      const res = await fetch(${JSON.stringify(url)}, {
+        credentials: 'include',
+        headers: {
+          'csrf-token': ${JSON.stringify(csrf)},
+          'x-restli-protocol-version': '2.0.0',
+          accept: 'application/json',
+        },
+      });
+      if (res.status === 401 || res.status === 403) return { authRequired: true, status: res.status };
+      if (!res.ok) return { error: 'HTTP ' + res.status };
+      return { json: await res.json() };
+    } catch (e) {
+      return { error: 'fetch failed: ' + ((e && e.message) || String(e)) };
+    }
+  })()`;
+}
+
+function parseCourse(el, slug) {
+    const title = normalizeWhitespace(el?.title);
+    if (!title) return null;
+    const description = typeof el?.description === 'string'
+        ? el.description
+        : (el?.description?.text || '');
+    const duration = el?.duration?.unit === 'SECOND' ? String(el.duration.duration ?? '') : '';
+    const released = el?.activatedAt ? new Date(el.activatedAt).toISOString().slice(0, 10) : '';
+    return {
+        title,
+        slug,
+        description,
+        difficulty: el?.difficultyLevel || '',
+        duration_sec: duration,
+        videos_count: el?.videosCount ?? '',
+        rating: typeof el?.rating?.averageRating === 'number' ? el.rating.averageRating.toFixed(2) : '',
+        rating_count: el?.rating?.ratingCount ?? '',
+        released,
+        url: `https://www.linkedin.com/learning/${slug}`,
+    };
+}
+
+cli({
+    site: 'linkedin-learning',
+    name: 'course',
+    access: 'read',
+    description: 'Get LinkedIn Learning course detail by slug or course URL',
+    domain: DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'slug', type: 'string', required: true, positional: true, help: 'Course slug (e.g. agentic-ai-build-your-first-agentic-ai-system) or full /learning/<slug> URL' },
+    ],
+    columns: ['title', 'slug', 'description', 'difficulty', 'duration_sec', 'videos_count', 'rating', 'rating_count', 'released', 'url'],
+    func: async (page, args) => {
+        if (!page) throw new CommandExecutionError('Browser session required for linkedin-learning course');
+        const slug = parseSlug(args.slug);
+
+        await page.goto('https://www.linkedin.com/learning/');
+        await page.wait(3);
+
+        const cookies = await page.getCookies({ url: 'https://www.linkedin.com' });
+        const jsession = cookies.find((c) => c.name === 'JSESSIONID')?.value;
+        if (!jsession) {
+            throw new AuthRequiredError(DOMAIN, 'LinkedIn JSESSIONID cookie not found. Please sign in to LinkedIn in the browser.');
+        }
+        const csrf = jsession.replace(/^"|"$/g, '');
+
+        const url = `https://www.linkedin.com/learning-api/courses?q=slug&slug=${encodeURIComponent(slug)}`;
+        const result = unwrapEvaluateResult(await page.evaluate(buildFetchScript(url, csrf)));
+        if (result?.authRequired) {
+            throw new AuthRequiredError(DOMAIN, `LinkedIn Learning auth failed (HTTP ${result.status ?? ''}).`);
+        }
+        if (!result?.json) {
+            throw new CommandExecutionError(`LinkedIn Learning courses lookup failed: ${result?.error ?? 'no payload'}`);
+        }
+        const elements = result.json?.elements;
+        if (!Array.isArray(elements)) {
+            throw new CommandExecutionError('LinkedIn Learning courses lookup returned malformed payload: missing elements array');
+        }
+        const el = elements[0];
+        if (!el) {
+            throw new EmptyResultError(`No LinkedIn Learning course found for slug "${slug}"`);
+        }
+        const row = parseCourse(el, slug);
+        if (!row) {
+            throw new CommandExecutionError('LinkedIn Learning courses lookup returned malformed course detail: missing title');
+        }
+        return [row];
+    },
+});
+
+export const __test__ = { parseSlug, parseCourse };

package/clis/linkedin-learning/course.test.js

@@ -0,0 +1,114 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import './course.js';
+
+const { parseSlug, parseCourse } = await import('./course.js').then((m) => m.__test__);
+
+function makePage({ evaluateResult, cookies = [{ name: 'JSESSIONID', value: '"ajax:abc"' }] } = {}) {
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        wait: vi.fn().mockResolvedValue(undefined),
+        getCookies: vi.fn().mockResolvedValue(cookies),
+        evaluate: vi.fn().mockResolvedValue(evaluateResult),
+    };
+}
+
+describe('linkedin-learning course', () => {
+    it('accepts a bare slug', () => {
+        expect(parseSlug('agentic-ai-build')).toBe('agentic-ai-build');
+    });
+
+    it('extracts a slug from a full /learning/<slug> URL', () => {
+        expect(parseSlug('https://www.linkedin.com/learning/agentic-ai-build/?foo=1'))
+            .toBe('agentic-ai-build');
+    });
+
+    it('rejects non-LinkedIn Learning URLs before navigation', () => {
+        expect(() => parseSlug('https://evil.example/learning/agentic-ai-build')).toThrow(ArgumentError);
+        expect(() => parseSlug('https://www.linkedin.com/feed/update/123')).toThrow(ArgumentError);
+    });
+
+    it('rejects empty or invalid slugs with ArgumentError', () => {
+        expect(() => parseSlug('')).toThrow(ArgumentError);
+        expect(() => parseSlug('   ')).toThrow(ArgumentError);
+        expect(() => parseSlug('not a slug!')).toThrow(ArgumentError);
+    });
+
+    it('maps a course detail element to the canonical row shape', () => {
+        const el = {
+            title: 'Agentic AI: Build Your First Agentic AI System',
+            description: { text: 'Dive into agentic AI...' },
+            duration: { duration: 3932, unit: 'SECOND' },
+            difficultyLevel: 'Intermediate',
+            videosCount: 18,
+            rating: { averageRating: 4.5, ratingCount: 259 },
+            activatedAt: 1774569600000,
+        };
+        const row = parseCourse(el, 'agentic-ai-build-your-first-agentic-ai-system');
+        expect(row.title).toBe('Agentic AI: Build Your First Agentic AI System');
+        expect(row.slug).toBe('agentic-ai-build-your-first-agentic-ai-system');
+        expect(row.description).toBe('Dive into agentic AI...');
+        expect(row.difficulty).toBe('Intermediate');
+        expect(row.duration_sec).toBe('3932');
+        expect(row.videos_count).toBe(18);
+        expect(row.rating).toBe('4.50');
+        expect(row.rating_count).toBe(259);
+        expect(row.released).toBe('2026-03-27');
+        expect(row.url).toBe('https://www.linkedin.com/learning/agentic-ai-build-your-first-agentic-ai-system');
+    });
+
+    it('handles description as a bare string', () => {
+        const row = parseCourse({ title: 't', description: 'plain string' }, 'x');
+        expect(row.description).toBe('plain string');
+    });
+
+    it('preserves the full course description', () => {
+        const text = 'x'.repeat(350);
+        const row = parseCourse({ title: 't', description: { text } }, 'x');
+        expect(row.description).toBe(text);
+    });
+
+    it('returns empty fields when upstream omits them', () => {
+        const row = parseCourse({ title: 't' }, 'x');
+        expect(row.title).toBe('t');
+        expect(row.duration_sec).toBe('');
+        expect(row.rating).toBe('');
+        expect(row.released).toBe('');
+    });
+
+    it('returns null when upstream omits the core title evidence', () => {
+        expect(parseCourse({}, 'x')).toBeNull();
+        expect(parseCourse({ title: '   ' }, 'x')).toBeNull();
+    });
+
+    it('throws AuthRequiredError when JSESSIONID is missing', async () => {
+        const cmd = getRegistry().get('linkedin-learning/course');
+        const page = makePage({ cookies: [], evaluateResult: { json: { elements: [{}] } } });
+        await expect(cmd.func(page, { slug: 'agentic-ai-build' })).rejects.toBeInstanceOf(AuthRequiredError);
+    });
+
+    it('throws EmptyResultError when no element matches the slug', async () => {
+        const cmd = getRegistry().get('linkedin-learning/course');
+        const page = makePage({ evaluateResult: { json: { elements: [] } } });
+        await expect(cmd.func(page, { slug: 'agentic-ai-build' })).rejects.toBeInstanceOf(EmptyResultError);
+    });
+
+    it('throws CommandExecutionError when the elements array is missing', async () => {
+        const cmd = getRegistry().get('linkedin-learning/course');
+        const page = makePage({ evaluateResult: { json: { data: {} } } });
+        await expect(cmd.func(page, { slug: 'agentic-ai-build' })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('throws CommandExecutionError when the first detail element is malformed', async () => {
+        const cmd = getRegistry().get('linkedin-learning/course');
+        const page = makePage({ evaluateResult: { json: { elements: [{}] } } });
+        await expect(cmd.func(page, { slug: 'agentic-ai-build' })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('throws CommandExecutionError on fetch errors', async () => {
+        const cmd = getRegistry().get('linkedin-learning/course');
+        const page = makePage({ evaluateResult: { error: 'HTTP 500' } });
+        await expect(cmd.func(page, { slug: 'agentic-ai-build' })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+});