@jackwener/opencli 1.7.22 → 1.8.1

package/clis/pixiv/utils.js

@@ -7,6 +7,25 @@
  */
 import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
 const PIXIV_DOMAIN = 'www.pixiv.net';
+
+function unwrapEvaluateResult(payload) {
+    if (payload && !Array.isArray(payload) && typeof payload === 'object' && 'session' in payload && 'data' in payload) {
+        return payload.data;
+    }
+    return payload;
+}
+
+function extractPixivErrorMessage(payload) {
+    if (!payload || typeof payload !== 'object') return '';
+    const candidates = [
+        payload.message,
+        payload.errorMessage,
+        payload.error?.message,
+        payload.error,
+    ];
+    const found = candidates.find((value) => typeof value === 'string' && value.trim());
+    return found ? found.trim() : '';
+}
 /**
  * Navigate to Pixiv (to attach cookies) then fetch a Pixiv Ajax API endpoint.
  *
@@ -21,27 +40,57 @@ const PIXIV_DOMAIN = 'www.pixiv.net';
  * @throws CommandExecutionError on 404 or other HTTP errors
  */
 export async function pixivFetch(page, path, opts = {}) {
-    await page.goto(`https://${PIXIV_DOMAIN}`);
+    try {
+        await page.goto(`https://${PIXIV_DOMAIN}`);
+    } catch (error) {
+        throw new CommandExecutionError(`Pixiv navigation failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
     const qs = opts.params
         ? '?' + Object.entries(opts.params).map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join('&')
         : '';
     const url = `https://${PIXIV_DOMAIN}${path}${qs}`;
-    const data = await page.evaluate(`
+    let data;
+    try {
+        data = unwrapEvaluateResult(await page.evaluate(`
     (async () => {
       const res = await fetch(${JSON.stringify(url)}, { credentials: 'include' });
-      if (!res.ok) return { __httpError: res.status };
-      return await res.json();
+      const text = await res.text();
+      let json = null;
+      if (text) {
+        try { json = JSON.parse(text); } catch {}
+      }
+      if (!res.ok) {
+        return {
+          __httpError: res.status,
+          message: json?.message || json?.errorMessage || json?.error?.message || (typeof json?.error === 'string' ? json.error : '') || text.slice(0, 200),
+        };
+      }
+      if (!json) return { __malformed: true, message: 'invalid JSON' };
+      return json;
     })()
-  `);
+  `));
+    } catch (error) {
+        throw new CommandExecutionError(`Pixiv request failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
     if (data?.__httpError) {
         const status = data.__httpError;
         if (status === 401 || status === 403) {
             throw new AuthRequiredError(PIXIV_DOMAIN, 'Authentication required — please log in to Pixiv in Chrome');
         }
+        const message = extractPixivErrorMessage(data);
         if (status === 404) {
-            throw new CommandExecutionError(opts.notFoundMsg || `Pixiv resource not found (HTTP 404)`);
+            throw new CommandExecutionError(message || opts.notFoundMsg || `Pixiv resource not found (HTTP 404)`);
         }
-        throw new CommandExecutionError(`Pixiv request failed (HTTP ${status})`);
+        throw new CommandExecutionError(message ? `Pixiv request failed (HTTP ${status}): ${message}` : `Pixiv request failed (HTTP ${status})`);
+    }
+    if (!data || Array.isArray(data) || typeof data !== 'object' || data.__malformed) {
+        throw new CommandExecutionError('Pixiv request returned malformed JSON payload');
+    }
+    if (data.error === true) {
+        throw new CommandExecutionError(extractPixivErrorMessage(data) || 'Pixiv API returned an error');
+    }
+    if (!('body' in data)) {
+        throw new CommandExecutionError('Pixiv request returned malformed API payload');
     }
     return data?.body;
 }

package/clis/powerchina/search.js

@@ -2,7 +2,7 @@
  * PowerChina search — browser DOM extraction with multi-entry URL probing.
  */
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { AuthRequiredError } from '@jackwener/opencli/errors';
+import { AuthRequiredError, EmptyResultError } from '@jackwener/opencli/errors';
 import {
   cleanText,
   normalizeDate,
@@ -215,7 +215,7 @@ cli({
     );
 
     if (rows.length === 0 && extractedRows.length > 0) {
-      throw new Error('[taxonomy=empty_result] site=powerchina command=search extracted only navigation/portal rows');
+      throw new EmptyResultError('powerchina search', 'extracted only navigation/portal rows, no bid entries matched');
     }
 
     if (rows.length === 0) {
@@ -227,7 +227,7 @@ cli({
         );
       }
       if (apiFailure) {
-        throw new Error(`[taxonomy=empty_result] site=powerchina command=search api/dom yielded no result: ${apiFailure}`);
+        throw new EmptyResultError('powerchina search', `api/dom yielded no result: ${apiFailure}`);
       }
     }
 

package/clis/powerchina/search.test.js

@@ -1,5 +1,12 @@
-import { describe, expect, it } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import { getRegistry } from '@jackwener/opencli/registry';
 import { __test__ } from './search.js';
+import './search.js';
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
 
 describe('powerchina search helpers', () => {
   it('builds candidate URLs with keyword variants', () => {
@@ -64,4 +71,23 @@ describe('powerchina search helpers', () => {
     expect(mapped?.date).toBe('2026-04-07');
     expect(mapped?.url).toBe('https://bid.powerchina.cn/newcbs/recpro-newmember/BidAnnouncementSummary/getInfo/2409419657');
   });
+
+  it('throws EmptyResultError when extraction only finds navigation rows', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('network down')));
+    const cmd = getRegistry().get('powerchina/search');
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      wait: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn().mockResolvedValue([
+        {
+          title: '首页',
+          url: 'https://bid.powerchina.cn/',
+          date: '',
+          contextText: '首页',
+        },
+      ]),
+    };
+
+    await expect(cmd.func(page, { query: '电梯', limit: 1 })).rejects.toBeInstanceOf(EmptyResultError);
+  });
 });

package/clis/reddit/extract-media.test.js

@@ -0,0 +1,149 @@
+/**
+ * Behavioral tests for the extractRedditMedia helper.
+ *
+ * The helper is duplicated inline inside each adapter's browser-side evaluate()
+ * source (see popular.js / hot.js / search.js / frontpage.js / subreddit.js).
+ * Per-adapter tests grep that the same function-name + spread call is present.
+ * This file pins the helper's behavior against representative Reddit-JSON
+ * fixtures.
+ */
+import { describe, expect, it } from 'vitest';
+
+function decodeHtml(s) {
+  if (typeof s !== 'string' || !s) return '';
+  return s
+    .replace(/&/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#x27;/gi, "'")
+    .replace(/&#39;/g, "'");
+}
+function extractRedditMedia(d) {
+  const post_hint = d?.post_hint || '';
+  const url_overridden_by_dest = d?.url_overridden_by_dest || '';
+  const preview_image_url = decodeHtml(d?.preview?.images?.[0]?.source?.url || '');
+  const gallery_urls = [];
+  const items = d?.gallery_data?.items;
+  const meta = d?.media_metadata;
+  if (Array.isArray(items) && meta) {
+    for (const it of items) {
+      const m = it && meta[it.media_id];
+      const u = m?.s?.u;
+      if (u) gallery_urls.push(decodeHtml(u));
+    }
+  }
+  return { post_hint, url_overridden_by_dest, preview_image_url, gallery_urls };
+}
+
+describe('extractRedditMedia', () => {
+  it('returns empty fields for a plain text/self post', () => {
+    expect(extractRedditMedia({ is_self: true, selftext: 'hi' })).toEqual({
+      post_hint: '',
+      url_overridden_by_dest: '',
+      preview_image_url: '',
+      gallery_urls: [],
+    });
+  });
+
+  it('extracts post_hint, url_overridden_by_dest, preview_image_url for a single-image post', () => {
+    const post = {
+      post_hint: 'image',
+      url_overridden_by_dest: 'https://i.redd.it/abc.jpg',
+      preview: {
+        images: [{ source: { url: 'https://preview.redd.it/abc.jpg?width=640&amp;s=xyz' } }],
+      },
+    };
+    expect(extractRedditMedia(post)).toEqual({
+      post_hint: 'image',
+      url_overridden_by_dest: 'https://i.redd.it/abc.jpg',
+      preview_image_url: 'https://preview.redd.it/abc.jpg?width=640&s=xyz',
+      gallery_urls: [],
+    });
+  });
+
+  it('extracts gallery_urls in gallery_data.items order, HTML-decoded', () => {
+    const post = {
+      post_hint: '',
+      url_overridden_by_dest: 'https://www.reddit.com/gallery/xyz',
+      gallery_data: {
+        items: [{ media_id: 'idB' }, { media_id: 'idA' }, { media_id: 'idC' }],
+      },
+      media_metadata: {
+        idA: { s: { u: 'https://preview.redd.it/idA.jpg?width=1&amp;a=1' } },
+        idB: { s: { u: 'https://preview.redd.it/idB.jpg?width=1&amp;a=2' } },
+        idC: { s: { u: 'https://preview.redd.it/idC.jpg?width=1&amp;a=3' } },
+      },
+    };
+    const out = extractRedditMedia(post);
+    expect(out.gallery_urls).toEqual([
+      'https://preview.redd.it/idB.jpg?width=1&a=2',
+      'https://preview.redd.it/idA.jpg?width=1&a=1',
+      'https://preview.redd.it/idC.jpg?width=1&a=3',
+    ]);
+    expect(out.url_overridden_by_dest).toBe('https://www.reddit.com/gallery/xyz');
+  });
+
+  it('extracts post_hint for a hosted:video post', () => {
+    const post = {
+      post_hint: 'hosted:video',
+      url_overridden_by_dest: 'https://v.redd.it/xyz',
+      preview: { images: [{ source: { url: 'https://preview.redd.it/thumb.jpg' } }] },
+    };
+    const out = extractRedditMedia(post);
+    expect(out.post_hint).toBe('hosted:video');
+    expect(out.url_overridden_by_dest).toBe('https://v.redd.it/xyz');
+    expect(out.preview_image_url).toBe('https://preview.redd.it/thumb.jpg');
+    expect(out.gallery_urls).toEqual([]);
+  });
+
+  it('extracts post_hint for an external link post', () => {
+    const post = {
+      post_hint: 'link',
+      url_overridden_by_dest: 'https://example.com/article',
+    };
+    expect(extractRedditMedia(post)).toEqual({
+      post_hint: 'link',
+      url_overridden_by_dest: 'https://example.com/article',
+      preview_image_url: '',
+      gallery_urls: [],
+    });
+  });
+
+  it('HTML-decodes preview URLs that arrive with &amp; separators', () => {
+    const post = {
+      preview: {
+        images: [{ source: { url: 'https://x/?a=1&amp;b=2&amp;c=3' } }],
+      },
+    };
+    expect(extractRedditMedia(post).preview_image_url).toBe('https://x/?a=1&b=2&c=3');
+  });
+
+  it('skips gallery entries whose media_metadata is missing', () => {
+    const post = {
+      gallery_data: { items: [{ media_id: 'present' }, { media_id: 'orphan' }] },
+      media_metadata: {
+        present: { s: { u: 'https://preview.redd.it/present.jpg' } },
+        // 'orphan' intentionally absent
+      },
+    };
+    expect(extractRedditMedia(post).gallery_urls).toEqual([
+      'https://preview.redd.it/present.jpg',
+    ]);
+  });
+
+  it('tolerates null/undefined input without throwing', () => {
+    expect(extractRedditMedia(null)).toEqual({
+      post_hint: '',
+      url_overridden_by_dest: '',
+      preview_image_url: '',
+      gallery_urls: [],
+    });
+    expect(extractRedditMedia(undefined)).toEqual({
+      post_hint: '',
+      url_overridden_by_dest: '',
+      preview_image_url: '',
+      gallery_urls: [],
+    });
+  });
+});

package/clis/reddit/frontpage.js

@@ -10,22 +10,60 @@ cli({
     args: [
         { name: 'limit', type: 'int', default: 15 },
     ],
-    columns: ['title', 'subreddit', 'author', 'upvotes', 'comments', 'url'],
+    columns: ['title', 'subreddit', 'author', 'upvotes', 'comments', 'url', 'post_hint', 'url_overridden_by_dest', 'preview_image_url', 'gallery_urls'],
     pipeline: [
         { navigate: 'https://www.reddit.com' },
         { evaluate: `(async () => {
-  const res = await fetch('/r/all.json?limit=\${{ args.limit }}', { credentials: 'include' });
+  function decodeHtml(s) {
+    if (typeof s !== 'string' || !s) return '';
+    return s
+      .replace(/&/g, '&')
+      .replace(/&lt;/g, '<')
+      .replace(/&gt;/g, '>')
+      .replace(/&quot;/g, '"')
+      .replace(/&#x27;/gi, "'")
+      .replace(/&#39;/g, "'");
+  }
+  function extractRedditMedia(d) {
+    const post_hint = d?.post_hint || '';
+    const url_overridden_by_dest = d?.url_overridden_by_dest || '';
+    const preview_image_url = decodeHtml(d?.preview?.images?.[0]?.source?.url || '');
+    const gallery_urls = [];
+    const items = d?.gallery_data?.items;
+    const meta = d?.media_metadata;
+    if (Array.isArray(items) && meta) {
+      for (const it of items) {
+        const m = it && meta[it.media_id];
+        const u = m?.s?.u;
+        if (u) gallery_urls.push(decodeHtml(u));
+      }
+    }
+    return { post_hint, url_overridden_by_dest, preview_image_url, gallery_urls };
+  }
+  const res = await fetch('/r/all.json?limit=\${{ args.limit }}&raw_json=1', { credentials: 'include' });
   const j = await res.json();
-  return j?.data?.children || [];
+  return (j?.data?.children || []).map(c => ({
+    title: c.data.title,
+    subreddit: c.data.subreddit_name_prefixed,
+    author: c.data.author,
+    upvotes: c.data.score,
+    comments: c.data.num_comments,
+    url: 'https://www.reddit.com' + c.data.permalink,
+    ...extractRedditMedia(c.data),
+  }));
 })()
 ` },
         { map: {
-                title: '${{ item.data.title }}',
-                subreddit: '${{ item.data.subreddit_name_prefixed }}',
-                author: '${{ item.data.author }}',
-                upvotes: '${{ item.data.score }}',
-                comments: '${{ item.data.num_comments }}',
-                url: 'https://www.reddit.com${{ item.data.permalink }}',
+                title: '${{ item.title }}',
+                subreddit: '${{ item.subreddit }}',
+                author: '${{ item.author }}',
+                upvotes: '${{ item.upvotes }}',
+                comments: '${{ item.comments }}',
+                url: '${{ item.url }}',
+                post_hint: '${{ item.post_hint }}',
+                url_overridden_by_dest: '${{ item.url_overridden_by_dest }}',
+                preview_image_url: '${{ item.preview_image_url }}',
+                gallery_urls: '${{ item.gallery_urls }}',
             } },
         { limit: '${{ args.limit }}' },
     ],

package/clis/reddit/frontpage.test.js

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './frontpage.js';
+
+describe('reddit frontpage adapter', () => {
+  const command = getRegistry().get('reddit/frontpage');
+
+  it('exposes the full frontpage shape including the 4 media columns', () => {
+    expect(command?.columns).toEqual([
+      'title', 'subreddit', 'author', 'upvotes', 'comments', 'url',
+      'post_hint', 'url_overridden_by_dest', 'preview_image_url', 'gallery_urls',
+    ]);
+  });
+
+  it('shapes children into the intermediate-object pattern with media spread in', () => {
+    // Refactored from item.data.* templating to a uniform pre-shaped object
+    // so gallery_urls (array-valued) can be set directly in evaluate.
+    expect(command?.pipeline?.[1]?.evaluate).toContain('function extractRedditMedia');
+    expect(command?.pipeline?.[1]?.evaluate).toContain('...extractRedditMedia(c.data)');
+    expect(command?.pipeline?.[1]?.evaluate).toContain('/r/all.json?limit=${{ args.limit }}&raw_json=1');
+    expect(command?.pipeline?.[2]?.map).toMatchObject({
+      title: '${{ item.title }}',
+      subreddit: '${{ item.subreddit }}',
+      author: '${{ item.author }}',
+      upvotes: '${{ item.upvotes }}',
+      comments: '${{ item.comments }}',
+      url: '${{ item.url }}',
+      post_hint: '${{ item.post_hint }}',
+      url_overridden_by_dest: '${{ item.url_overridden_by_dest }}',
+      preview_image_url: '${{ item.preview_image_url }}',
+      gallery_urls: '${{ item.gallery_urls }}',
+    });
+  });
+});

package/clis/reddit/home.js

@@ -15,6 +15,35 @@ export function parseRedditHomeLimit(raw) {
     return n;
 }
 
+export function decodeRedditHtml(value) {
+    if (typeof value !== 'string' || !value) return '';
+    return value
+        .replace(/&/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#x27;/gi, "'")
+        .replace(/&#39;/g, "'");
+}
+
+export function extractRedditMedia(d) {
+    const galleryUrls = [];
+    const items = d?.gallery_data?.items;
+    const meta = d?.media_metadata;
+    if (Array.isArray(items) && meta && typeof meta === 'object') {
+        for (const item of items) {
+            const url = meta[item?.media_id]?.s?.u;
+            if (typeof url === 'string' && url) galleryUrls.push(decodeRedditHtml(url));
+        }
+    }
+    return {
+        post_hint: typeof d?.post_hint === 'string' ? d.post_hint : '',
+        url_overridden_by_dest: decodeRedditHtml(d?.url_overridden_by_dest || ''),
+        preview_image_url: decodeRedditHtml(d?.preview?.images?.[0]?.source?.url || ''),
+        gallery_urls: galleryUrls,
+    };
+}
+
 cli({
     site: 'reddit',
     name: 'home',
@@ -26,7 +55,7 @@ cli({
     args: [
         { name: 'limit', type: 'int', default: 25, help: `Number of posts (1–${REDDIT_HOME_MAX_LIMIT})` },
     ],
-    columns: ['rank', 'title', 'subreddit', 'score', 'comments', 'postId', 'author', 'url'],
+    columns: ['rank', 'title', 'subreddit', 'score', 'comments', 'postId', 'author', 'url', 'post_hint', 'url_overridden_by_dest', 'preview_image_url', 'gallery_urls'],
     func: async (page, kwargs) => {
         const limit = parseRedditHomeLimit(kwargs.limit);
         await page.goto('https://www.reddit.com');
@@ -103,6 +132,7 @@ cli({
                 postId: d.id,
                 author: typeof d.author === 'string' ? d.author : null,
                 url: d.permalink ? 'https://www.reddit.com' + d.permalink : null,
+                ...extractRedditMedia(d),
             });
         }
         if (rows.length === 0) {

package/clis/reddit/home.test.js

@@ -1,7 +1,7 @@
 import { describe, expect, it, vi } from 'vitest';
 import { getRegistry } from '@jackwener/opencli/registry';
 import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
-import { parseRedditHomeLimit } from './home.js';
+import { extractRedditMedia, parseRedditHomeLimit } from './home.js';
 import './home.js';
 
 function makePage(result) {
@@ -33,7 +33,10 @@ describe('reddit home command', () => {
         expect(command).toBeDefined();
         expect(command.access).toBe('read');
         expect(command.browser).toBe(true);
-        expect(command.columns).toEqual(['rank', 'title', 'subreddit', 'score', 'comments', 'postId', 'author', 'url']);
+        expect(command.columns).toEqual([
+            'rank', 'title', 'subreddit', 'score', 'comments', 'postId', 'author', 'url',
+            'post_hint', 'url_overridden_by_dest', 'preview_image_url', 'gallery_urls',
+        ]);
     });
 
     it('parseRedditHomeLimit accepts [1,100] and rejects out-of-range / non-integer without silent clamp', () => {
@@ -81,20 +84,60 @@ describe('reddit home command', () => {
             {
                 rank: 1, title: 'Title for a1', subreddit: 'r/dummy', score: 100, comments: 10,
                 postId: 'a1', author: 'someone', url: 'https://www.reddit.com/r/dummy/comments/a1/title/',
+                post_hint: '', url_overridden_by_dest: '', preview_image_url: '', gallery_urls: [],
             },
             {
                 rank: 2, title: 'Title for b2', subreddit: 'r/dummy', score: 250, comments: 42,
                 postId: 'b2', author: 'someone', url: 'https://www.reddit.com/r/dummy/comments/b2/title/',
+                post_hint: '', url_overridden_by_dest: '', preview_image_url: '', gallery_urls: [],
             },
         ]);
         // Row shape must match declared columns exactly.
         for (const row of rows) {
             expect(Object.keys(row).sort()).toEqual(
-                ['author', 'comments', 'postId', 'rank', 'score', 'subreddit', 'title', 'url'],
+                [
+                    'author', 'comments', 'gallery_urls', 'postId', 'post_hint', 'preview_image_url',
+                    'rank', 'score', 'subreddit', 'title', 'url', 'url_overridden_by_dest',
+                ],
             );
         }
     });
 
+    it('surfaces media route fields from the personalized home feed', async () => {
+        const entries = [makeEntry('a1', {
+            post_hint: 'image',
+            url_overridden_by_dest: 'https://i.redd.it/a.jpg',
+            preview: {
+                images: [{ source: { url: 'https://preview.redd.it/a.jpg?x=1&y=2' } }],
+            },
+            gallery_data: { items: [{ media_id: 'm2' }, { media_id: 'm1' }] },
+            media_metadata: {
+                m1: { s: { u: 'https://preview.redd.it/m1.jpg?x=1&y=1' } },
+                m2: { s: { u: 'https://preview.redd.it/m2.jpg?x=1&y=2' } },
+            },
+        })];
+        const rows = await command.func(makePage({ kind: 'ok', entries }), { limit: 25 });
+
+        expect(rows[0]).toMatchObject({
+            post_hint: 'image',
+            url_overridden_by_dest: 'https://i.redd.it/a.jpg',
+            preview_image_url: 'https://preview.redd.it/a.jpg?x=1&y=2',
+            gallery_urls: [
+                'https://preview.redd.it/m2.jpg?x=1&y=2',
+                'https://preview.redd.it/m1.jpg?x=1&y=1',
+            ],
+        });
+    });
+
+    it('extractRedditMedia tolerates missing media without throwing', () => {
+        expect(extractRedditMedia({ is_self: true })).toEqual({
+            post_hint: '',
+            url_overridden_by_dest: '',
+            preview_image_url: '',
+            gallery_urls: [],
+        });
+    });
+
     it('applies the post-fetch limit slice (defence in depth vs Reddit overshoot)', async () => {
         const entries = Array.from({ length: 30 }, (_, i) => makeEntry(`p${i}`));
         const rows = await command.func(makePage({ kind: 'ok', entries }), { limit: 5 });

package/clis/reddit/hot.js

@@ -13,10 +13,36 @@ cli({
         },
         { name: 'limit', type: 'int', default: 20, help: 'Number of posts' },
     ],
-    columns: ['rank', 'title', 'subreddit', 'score', 'comments', 'postId', 'author', 'url'],
+    columns: ['rank', 'title', 'subreddit', 'score', 'comments', 'postId', 'author', 'url', 'post_hint', 'url_overridden_by_dest', 'preview_image_url', 'gallery_urls'],
     pipeline: [
         { navigate: 'https://www.reddit.com' },
         { evaluate: `(async () => {
+  function decodeHtml(s) {
+    if (typeof s !== 'string' || !s) return '';
+    return s
+      .replace(/&/g, '&')
+      .replace(/&lt;/g, '<')
+      .replace(/&gt;/g, '>')
+      .replace(/&quot;/g, '"')
+      .replace(/&#x27;/gi, "'")
+      .replace(/&#39;/g, "'");
+  }
+  function extractRedditMedia(d) {
+    const post_hint = d?.post_hint || '';
+    const url_overridden_by_dest = d?.url_overridden_by_dest || '';
+    const preview_image_url = decodeHtml(d?.preview?.images?.[0]?.source?.url || '');
+    const gallery_urls = [];
+    const items = d?.gallery_data?.items;
+    const meta = d?.media_metadata;
+    if (Array.isArray(items) && meta) {
+      for (const it of items) {
+        const m = it && meta[it.media_id];
+        const u = m?.s?.u;
+        if (u) gallery_urls.push(decodeHtml(u));
+      }
+    }
+    return { post_hint, url_overridden_by_dest, preview_image_url, gallery_urls };
+  }
   const sub = \${{ args.subreddit | json }};
   const path = sub ? '/r/' + sub + '/hot.json' : '/hot.json';
   const limit = \${{ args.limit }};
@@ -32,6 +58,7 @@ cli({
     author: c.data.author,
     postId: c.data.id,
     url: 'https://www.reddit.com' + c.data.permalink,
+    ...extractRedditMedia(c.data),
   }));
 })()
 ` },
@@ -44,6 +71,10 @@ cli({
                 postId: '${{ item.postId }}',
                 author: '${{ item.author }}',
                 url: '${{ item.url }}',
+                post_hint: '${{ item.post_hint }}',
+                url_overridden_by_dest: '${{ item.url_overridden_by_dest }}',
+                preview_image_url: '${{ item.preview_image_url }}',
+                gallery_urls: '${{ item.gallery_urls }}',
             } },
         { limit: '${{ args.limit }}' },
     ],

package/clis/reddit/hot.test.js

@@ -6,7 +6,10 @@ describe('reddit hot adapter', () => {
   const command = getRegistry().get('reddit/hot');
 
   it('registers postId, author, and url columns in the hot-list shape', () => {
-    expect(command?.columns).toEqual(['rank', 'title', 'subreddit', 'score', 'comments', 'postId', 'author', 'url']);
+    expect(command?.columns).toEqual([
+      'rank', 'title', 'subreddit', 'score', 'comments', 'postId', 'author', 'url',
+      'post_hint', 'url_overridden_by_dest', 'preview_image_url', 'gallery_urls',
+    ]);
     expect(command?.pipeline?.[1]?.evaluate).toContain('postId: c.data.id');
     expect(command?.pipeline?.[1]?.evaluate).toContain("'https://www.reddit.com' + c.data.permalink");
     expect(command?.pipeline?.[2]?.map).toMatchObject({
@@ -15,4 +18,15 @@ describe('reddit hot adapter', () => {
       url: '${{ item.url }}',
     });
   });
+
+  it('surfaces post_hint, url_overridden_by_dest, preview_image_url, gallery_urls via extractRedditMedia', () => {
+    expect(command?.pipeline?.[1]?.evaluate).toContain('function extractRedditMedia');
+    expect(command?.pipeline?.[1]?.evaluate).toContain('...extractRedditMedia(c.data)');
+    expect(command?.pipeline?.[2]?.map).toMatchObject({
+      post_hint: '${{ item.post_hint }}',
+      url_overridden_by_dest: '${{ item.url_overridden_by_dest }}',
+      preview_image_url: '${{ item.preview_image_url }}',
+      gallery_urls: '${{ item.gallery_urls }}',
+    });
+  });
 });