@jackwener/opencli 1.4.1 → 1.5.0

package/dist/clis/douban/utils.js

@@ -1,10 +1,15 @@
 /**
  * Douban adapter utilities.
  */
-import { CliError } from '../../errors.js';
+import { ArgumentError, CliError, EmptyResultError } from '../../errors.js';
+const DOUBAN_PHOTO_PAGE_SIZE = 30;
+const MAX_DOUBAN_PHOTOS = 500;
 function clampLimit(limit) {
     return Math.max(1, Math.min(limit || 20, 50));
 }
+function clampPhotoLimit(limit) {
+    return Math.max(1, Math.min(limit || 120, MAX_DOUBAN_PHOTOS));
+}
 async function ensureDoubanReady(page) {
     const state = await page.evaluate(`
     (() => {
@@ -18,6 +23,190 @@ async function ensureDoubanReady(page) {
         throw new CliError('AUTH_REQUIRED', 'Douban requires a logged-in browser session before these commands can load data.', 'Please sign in to douban.com in the browser that opencli reuses, then rerun the command.');
     }
 }
+export function normalizeDoubanSubjectId(subjectId) {
+    const normalized = String(subjectId || '').trim();
+    if (!/^\d+$/.test(normalized)) {
+        throw new ArgumentError(`Invalid Douban subject ID: ${subjectId}`);
+    }
+    return normalized;
+}
+export function promoteDoubanPhotoUrl(url, size = 'l') {
+    const normalized = String(url || '').trim();
+    if (!normalized)
+        return '';
+    if (/^[a-z]+:/i.test(normalized) && !/^https?:/i.test(normalized))
+        return '';
+    return normalized.replace(/\/view\/photo\/[^/]+\/public\//, `/view/photo/${size}/public/`);
+}
+export function resolveDoubanPhotoAssetUrl(candidates, baseUrl = '') {
+    for (const candidate of candidates) {
+        const normalized = String(candidate || '').trim();
+        if (!normalized)
+            continue;
+        let resolved = normalized;
+        try {
+            resolved = baseUrl
+                ? new URL(normalized, baseUrl).toString()
+                : new URL(normalized).toString();
+        }
+        catch {
+            resolved = normalized;
+        }
+        if (/^https?:\/\//i.test(resolved)) {
+            return resolved;
+        }
+    }
+    return '';
+}
+export function getDoubanPhotoExtension(url) {
+    const normalized = String(url || '').trim();
+    if (!normalized)
+        return '.jpg';
+    try {
+        const ext = new URL(normalized).pathname.match(/\.(jpe?g|png|gif|webp|avif|bmp)$/i)?.[0];
+        return ext || '.jpg';
+    }
+    catch {
+        const ext = normalized.match(/\.(jpe?g|png|gif|webp|avif|bmp)(?:$|[?#])/i)?.[0];
+        return ext ? ext.replace(/[?#].*$/, '') : '.jpg';
+    }
+}
+export async function loadDoubanSubjectPhotos(page, subjectId, options = {}) {
+    const normalizedId = normalizeDoubanSubjectId(subjectId);
+    const type = String(options.type || 'Rb').trim() || 'Rb';
+    const targetPhotoId = String(options.targetPhotoId || '').trim();
+    const safeLimit = targetPhotoId ? Number.MAX_SAFE_INTEGER : clampPhotoLimit(Number(options.limit) || 120);
+    const resolvePhotoAssetUrlSource = resolveDoubanPhotoAssetUrl.toString();
+    const galleryUrl = `https://movie.douban.com/subject/${normalizedId}/photos?type=${encodeURIComponent(type)}`;
+    await page.goto(galleryUrl);
+    await page.wait(2);
+    await ensureDoubanReady(page);
+    const data = await page.evaluate(`
+    (async () => {
+      const subjectId = ${JSON.stringify(normalizedId)};
+      const type = ${JSON.stringify(type)};
+      const limit = ${safeLimit};
+      const targetPhotoId = ${JSON.stringify(targetPhotoId)};
+      const pageSize = ${DOUBAN_PHOTO_PAGE_SIZE};
+      const resolveDoubanPhotoAssetUrl = ${resolvePhotoAssetUrlSource};
+
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const toAbsoluteUrl = (value) => {
+        if (!value) return '';
+        try {
+          return new URL(value, location.origin).toString();
+        } catch {
+          return value;
+        }
+      };
+      const promotePhotoUrl = (value) => {
+        const absolute = toAbsoluteUrl(value);
+        if (!absolute) return '';
+        if (/^[a-z]+:/i.test(absolute) && !/^https?:/i.test(absolute)) return '';
+        return absolute.replace(/\\/view\\/photo\\/[^/]+\\/public\\//, '/view/photo/l/public/');
+      };
+      const buildPageUrl = (start) => {
+        const url = new URL(location.href);
+        url.searchParams.set('type', type);
+        if (start > 0) url.searchParams.set('start', String(start));
+        else url.searchParams.delete('start');
+        return url.toString();
+      };
+      const getTitle = (doc) => {
+        const raw = normalize(doc.querySelector('#content h1')?.textContent)
+          || normalize(doc.querySelector('title')?.textContent);
+        return raw.replace(/\\s*\\(豆瓣\\)\\s*$/, '');
+      };
+      const extractPhotos = (doc, pageNumber) => {
+        const nodes = Array.from(doc.querySelectorAll('.poster-col3 li, .poster-col3l li, .article li'));
+        const rows = [];
+        for (const node of nodes) {
+          const link = node.querySelector('a[href*="/photos/photo/"]');
+          const img = node.querySelector('img');
+          if (!link || !img) continue;
+
+          const detailUrl = toAbsoluteUrl(link.getAttribute('href') || '');
+          const photoId = detailUrl.match(/\\/photo\\/(\\d+)/)?.[1] || '';
+          const thumbUrl = resolveDoubanPhotoAssetUrl([
+            img.getAttribute('data-origin'),
+            img.getAttribute('data-src'),
+            img.getAttribute('src'),
+          ], location.href);
+          const imageUrl = promotePhotoUrl(thumbUrl);
+          const title = normalize(link.getAttribute('title'))
+            || normalize(img.getAttribute('alt'))
+            || (photoId ? 'photo_' + photoId : 'photo_' + String(rows.length + 1));
+
+          if (!detailUrl || !thumbUrl || !imageUrl) continue;
+
+          rows.push({
+            photoId,
+            title,
+            imageUrl,
+            thumbUrl,
+            detailUrl,
+            page: pageNumber,
+          });
+        }
+        return rows;
+      };
+
+      const subjectTitle = getTitle(document);
+      const seen = new Set();
+      const photos = [];
+
+      for (let pageIndex = 0; photos.length < limit; pageIndex += 1) {
+        let doc = document;
+        if (pageIndex > 0) {
+          const response = await fetch(buildPageUrl(pageIndex * pageSize), { credentials: 'include' });
+          if (!response.ok) break;
+          const html = await response.text();
+          doc = new DOMParser().parseFromString(html, 'text/html');
+        }
+
+        const pagePhotos = extractPhotos(doc, pageIndex + 1);
+        if (!pagePhotos.length) break;
+
+        let appended = 0;
+        let foundTarget = false;
+        for (const photo of pagePhotos) {
+          const key = photo.photoId || photo.detailUrl || photo.imageUrl;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          photos.push({
+            index: photos.length + 1,
+            ...photo,
+          });
+          appended += 1;
+          if (targetPhotoId && photo.photoId === targetPhotoId) {
+            foundTarget = true;
+            break;
+          }
+          if (photos.length >= limit) break;
+        }
+
+        if (foundTarget || pagePhotos.length < pageSize || appended === 0) break;
+      }
+
+      return {
+        subjectId,
+        subjectTitle,
+        type,
+        photos,
+      };
+    })()
+  `);
+    const photos = Array.isArray(data?.photos) ? data.photos : [];
+    if (!photos.length) {
+        throw new EmptyResultError('douban photos', 'No photos found. Try a different subject ID or a different --type value such as Rb.');
+    }
+    return {
+        subjectId: normalizedId,
+        subjectTitle: String(data?.subjectTitle || '').trim(),
+        type,
+        photos,
+    };
+}
 export async function loadDoubanBookHot(page, limit) {
     const safeLimit = clampLimit(limit);
     await page.goto('https://book.douban.com/chart');

package/dist/clis/douban/utils.test.d.ts

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

package/dist/clis/douban/utils.test.js

@@ -0,0 +1,64 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getDoubanPhotoExtension, loadDoubanSubjectPhotos, normalizeDoubanSubjectId, promoteDoubanPhotoUrl, resolveDoubanPhotoAssetUrl, } from './utils.js';
+describe('douban utils', () => {
+    it('normalizes valid subject ids', () => {
+        expect(normalizeDoubanSubjectId(' 30382501 ')).toBe('30382501');
+    });
+    it('rejects invalid subject ids', () => {
+        expect(() => normalizeDoubanSubjectId('tt30382501')).toThrow('Invalid Douban subject ID');
+    });
+    it('promotes thumbnail urls to large photo urls', () => {
+        expect(promoteDoubanPhotoUrl('https://img1.doubanio.com/view/photo/m/public/p2913450214.webp')).toBe('https://img1.doubanio.com/view/photo/l/public/p2913450214.webp');
+        expect(promoteDoubanPhotoUrl('https://img9.doubanio.com/view/photo/s_ratio_poster/public/p2578474613.jpg')).toBe('https://img9.doubanio.com/view/photo/l/public/p2578474613.jpg');
+    });
+    it('rejects non-http photo urls during promotion', () => {
+        expect(promoteDoubanPhotoUrl('data:image/gif;base64,abc')).toBe('');
+    });
+    it('prefers lazy-loaded photo urls over data placeholders', () => {
+        expect(resolveDoubanPhotoAssetUrl([
+            '',
+            'https://img1.doubanio.com/view/photo/m/public/p2913450214.webp',
+            'data:image/gif;base64,abc',
+        ], 'https://movie.douban.com/subject/30382501/photos?type=Rb')).toBe('https://img1.doubanio.com/view/photo/m/public/p2913450214.webp');
+    });
+    it('drops unsupported non-http photo urls when no real image url exists', () => {
+        expect(resolveDoubanPhotoAssetUrl(['data:image/gif;base64,abc', 'blob:https://movie.douban.com/example'], 'https://movie.douban.com/subject/30382501/photos?type=Rb')).toBe('');
+    });
+    it('removes the default photo cap when scanning for an exact photo id', async () => {
+        const evaluate = vi.fn()
+            .mockResolvedValueOnce({ blocked: false, title: 'Some Movie', href: 'https://movie.douban.com/subject/30382501/photos?type=Rb' })
+            .mockResolvedValueOnce({
+            subjectId: '30382501',
+            subjectTitle: 'The Wandering Earth 2',
+            type: 'Rb',
+            photos: [
+                {
+                    index: 731,
+                    photoId: '2913450215',
+                    title: 'Character poster',
+                    imageUrl: 'https://img1.doubanio.com/view/photo/l/public/p2913450215.jpg',
+                    thumbUrl: 'https://img1.doubanio.com/view/photo/m/public/p2913450215.jpg',
+                    detailUrl: 'https://movie.douban.com/photos/photo/2913450215/',
+                    page: 25,
+                },
+            ],
+        });
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            evaluate,
+        };
+        await loadDoubanSubjectPhotos(page, '30382501', {
+            type: 'Rb',
+            targetPhotoId: '2913450215',
+        });
+        const scanScript = evaluate.mock.calls[1]?.[0];
+        expect(scanScript).toContain('const targetPhotoId = "2913450215";');
+        expect(scanScript).toContain(`const limit = ${Number.MAX_SAFE_INTEGER};`);
+        expect(scanScript).toContain('for (let pageIndex = 0; photos.length < limit; pageIndex += 1)');
+    });
+    it('keeps image extensions when download urls contain query params', () => {
+        expect(getDoubanPhotoExtension('https://img1.doubanio.com/view/photo/l/public/p2913450214.webp?foo=1')).toBe('.webp');
+        expect(getDoubanPhotoExtension('https://img1.doubanio.com/view/photo/l/public/p2913450214.jpeg')).toBe('.jpeg');
+    });
+});

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

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

package/dist/clis/imdb/person.js

@@ -0,0 +1,203 @@
+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.name) {
+            throw new CommandExecutionError(`Person not found: ${id}`, 'Check the person ID and try again');
+        }
+        const result = data;
+        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/dist/clis/imdb/reviews.d.ts

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

package/dist/clis/imdb/reviews.js

@@ -0,0 +1,88 @@
+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, index) => ({
+            rank: index + 1,
+            title: item.title || '',
+            rating: item.rating || '',
+            author: item.author || '',
+            date: item.date || '',
+            text: item.text || '',
+        }));
+    },
+});

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

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