@jackwener/opencli 1.4.1 → 1.5.0

package/dist/clis/imdb/search.js

@@ -0,0 +1,161 @@
+import { ArgumentError, CommandExecutionError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+import { forceEnglishUrl, isChallengePage, normalizeImdbTitleType, waitForImdbPath, waitForImdbSearchReady, } from './utils.js';
+/**
+ * Search IMDb via the public search page and parse Next.js payload first.
+ */
+cli({
+    site: 'imdb',
+    name: 'search',
+    description: 'Search IMDb for movies, TV shows, and people',
+    domain: 'www.imdb.com',
+    strategy: Strategy.PUBLIC,
+    browser: true,
+    args: [
+        { name: 'query', positional: true, required: true, help: 'Search query' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
+    ],
+    columns: ['rank', 'id', 'title', 'year', 'type', 'url'],
+    func: async (page, args) => {
+        const query = String(args.query || '').trim();
+        // Reject empty or whitespace-only queries early
+        if (!query) {
+            throw new ArgumentError('Search query cannot be empty');
+        }
+        const limit = Math.max(1, Math.min(Number(args.limit) || 20, 50));
+        const url = forceEnglishUrl(`https://www.imdb.com/find/?q=${encodeURIComponent(query)}&ref_=nv_sr_sm`);
+        await page.goto(url);
+        const onSearchPage = await waitForImdbPath(page, '^/find/?$');
+        const searchReady = await waitForImdbSearchReady(page, 15000);
+        if (await isChallengePage(page)) {
+            throw new CommandExecutionError('IMDb blocked this request', 'Try again with a normal browser session or extension mode');
+        }
+        if (!onSearchPage || !searchReady) {
+            throw new CommandExecutionError('IMDb search results did not finish loading', 'Retry the command; if it persists, the search page structure may have changed');
+        }
+        const results = await page.evaluate(`
+      (function() {
+        var results = [];
+
+        function pushResult(item) {
+          if (!item || !item.id || !item.title) {
+            return;
+          }
+          results.push(item);
+        }
+
+        var nextDataEl = document.getElementById('__NEXT_DATA__');
+        if (nextDataEl) {
+          try {
+            var nextData = JSON.parse(nextDataEl.textContent || 'null');
+            var pageProps = nextData && nextData.props && nextData.props.pageProps;
+            if (pageProps) {
+              // IMDb wraps results as {index: "tt...", listItem: {...}}
+              var titleResults = (pageProps.titleResults && pageProps.titleResults.results) || [];
+              for (var i = 0; i < titleResults.length; i++) {
+                var tr = titleResults[i] || {};
+                var tItem = tr.listItem || {};
+                var tId = tr.index || '';
+                var tTitle = typeof tItem.originalTitleText === 'string'
+                  ? tItem.originalTitleText
+                  : (tItem.originalTitleText && tItem.originalTitleText.text) || '';
+                if (!tTitle) {
+                  tTitle = typeof tItem.titleText === 'string'
+                    ? tItem.titleText
+                    : (tItem.titleText && tItem.titleText.text) || '';
+                }
+                var tYear = '';
+                if (typeof tItem.releaseYear === 'number' || typeof tItem.releaseYear === 'string') {
+                  tYear = String(tItem.releaseYear);
+                } else if (tItem.releaseYear && typeof tItem.releaseYear === 'object') {
+                  tYear = String(tItem.releaseYear.year || '');
+                }
+                pushResult({
+                  id: tId,
+                  title: tTitle,
+                  year: tYear,
+                  type: tItem.titleType || (tItem.endYear != null ? 'tvSeries' : ''),
+                  url: tId ? 'https://www.imdb.com/title/' + tId + '/' : ''
+                });
+              }
+
+              var nameResults = (pageProps.nameResults && pageProps.nameResults.results) || [];
+              for (var j = 0; j < nameResults.length; j++) {
+                var nr = nameResults[j] || {};
+                var nItem = nr.listItem || {};
+                var nId = nr.index || '';
+                var nTitle = typeof nItem.nameText === 'string'
+                  ? nItem.nameText
+                  : (nItem.nameText && nItem.nameText.text) || '';
+                if (!nTitle) {
+                  nTitle = typeof nItem.originalNameText === 'string'
+                    ? nItem.originalNameText
+                    : (nItem.originalNameText && nItem.originalNameText.text) || '';
+                }
+                var nType = '';
+                if (typeof nItem.primaryProfession === 'string') {
+                  nType = nItem.primaryProfession;
+                } else if (Array.isArray(nItem.primaryProfessions) && nItem.primaryProfessions.length > 0) {
+                  nType = String(nItem.primaryProfessions[0] || '');
+                } else if (Array.isArray(nItem.professions) && nItem.professions.length > 0) {
+                  nType = String(nItem.professions[0] || '');
+                }
+                pushResult({
+                  id: nId,
+                  title: nTitle,
+                  year: nItem.knownFor && nItem.knownFor.yearRange ? String(nItem.knownFor.yearRange.year || '') : (nItem.knownForTitleYear ? String(nItem.knownForTitleYear) : ''),
+                  type: nType || 'Person',
+                  url: nId ? 'https://www.imdb.com/name/' + nId + '/' : ''
+                });
+              }
+            }
+          } catch (error) {
+            void error;
+          }
+        }
+
+        if (results.length === 0) {
+          var items = document.querySelectorAll('[class*="find-title-result"], [class*="find-name-result"], .ipc-metadata-list-summary-item');
+          for (var k = 0; k < items.length; k++) {
+            var el = items[k];
+            var linkEl = el.querySelector('a[href*="/title/"], a[href*="/name/"]');
+            if (!linkEl) {
+              continue;
+            }
+
+            var href = linkEl.getAttribute('href') || '';
+            var idMatch = href.match(/(tt|nm)\\d{7,8}/);
+            if (!idMatch) {
+              continue;
+            }
+
+            var titleEl = el.querySelector('.ipc-metadata-list-summary-item__t, h3, a');
+            var metaEls = el.querySelectorAll('.ipc-metadata-list-summary-item__li, span');
+            var absoluteUrl = href.startsWith('http') ? href : 'https://www.imdb.com' + href.split('?')[0];
+
+            pushResult({
+              id: idMatch[0],
+              title: titleEl ? (titleEl.textContent || '').trim() : '',
+              year: metaEls.length > 0 ? (metaEls[0].textContent || '').trim() : '',
+              type: metaEls.length > 1 ? (metaEls[1].textContent || '').trim() : '',
+              url: absoluteUrl
+            });
+          }
+        }
+
+        return results;
+      })()
+    `);
+        if (!Array.isArray(results)) {
+            return [];
+        }
+        return results.slice(0, limit).map((item, index) => ({
+            rank: index + 1,
+            id: item.id || '',
+            title: item.title || '',
+            year: item.year || '',
+            type: normalizeImdbTitleType(item.type),
+            url: item.url || '',
+        }));
+    },
+});

package/dist/clis/imdb/title.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/imdb/title.js

@@ -0,0 +1,93 @@
+import { CommandExecutionError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+import { extractJsonLd, forceEnglishUrl, formatDuration, getCurrentImdbId, isChallengePage, normalizeImdbId, waitForImdbPath, } from './utils.js';
+/**
+ * Read IMDb title details from JSON-LD on the public page.
+ */
+cli({
+    site: 'imdb',
+    name: 'title',
+    description: 'Get movie or TV show details',
+    domain: 'www.imdb.com',
+    strategy: Strategy.PUBLIC,
+    browser: true,
+    args: [
+        { name: 'id', positional: true, required: true, help: 'IMDb title ID (tt1375666) or URL' },
+    ],
+    columns: ['field', 'value'],
+    func: async (page, args) => {
+        const id = normalizeImdbId(String(args.id), 'tt');
+        const url = forceEnglishUrl(`https://www.imdb.com/title/${id}/`);
+        await page.goto(url);
+        const onTitlePage = await waitForImdbPath(page, `^/title/${id}/`);
+        if (await isChallengePage(page)) {
+            throw new CommandExecutionError('IMDb blocked this request', 'Try again with a normal browser session or extension mode');
+        }
+        if (!onTitlePage) {
+            throw new CommandExecutionError(`Title page did not finish loading: ${id}`, 'Retry the command; if it persists, IMDb may have changed their navigation flow');
+        }
+        const currentId = await getCurrentImdbId(page, 'tt');
+        if (currentId && currentId !== id) {
+            throw new CommandExecutionError(`IMDb redirected to a different title: ${currentId}`, 'Retry the command; if it persists, the title page may have changed');
+        }
+        // Single browser roundtrip: fetch title JSON-LD by type whitelist
+        const titleTypes = ['Movie', 'TVSeries', 'TVEpisode', 'TVMiniseries', 'TVMovie', 'TVSpecial', 'VideoGame', 'ShortFilm'];
+        const ld = await extractJsonLd(page, titleTypes);
+        if (!ld) {
+            throw new CommandExecutionError(`Title not found: ${id}`, 'Check the title ID and try again');
+        }
+        const data = ld;
+        const type = String(data['@type'] || '');
+        const isTvSeries = type === 'TVSeries' || type === 'TVMiniseries';
+        // Handle both array and single-object JSON-LD person fields
+        const toPeople = (arr) => {
+            if (!arr)
+                return '';
+            const list = Array.isArray(arr) ? arr : [arr];
+            return list
+                .slice(0, 5)
+                .map((p) => p.name || '')
+                .filter(Boolean)
+                .join(', ');
+        };
+        const year = (() => {
+            if (isTvSeries && typeof data.startDate === 'string') {
+                const startYear = data.startDate.split('-')[0] || '';
+                const endYear = typeof data.endDate === 'string' ? data.endDate.split('-')[0] || '' : '';
+                // Show "2024-" for ongoing series (no endDate) or "2010-2015" for ended ones
+                return endYear ? `${startYear}-${endYear}` : `${startYear}-`;
+            }
+            if (typeof data.datePublished === 'string') {
+                return data.datePublished.split('-')[0] || '';
+            }
+            return '';
+        })();
+        const directorField = isTvSeries ? 'creator' : 'director';
+        const directorValue = isTvSeries ? toPeople(data.creator) : toPeople(data.director);
+        const fields = {
+            title: String(data.name || ''),
+            type,
+            year,
+            rating: data.aggregateRating?.ratingValue != null ? String(data.aggregateRating.ratingValue) : '',
+            votes: data.aggregateRating?.ratingCount != null ? String(data.aggregateRating.ratingCount) : '',
+            genre: Array.isArray(data.genre) ? data.genre.join(', ') : String(data.genre || ''),
+            [directorField]: directorValue,
+            cast: toPeople(data.actor),
+            duration: formatDuration(String(data.duration || '')),
+            contentRating: String(data.contentRating || ''),
+            plot: String(data.description || ''),
+            url: `https://www.imdb.com/title/${id}/`,
+        };
+        if (isTvSeries) {
+            if (data.numberOfSeasons != null) {
+                fields.seasons = String(data.numberOfSeasons);
+            }
+            if (data.numberOfEpisodes != null) {
+                fields.episodes = String(data.numberOfEpisodes);
+            }
+        }
+        return Object.entries(fields)
+            .filter(([, value]) => value !== '')
+            .map(([field, value]) => ({ field, value }));
+    },
+});

package/dist/clis/imdb/top.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/imdb/top.js

@@ -0,0 +1,53 @@
+import { CommandExecutionError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+import { extractJsonLd, forceEnglishUrl, isChallengePage } from './utils.js';
+/**
+ * Fetch the IMDb Top 250 Movies list from JSON-LD structured data on the chart page.
+ */
+cli({
+    site: 'imdb',
+    name: 'top',
+    description: 'IMDb Top 250 Movies',
+    domain: 'www.imdb.com',
+    strategy: Strategy.PUBLIC,
+    browser: true,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
+    ],
+    columns: ['rank', 'title', 'rating', 'votes', 'genre', 'url'],
+    func: async (page, args) => {
+        const url = forceEnglishUrl('https://www.imdb.com/chart/top/');
+        await page.goto(url);
+        await page.wait(2);
+        if (await isChallengePage(page)) {
+            throw new CommandExecutionError('IMDb blocked this request', 'Try again with a normal browser session or extension mode');
+        }
+        // Extract the ItemList JSON-LD block which contains all chart entries
+        const ld = await extractJsonLd(page, 'ItemList');
+        if (!ld || !Array.isArray(ld.itemListElement)) {
+            throw new CommandExecutionError('Could not find chart data on page', 'IMDb may have changed their page structure');
+        }
+        const limit = Math.max(1, Math.min(Number(args.limit) || 20, 250));
+        const items = ld.itemListElement.slice(0, limit);
+        return items.map((entry, index) => {
+            const item = entry.item || {};
+            const rating = item.aggregateRating || {};
+            const genre = Array.isArray(item.genre)
+                ? item.genre.join(', ')
+                : String(item.genre || '');
+            // Normalize relative URLs to absolute IMDb URLs
+            let itemUrl = item.url || '';
+            if (itemUrl && !/^https?:\/\//.test(itemUrl)) {
+                itemUrl = 'https://www.imdb.com' + itemUrl;
+            }
+            return {
+                rank: entry.position || index + 1,
+                title: String(item.name || ''),
+                rating: rating.ratingValue != null ? String(rating.ratingValue) : '',
+                votes: rating.ratingCount != null ? String(rating.ratingCount) : '',
+                genre,
+                url: itemUrl,
+            };
+        });
+    },
+});

package/dist/clis/imdb/trending.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/imdb/trending.js

@@ -0,0 +1,52 @@
+import { CommandExecutionError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+import { extractJsonLd, forceEnglishUrl, isChallengePage } from './utils.js';
+/**
+ * Fetch the IMDb Most Popular Movies (MovieMeter) list from JSON-LD structured data.
+ */
+cli({
+    site: 'imdb',
+    name: 'trending',
+    description: 'IMDb Most Popular Movies',
+    domain: 'www.imdb.com',
+    strategy: Strategy.PUBLIC,
+    browser: true,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
+    ],
+    columns: ['rank', 'title', 'rating', 'genre', 'url'],
+    func: async (page, args) => {
+        const url = forceEnglishUrl('https://www.imdb.com/chart/moviemeter/');
+        await page.goto(url);
+        await page.wait(2);
+        if (await isChallengePage(page)) {
+            throw new CommandExecutionError('IMDb blocked this request', 'Try again with a normal browser session or extension mode');
+        }
+        // Extract the ItemList JSON-LD block which contains all chart entries
+        const ld = await extractJsonLd(page, 'ItemList');
+        if (!ld || !Array.isArray(ld.itemListElement)) {
+            throw new CommandExecutionError('Could not find chart data on page', 'IMDb may have changed their page structure');
+        }
+        const limit = Math.max(1, Math.min(Number(args.limit) || 20, 100));
+        const items = ld.itemListElement.slice(0, limit);
+        return items.map((entry, index) => {
+            const item = entry.item || {};
+            const rating = item.aggregateRating || {};
+            const genre = Array.isArray(item.genre)
+                ? item.genre.join(', ')
+                : String(item.genre || '');
+            // Normalize relative URLs to absolute IMDb URLs
+            let itemUrl = item.url || '';
+            if (itemUrl && !/^https?:\/\//.test(itemUrl)) {
+                itemUrl = 'https://www.imdb.com' + itemUrl;
+            }
+            return {
+                rank: entry.position || index + 1,
+                title: String(item.name || ''),
+                rating: rating.ratingValue != null ? String(rating.ratingValue) : '',
+                genre,
+                url: itemUrl,
+            };
+        });
+    },
+});

package/dist/clis/imdb/utils.d.ts

@@ -0,0 +1,46 @@
+import type { IPage } from '../../types.js';
+/**
+ * Normalize an IMDb title or person input to a bare ID.
+ * Accepts bare IDs, desktop URLs, mobile URLs, and URLs with language prefixes or query params.
+ */
+export declare function normalizeImdbId(input: string, prefix: 'tt' | 'nm'): string;
+/**
+ * Convert an ISO 8601 duration string to a short human-readable format for table display.
+ * Example: PT2H28M -> 2h 28m.
+ */
+export declare function formatDuration(iso: string): string;
+/**
+ * Force an IMDb page URL to use the English language parameter,
+ * reducing structural differences across localized pages.
+ */
+export declare function forceEnglishUrl(url: string): string;
+/**
+ * Normalize IMDb title-type payloads that may be represented as an object,
+ * a raw string, or an empty text field with only an internal id.
+ */
+export declare function normalizeImdbTitleType(input: unknown): string;
+/**
+ * Extract structured JSON-LD data from the page.
+ * Accepts a single type string or an array of types to match against @type.
+ */
+export declare function extractJsonLd(page: IPage, type?: string | string[]): Promise<Record<string, unknown> | null>;
+/**
+ * Poll until the current IMDb page path matches the expected entity/search path.
+ */
+export declare function waitForImdbPath(page: IPage, pathPattern: string, timeoutMs?: number): Promise<boolean>;
+/**
+ * Wait until IMDb search results (or the search UI state) has rendered.
+ */
+export declare function waitForImdbSearchReady(page: IPage, timeoutMs?: number): Promise<boolean>;
+/**
+ * Wait until IMDb review cards (or the page review summary) has rendered.
+ */
+export declare function waitForImdbReviewsReady(page: IPage, timeoutMs?: number): Promise<boolean>;
+/**
+ * Read the current IMDb entity id from the page URL/canonical metadata.
+ */
+export declare function getCurrentImdbId(page: IPage, prefix: 'tt' | 'nm'): Promise<string>;
+/**
+ * Detect whether the current page is an IMDb bot-challenge or verification page.
+ */
+export declare function isChallengePage(page: IPage): Promise<boolean>;