@jackwener/opencli 1.4.1 → 1.5.1

package/src/clis/imdb/person.ts

@@ -0,0 +1,232 @@
+import { CommandExecutionError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+import {
+  forceEnglishUrl,
+  getCurrentImdbId,
+  isChallengePage,
+  normalizeImdbId,
+  waitForImdbPath,
+} from './utils.js';
+
+/**
+ * Read IMDb person details from public profile pages.
+ */
+cli({
+  site: 'imdb',
+  name: 'person',
+  description: 'Get actor or director info',
+  domain: 'www.imdb.com',
+  strategy: Strategy.PUBLIC,
+  browser: true,
+  args: [
+    { name: 'id', positional: true, required: true, help: 'IMDb person ID (nm0634240) or URL' },
+    { name: 'limit', type: 'int', default: 10, help: 'Max filmography entries' },
+  ],
+  columns: ['field', 'value'],
+  func: async (page, args) => {
+    const id = normalizeImdbId(String(args.id), 'nm');
+    // Clamp to 30 to match the internal evaluate cap
+    const limit = Math.max(1, Math.min(Number(args.limit) || 10, 30));
+    const url = forceEnglishUrl(`https://www.imdb.com/name/${id}/`);
+
+    await page.goto(url);
+    const onPersonPage = await waitForImdbPath(page, `^/name/${id}/`);
+
+    if (await isChallengePage(page)) {
+      throw new CommandExecutionError(
+        'IMDb blocked this request',
+        'Try again with a normal browser session or extension mode',
+      );
+    }
+    if (!onPersonPage) {
+      throw new CommandExecutionError(
+        `Person page did not finish loading: ${id}`,
+        'Retry the command; if it persists, IMDb may have changed their navigation flow',
+      );
+    }
+
+    const currentId = await getCurrentImdbId(page, 'nm');
+    if (currentId && currentId !== id) {
+      throw new CommandExecutionError(
+        `IMDb redirected to a different person: ${currentId}`,
+        'Retry the command; if it persists, the person page may have changed',
+      );
+    }
+
+    const data = await page.evaluate(`
+      (function() {
+        var result = {
+          nameId: '',
+          name: '',
+          description: '',
+          birthDate: '',
+          filmography: []
+        };
+
+        var scripts = document.querySelectorAll('script[type="application/ld+json"]');
+        for (var i = 0; i < scripts.length; i++) {
+          try {
+            var ld = JSON.parse(scripts[i].textContent || 'null');
+            if (ld && ld['@type'] === 'Person') {
+              if (typeof ld.url === 'string') {
+                var ldMatch = ld.url.match(/(nm\\d{7,8})/);
+                if (ldMatch) {
+                  result.nameId = ldMatch[1];
+                }
+              }
+              result.name = result.name || ld.name || '';
+              result.description = result.description || ld.description || '';
+              break;
+            }
+          } catch (error) {
+            void error;
+          }
+        }
+
+        var nextDataEl = document.getElementById('__NEXT_DATA__');
+        if (!nextDataEl) {
+          return result;
+        }
+
+        try {
+          var nextData = JSON.parse(nextDataEl.textContent || 'null');
+          var pageProps = nextData && nextData.props && nextData.props.pageProps;
+          var above = pageProps && (pageProps.aboveTheFold || pageProps.aboveTheFoldData);
+          var main = pageProps && (pageProps.mainColumnData || pageProps.belowTheFold);
+
+          if (above) {
+            if (!result.nameId && above.id) {
+              result.nameId = String(above.id);
+            }
+            if (!result.name && above.nameText && above.nameText.text) {
+              result.name = above.nameText.text;
+            }
+
+            if (above.birthDate) {
+              if (above.birthDate.displayableProperty && above.birthDate.displayableProperty.value) {
+                result.birthDate = above.birthDate.displayableProperty.value.plainText || '';
+              }
+              if (!result.birthDate && above.birthDate.dateComponents) {
+                var dc = above.birthDate.dateComponents;
+                result.birthDate = [dc.year, dc.month, dc.day].filter(Boolean).join('-');
+              }
+            }
+
+            if (above.bio && above.bio.text && above.bio.text.plainText) {
+              result.description = above.bio.text.plainText.substring(0, 300);
+            }
+          }
+
+          var pushFilmography = function(title, year, role) {
+            if (!title) {
+              return;
+            }
+            result.filmography.push({
+              title: title,
+              year: year || '',
+              role: role || ''
+            });
+          };
+
+          var knownFor = main && main.knownForFeatureV2;
+          if (knownFor && Array.isArray(knownFor.credits)) {
+            for (var j = 0; j < knownFor.credits.length; j++) {
+              var knownNode = knownFor.credits[j];
+              if (!knownNode || !knownNode.title) {
+                continue;
+              }
+              var knownRole = '';
+              var knownRoleEdge = knownNode.creditedRoles && Array.isArray(knownNode.creditedRoles.edges)
+                ? knownNode.creditedRoles.edges[0]
+                : null;
+              if (knownRoleEdge && knownRoleEdge.node) {
+                knownRole = knownRoleEdge.node.text
+                  || (knownRoleEdge.node.category ? knownRoleEdge.node.category.text || '' : '');
+              }
+              pushFilmography(
+                knownNode.title.titleText ? knownNode.title.titleText.text : '',
+                knownNode.title.releaseYear ? String(knownNode.title.releaseYear.year || '') : '',
+                knownRole
+              );
+            }
+          }
+
+          if (result.filmography.length === 0) {
+            var creditSources = [];
+            if (main && main.released && Array.isArray(main.released.edges)) {
+              creditSources.push(main.released.edges);
+            }
+            if (main && main.groupings && Array.isArray(main.groupings.edges)) {
+              creditSources.push(main.groupings.edges);
+            }
+
+            for (var k = 0; k < creditSources.length && result.filmography.length < 30; k++) {
+              var groups = creditSources[k];
+              for (var m = 0; m < groups.length && result.filmography.length < 30; m++) {
+                var groupNode = groups[m] && groups[m].node;
+                if (!groupNode) {
+                  continue;
+                }
+
+                var roleName = groupNode.grouping ? groupNode.grouping.text || '' : '';
+                var credits = groupNode.credits && Array.isArray(groupNode.credits.edges)
+                  ? groupNode.credits.edges
+                  : [];
+                for (var n = 0; n < credits.length && result.filmography.length < 30; n++) {
+                  var creditNode = credits[n] && credits[n].node;
+                  if (!creditNode || !creditNode.title) {
+                    continue;
+                  }
+                  pushFilmography(
+                    creditNode.title.titleText ? creditNode.title.titleText.text : (creditNode.title.originalTitleText ? creditNode.title.originalTitleText.text : ''),
+                    creditNode.title.releaseYear ? String(creditNode.title.releaseYear.year || '') : '',
+                    roleName
+                  );
+                }
+              }
+            }
+          }
+        } catch (error) {
+          void error;
+        }
+
+        return result;
+      })()
+    `);
+
+    if (!data || typeof data !== 'object' || !('name' in data) || !(data as Record<string, unknown>).name) {
+      throw new CommandExecutionError(`Person not found: ${id}`, 'Check the person ID and try again');
+    }
+
+    const result = data as Record<string, any>;
+    if (result.nameId && result.nameId !== id) {
+      throw new CommandExecutionError(
+        `IMDb returned a different person payload: ${result.nameId}`,
+        'Retry the command; if it persists, the person parser may need updating',
+      );
+    }
+    const filmography = Array.isArray(result.filmography) ? result.filmography : [];
+
+    // Override url with a clean canonical URL (no query params like ?language=en-US)
+    result.url = `https://www.imdb.com/name/${id}/`;
+
+    const rows = Object.entries(result)
+      .filter(([field, value]) => field !== 'filmography' && field !== 'nameId' && value !== '' && value != null)
+      .map(([field, value]) => ({ field, value: String(value) }));
+
+    if (filmography.length > 0) {
+      rows.push({ field: 'filmography', value: '' });
+      for (const entry of filmography.slice(0, limit)) {
+        const suffix = [entry.year ? `(${entry.year})` : '', entry.role ? `[${entry.role}]` : '']
+          .filter(Boolean)
+          .join(' ');
+        rows.push({
+          field: String(entry.title || ''),
+          value: suffix,
+        });
+      }
+    }
+
+    return rows;
+  },
+});

package/src/clis/imdb/reviews.ts

@@ -0,0 +1,111 @@
+import { CommandExecutionError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+import {
+  forceEnglishUrl,
+  getCurrentImdbId,
+  isChallengePage,
+  normalizeImdbId,
+  waitForImdbPath,
+  waitForImdbReviewsReady,
+} from './utils.js';
+
+/**
+ * Read IMDb user reviews from the first review page.
+ */
+cli({
+  site: 'imdb',
+  name: 'reviews',
+  description: 'Get user reviews for a movie or TV show',
+  domain: 'www.imdb.com',
+  strategy: Strategy.PUBLIC,
+  browser: true,
+  args: [
+    { name: 'id', positional: true, required: true, help: 'IMDb title ID (tt1375666) or URL' },
+    { name: 'limit', type: 'int', default: 10, help: 'Number of reviews' },
+  ],
+  columns: ['rank', 'title', 'rating', 'author', 'date', 'text'],
+  func: async (page, args) => {
+    const id = normalizeImdbId(String(args.id), 'tt');
+    const limit = Math.max(1, Math.min(Number(args.limit) || 10, 25));
+    const url = forceEnglishUrl(`https://www.imdb.com/title/${id}/reviews/`);
+
+    await page.goto(url);
+    const onReviewsPage = await waitForImdbPath(page, `^/title/${id}/reviews/?$`);
+    const reviewsReady = await waitForImdbReviewsReady(page, 15000);
+
+    if (await isChallengePage(page)) {
+      throw new CommandExecutionError(
+        'IMDb blocked this request',
+        'Try again with a normal browser session or extension mode',
+      );
+    }
+    if (!onReviewsPage || !reviewsReady) {
+      throw new CommandExecutionError(
+        'IMDb reviews did not finish loading',
+        'Retry the command; if it persists, the review page structure may have changed',
+      );
+    }
+
+    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 review page may have changed',
+      );
+    }
+
+    const reviews = await page.evaluate(`
+      (function() {
+        var limit = ${limit};
+        var items = [];
+        var containers = document.querySelectorAll('article.user-review-item, [data-testid="review-card-parent"], .imdb-user-review, [data-testid="review-card"], .review-container');
+
+        for (var i = 0; i < containers.length && items.length < limit; i++) {
+          var el = containers[i];
+          var titleEl = el.querySelector('.title, [data-testid="review-summary"], a.title');
+          var ratingEl = el.querySelector('.review-rating .ipc-rating-star--rating, .rating-other-user-rating span:first-child, [data-testid="review-rating"]');
+          var authorEl = el.querySelector('.display-name-link a, [data-testid="author-link"], .author-text, a[href*="/user/"]');
+          var dateEl = el.querySelector('.review-date, [data-testid="review-date"]');
+          var textEl = el.querySelector('.content .text, .content .show-more__control, [data-testid="review-overflow"]');
+
+          var title = titleEl ? (titleEl.textContent || '').trim() : '';
+          var text = textEl ? (textEl.textContent || '').replace(/\\s+/g, ' ').trim().slice(0, 200) : '';
+
+          if (!title && !text) {
+            continue;
+          }
+
+          // Deduplicate: IMDb renders both preview and expanded versions of each review
+          var isDupe = false;
+          for (var d = 0; d < items.length; d++) {
+            if (items[d].title === title) { isDupe = true; break; }
+          }
+          if (isDupe) { continue; }
+
+          items.push({
+            title: title,
+            rating: ratingEl ? (ratingEl.textContent || '').trim() : '',
+            author: authorEl ? (authorEl.textContent || '').trim() : '',
+            date: dateEl ? (dateEl.textContent || '').trim() : '',
+            text: text
+          });
+        }
+
+        return items;
+      })()
+    `);
+
+    if (!Array.isArray(reviews)) {
+      return [];
+    }
+
+    return reviews.map((item: any, index: number) => ({
+      rank: index + 1,
+      title: item.title || '',
+      rating: item.rating || '',
+      author: item.author || '',
+      date: item.date || '',
+      text: item.text || '',
+    }));
+  },
+});

package/src/clis/imdb/search.ts

@@ -0,0 +1,179 @@
+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: any, index: number) => ({
+      rank: index + 1,
+      id: item.id || '',
+      title: item.title || '',
+      year: item.year || '',
+      type: normalizeImdbTitleType(item.type),
+      url: item.url || '',
+    }));
+  },
+});

package/src/clis/imdb/title.ts

@@ -0,0 +1,121 @@
+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 as Record<string, any>;
+    const type = String(data['@type'] || '');
+    const isTvSeries = type === 'TVSeries' || type === 'TVMiniseries';
+
+    // Handle both array and single-object JSON-LD person fields
+    const toPeople = (arr: any): string => {
+      if (!arr) return '';
+      const list = Array.isArray(arr) ? arr : [arr];
+      return list
+        .slice(0, 5)
+        .map((p: any) => 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: Record<string, string> = {
+      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 }));
+  },
+});