@jackwener/opencli 1.7.21 → 1.8.0

package/clis/reddit/search.js

@@ -29,10 +29,36 @@ cli({
         },
         { name: 'limit', type: 'int', default: 15 },
     ],
-    columns: ['title', 'subreddit', 'author', 'score', 'comments', 'url'],
+    columns: ['id', 'title', 'subreddit', 'author', 'score', 'comments', 'url', 'created_utc', 'selftext', '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 q = encodeURIComponent(\${{ args.query | json }});
   const sub = \${{ args.subreddit | json }};
   const sort = \${{ args.sort | json }};
@@ -44,22 +70,33 @@ cli({
   const res = await fetch(basePath + '?' + params, { credentials: 'include' });
   const d = await res.json();
   return (d?.data?.children || []).map(c => ({
+    id: c.data.id,
     title: c.data.title,
     subreddit: c.data.subreddit_name_prefixed,
     author: c.data.author,
     score: c.data.score,
     comments: c.data.num_comments,
     url: 'https://www.reddit.com' + c.data.permalink,
+    created_utc: c.data.created_utc,
+    selftext: c.data.selftext || '',
+    ...extractRedditMedia(c.data),
   }));
 })()
 ` },
         { map: {
+                id: '${{ item.id }}',
                 title: '${{ item.title }}',
                 subreddit: '${{ item.subreddit }}',
                 author: '${{ item.author }}',
                 score: '${{ item.score }}',
                 comments: '${{ item.comments }}',
                 url: '${{ item.url }}',
+                created_utc: '${{ item.created_utc }}',
+                selftext: '${{ item.selftext }}',
+                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/search.test.js

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './search.js';
+
+describe('reddit search adapter', () => {
+  const command = getRegistry().get('reddit/search');
+
+  it('exposes the full search-result shape including the 4 media columns', () => {
+    expect(command?.columns).toEqual([
+      'id', 'title', 'subreddit', 'author', 'score', 'comments', 'url',
+      'created_utc', 'selftext',
+      'post_hint', 'url_overridden_by_dest', 'preview_image_url', 'gallery_urls',
+    ]);
+  });
+
+  it('surfaces media via extractRedditMedia in evaluate + map', () => {
+    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 }}',
+    });
+  });
+});

package/clis/reddit/subreddit.js

@@ -23,10 +23,36 @@ cli({
         },
         { name: 'limit', type: 'int', default: 15 },
     ],
-    columns: ['title', 'author', 'upvotes', 'comments', 'url'],
+    columns: ['id', 'title', 'subreddit', 'author', 'upvotes', 'comments', 'url', 'created_utc', 'selftext', '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 };
+  }
   let sub = \${{ args.name | json }};
   if (sub.startsWith('r/')) sub = sub.slice(2);
   const sort = \${{ args.sort | json }};
@@ -38,15 +64,34 @@ cli({
   }
   const res = await fetch(url, { credentials: 'include' });
   const j = await res.json();
-  return j?.data?.children || [];
+  return (j?.data?.children || []).map(c => ({
+    id: c.data.id,
+    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,
+    created_utc: c.data.created_utc,
+    selftext: c.data.selftext || '',
+    ...extractRedditMedia(c.data),
+  }));
 })()
 ` },
         { map: {
-                title: '${{ item.data.title }}',
-                author: '${{ item.data.author }}',
-                upvotes: '${{ item.data.score }}',
-                comments: '${{ item.data.num_comments }}',
-                url: 'https://www.reddit.com${{ item.data.permalink }}',
+                id: '${{ item.id }}',
+                title: '${{ item.title }}',
+                subreddit: '${{ item.subreddit }}',
+                author: '${{ item.author }}',
+                upvotes: '${{ item.upvotes }}',
+                comments: '${{ item.comments }}',
+                url: '${{ item.url }}',
+                created_utc: '${{ item.created_utc }}',
+                selftext: '${{ item.selftext }}',
+                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/subreddit.test.js

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './subreddit.js';
+
+describe('reddit subreddit adapter', () => {
+  const command = getRegistry().get('reddit/subreddit');
+
+  it('exposes the full subreddit-list shape including the 4 media columns', () => {
+    expect(command?.columns).toEqual([
+      'id', 'title', 'subreddit', 'author', 'upvotes', 'comments', 'url',
+      'created_utc', 'selftext',
+      'post_hint', 'url_overridden_by_dest', 'preview_image_url', 'gallery_urls',
+    ]);
+  });
+
+  it('shapes children into the intermediate-object pattern with media spread in', () => {
+    expect(command?.pipeline?.[1]?.evaluate).toContain('function extractRedditMedia');
+    expect(command?.pipeline?.[1]?.evaluate).toContain('...extractRedditMedia(c.data)');
+    expect(command?.pipeline?.[2]?.map).toMatchObject({
+      title: '${{ item.title }}',
+      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/subscribed.js

@@ -0,0 +1,165 @@
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { BROWSER_JSON_SNIFF_FN, throwIfLoginWall } from '@jackwener/opencli/utils';
+
+export const REDDIT_SUBSCRIBED_MAX_LIMIT = 1000;
+
+export function parseRedditSubscribedLimit(raw) {
+    if (raw === undefined || raw === null || raw === '') return 100;
+    const n = Number(raw);
+    if (!Number.isFinite(n) || !Number.isInteger(n) || n < 1 || n > REDDIT_SUBSCRIBED_MAX_LIMIT) {
+        throw new ArgumentError(
+            `limit must be an integer in [1, ${REDDIT_SUBSCRIBED_MAX_LIMIT}].`,
+            `Got: ${raw}`,
+        );
+    }
+    return n;
+}
+
+export function unwrapEvaluateResult(payload) {
+    if (payload && typeof payload === 'object' && !Array.isArray(payload) && 'session' in payload && 'data' in payload) {
+        return payload.data;
+    }
+    return payload;
+}
+
+function mapSubredditRow(entry, index) {
+    const data = entry?.data;
+    if (!data || typeof data !== 'object') {
+        throw new CommandExecutionError(`Reddit subscriptions row ${index + 1} was missing data.`);
+    }
+    const fullname = typeof data.name === 'string' ? data.name : '';
+    const id = fullname.startsWith('t5_')
+        ? fullname
+        : (entry?.kind === 't5' && typeof data.id === 'string' && data.id ? `t5_${data.id}` : '');
+    const displayName = typeof data.display_name === 'string' && data.display_name
+        ? data.display_name
+        : '';
+    const subreddit = typeof data.display_name_prefixed === 'string' && data.display_name_prefixed
+        ? data.display_name_prefixed
+        : (displayName ? `r/${displayName}` : '');
+    const path = typeof data.url === 'string' && data.url.startsWith('/r/') ? data.url : '';
+    if (!id || !displayName || !subreddit || !path) {
+        throw new CommandExecutionError(`Reddit subscriptions row ${index + 1} was missing subreddit identity.`);
+    }
+    return {
+        id,
+        subreddit,
+        title: typeof data.title === 'string' ? data.title : '',
+        subscribers: typeof data.subscribers === 'number' ? data.subscribers : null,
+        description: typeof data.public_description === 'string' ? data.public_description.slice(0, 200) : '',
+        url: 'https://www.reddit.com' + path,
+    };
+}
+
+cli({
+    site: 'reddit',
+    name: 'subscribed',
+    description: 'List subreddits you are subscribed to',
+    access: 'read',
+    domain: 'reddit.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'limit', type: 'int', default: 100, help: `Max subreddits to return (1-${REDDIT_SUBSCRIBED_MAX_LIMIT}, auto-paginates)` },
+    ],
+    columns: ['id', 'subreddit', 'title', 'subscribers', 'description', 'url'],
+    func: async (page, kwargs) => {
+        const limit = parseRedditSubscribedLimit(kwargs.limit);
+        if (!page)
+            throw new CommandExecutionError('Browser session required');
+        await page.goto('https://www.reddit.com');
+        const result = unwrapEvaluateResult(await page.evaluate(`(async () => {
+      ${BROWSER_JSON_SNIFF_FN}
+      try {
+        // fetchJsonOrLoginWall sniffs HTML responses (login wall / WAF / rate-limit
+        // page) and returns a structured { __loginWall, status, url, ... } sentinel
+        // instead of letting JSON.parse blow up with "Unexpected token '<'".
+        const me = await fetchJsonOrLoginWall('/api/me.json?raw_json=1', { credentials: 'include' });
+        if (me && me.__loginWall) {
+          return { kind: 'login-wall', sentinel: me, where: '/api/me.json' };
+        }
+        if (me && me.error === 401 || me && me.error === 403) {
+          return { kind: 'auth', detail: 'Reddit /api/me.json returned HTTP ' + me.error };
+        }
+        if (me && me.error) {
+          return { kind: 'http', httpStatus: me.error, where: '/api/me.json' };
+        }
+        const username = me?.data?.name || me?.name;
+        if (!username) return { kind: 'auth', detail: 'Not logged in to reddit.com (no identity in /api/me.json)' };
+
+        const target = ${JSON.stringify(limit)};
+        const PAGE_SIZE = 100;
+        const out = [];
+        let after = null;
+        const seenCursors = new Set();
+        for (let pageIndex = 0; pageIndex < 20 && out.length < target; pageIndex++) {
+          const remaining = target - out.length;
+          const pageLimit = Math.min(PAGE_SIZE, remaining);
+          const url = '/subreddits/mine/subscriptions.json?limit=' + pageLimit
+            + '&raw_json=1'
+            + (after ? '&after=' + encodeURIComponent(after) : '');
+          const d = await fetchJsonOrLoginWall(url, { credentials: 'include' });
+          if (d && d.__loginWall) {
+            return { kind: 'login-wall', sentinel: d, where: url };
+          }
+          if (d && (d.error === 401 || d.error === 403)) {
+            return { kind: 'auth', detail: 'Reddit subscriptions endpoint returned HTTP ' + d.error };
+          }
+          if (d && d.error) return { kind: 'http', httpStatus: d.error, where: url };
+          const children = d?.data?.children;
+          if (!Array.isArray(children)) {
+            return { kind: 'malformed', detail: 'Reddit subscriptions payload was missing data.children.' };
+          }
+          for (const child of children) {
+            if (out.length >= target) break;
+            out.push(child);
+          }
+          const next = d?.data?.after ?? null;
+          if (next !== null && typeof next !== 'string') {
+            return { kind: 'malformed', detail: 'Reddit subscriptions payload had a malformed after cursor.' };
+          }
+          if (out.length >= target || !next) break;
+          if (children.length === 0) {
+            return { kind: 'malformed', detail: 'Reddit subscriptions page was empty but returned an after cursor.' };
+          }
+          if (seenCursors.has(next)) {
+            return { kind: 'malformed', detail: 'Reddit subscriptions repeated pagination cursor ' + next + '.' };
+          }
+          seenCursors.add(next);
+          after = next;
+        }
+        if (out.length < target && after) {
+          return { kind: 'malformed', detail: 'Reddit subscriptions pagination exceeded the safety cap before satisfying the requested limit.' };
+        }
+        return { kind: 'ok', entries: out };
+      } catch (e) {
+        return { kind: 'exception', detail: String(e && e.message || e) };
+      }
+    })()`));
+        if (result?.kind === 'login-wall') {
+            // Convert the browser-side sentinel into a typed LoginWallError on the Node side.
+            throwIfLoginWall(result.sentinel, { url: result.where });
+        }
+        if (result?.kind === 'auth') {
+            throw new AuthRequiredError('reddit.com', result.detail);
+        }
+        if (result?.kind === 'http') {
+            throw new CommandExecutionError(`HTTP ${result.httpStatus} from ${result.where}`);
+        }
+        if (result?.kind === 'malformed') {
+            throw new CommandExecutionError(result.detail);
+        }
+        if (result?.kind === 'exception') {
+            throw new CommandExecutionError(`subscribed failed: ${result.detail}`);
+        }
+        if (result?.kind !== 'ok' || !Array.isArray(result.entries)) {
+            throw new CommandExecutionError(`Unexpected result from reddit subscribed: ${JSON.stringify(result)}`);
+        }
+        const rows = result.entries.slice(0, limit).map((entry, index) => mapSubredditRow(entry, index));
+        if (rows.length === 0) {
+            throw new EmptyResultError('Reddit returned no subscribed subreddits for the logged-in account.');
+        }
+        return rows;
+    }
+});

package/clis/reddit/subscribed.test.js

@@ -0,0 +1,168 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError, LoginWallError } from '@jackwener/opencli/errors';
+import { parseRedditSubscribedLimit, unwrapEvaluateResult } from './subscribed.js';
+import './subscribed.js';
+
+function subredditThing(id, overrides = {}) {
+    const displayName = `sub${id}`;
+    return {
+        kind: 't5',
+        data: {
+            id,
+            name: `t5_${id}`,
+            display_name: displayName,
+            display_name_prefixed: `r/${displayName}`,
+            title: `Sub ${id}`,
+            subscribers: 1000,
+            public_description: `Description ${id}`,
+            url: `/r/${displayName}/`,
+            ...overrides,
+        },
+    };
+}
+
+function makePage(result) {
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockResolvedValue(result),
+    };
+}
+
+describe('reddit subscribed adapter', () => {
+    const command = getRegistry().get('reddit/subscribed');
+
+    it('registers with id-bearing output columns', () => {
+        expect(command).toBeDefined();
+        expect(command.columns).toEqual(['id', 'subreddit', 'title', 'subscribers', 'description', 'url']);
+    });
+
+    it('parseRedditSubscribedLimit rejects out-of-range values without silent clamp', () => {
+        expect(parseRedditSubscribedLimit(undefined)).toBe(100);
+        expect(parseRedditSubscribedLimit(null)).toBe(100);
+        expect(parseRedditSubscribedLimit('')).toBe(100);
+        expect(parseRedditSubscribedLimit(1)).toBe(1);
+        expect(parseRedditSubscribedLimit(1000)).toBe(1000);
+        for (const bad of [0, -1, 1001, 1.5, NaN, 'abc']) {
+            expect(() => parseRedditSubscribedLimit(bad)).toThrow(ArgumentError);
+        }
+    });
+
+    it('rejects bad limit before navigation', async () => {
+        const page = makePage({ kind: 'ok', entries: [] });
+        await expect(command.func(page, { limit: 1001 })).rejects.toBeInstanceOf(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+        expect(page.evaluate).not.toHaveBeenCalled();
+    });
+
+    it('unwraps Browser Bridge envelopes', () => {
+        const inner = { kind: 'ok', entries: [] };
+        expect(unwrapEvaluateResult({ session: 'browser:default', data: inner })).toBe(inner);
+        expect(unwrapEvaluateResult(inner)).toBe(inner);
+    });
+
+    it('returns subscribed subreddits from the browser-evaluated payload', async () => {
+        const page = makePage({
+            kind: 'ok',
+            entries: [
+                subredditThing('abc', {
+                    display_name: 'programming',
+                    display_name_prefixed: 'r/programming',
+                    title: 'Programming',
+                    subscribers: 6000000,
+                    public_description: 'All things code',
+                    url: '/r/programming/',
+                }),
+                subredditThing('def', {
+                    display_name: 'MachineLearning',
+                    display_name_prefixed: 'r/MachineLearning',
+                    title: 'Machine Learning',
+                    subscribers: 3000000,
+                    public_description: 'ML research',
+                    url: '/r/MachineLearning/',
+                }),
+            ],
+        });
+        const result = await command.func(page, { limit: 100 });
+        expect(page.goto).toHaveBeenCalledWith('https://www.reddit.com');
+        expect(result).toEqual([
+            { id: 't5_abc', subreddit: 'r/programming', title: 'Programming', subscribers: 6000000, description: 'All things code', url: 'https://www.reddit.com/r/programming/' },
+            { id: 't5_def', subreddit: 'r/MachineLearning', title: 'Machine Learning', subscribers: 3000000, description: 'ML research', url: 'https://www.reddit.com/r/MachineLearning/' },
+        ]);
+    });
+
+    it('throws AuthRequiredError when not logged in', async () => {
+        await expect(command.func(makePage({ kind: 'auth', detail: 'login required' }), { limit: 100 }))
+            .rejects.toBeInstanceOf(AuthRequiredError);
+    });
+
+    it('surfaces HTTP, malformed, exception, and unexpected envelopes as CommandExecutionError', async () => {
+        await expect(command.func(makePage({ kind: 'http', httpStatus: 429, where: '/subreddits/mine/subscriptions.json?limit=100' }), { limit: 100 }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+        await expect(command.func(makePage({ kind: 'malformed', detail: 'missing data.children' }), { limit: 100 }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+        await expect(command.func(makePage({ kind: 'exception', detail: 'network' }), { limit: 100 }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+        await expect(command.func(makePage({ ok: true }), { limit: 100 }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('converts a browser-side login-wall sentinel into a typed LoginWallError', async () => {
+        const sentinel = {
+            __loginWall: true,
+            status: 200,
+            url: 'https://www.reddit.com/api/me.json?raw_json=1',
+            contentType: 'text/html; charset=utf-8',
+            bodyPreview: '<!DOCTYPE html><html><head><title>reddit.com: over 18?</title>',
+        };
+        const page = makePage({ kind: 'login-wall', sentinel, where: '/api/me.json' });
+        try {
+            await command.func(page, { limit: 100 });
+            throw new Error('expected LoginWallError, got success');
+        } catch (err) {
+            expect(err).toBeInstanceOf(LoginWallError);
+            expect(err.status).toBe(200);
+            expect(err.url).toBe('/api/me.json');
+            expect(err.bodyPreview).toContain('reddit.com: over 18');
+        }
+    });
+
+    it('throws EmptyResultError for a valid empty subscriptions list', async () => {
+        await expect(command.func(makePage({ kind: 'ok', entries: [] }), { limit: 100 }))
+            .rejects.toBeInstanceOf(EmptyResultError);
+    });
+
+    it('throws CommandExecutionError when rows lack subreddit identity', async () => {
+        await expect(command.func(makePage({ kind: 'ok', entries: [subredditThing('abc', { name: '', id: '', display_name: '', display_name_prefixed: '', url: '' })] }), { limit: 100 }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('does not synthesize subreddit identity from a non-t5 listing item', async () => {
+        await expect(command.func(makePage({
+            kind: 'ok',
+            entries: [{
+                kind: 't3',
+                data: {
+                    id: 'abc',
+                    display_name: 'notasub',
+                    display_name_prefixed: 'r/notasub',
+                    url: '/r/notasub/',
+                },
+            }],
+        }), { limit: 100 })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('respects --limit by slicing the final result', async () => {
+        const page = makePage({ kind: 'ok', entries: Array.from({ length: 5 }, (_, i) => subredditThing(String(i))) });
+        const result = await command.func(page, { limit: 3 });
+        expect(result).toHaveLength(3);
+        expect(result[0].subreddit).toBe('r/sub0');
+    });
+
+    it('embeds the validated limit literally in the browser script', async () => {
+        const page = makePage({ kind: 'ok', entries: [subredditThing('x')] });
+        await command.func(page, { limit: 7 });
+        const script = page.evaluate.mock.calls[0][0];
+        expect(script).toContain('const target = 7');
+    });
+});

package/clis/reddit/upvoted.js

@@ -30,7 +30,7 @@ cli({
         });
         const d = await res.json();
         return (d?.data?.children || []).map(c => ({
-          title: c.data.title || '-',
+          title: c.data.title || '',
           subreddit: c.data.subreddit_name_prefixed || 'r/' + (c.data.subreddit || '?'),
           score: c.data.score || 0,
           comments: c.data.num_comments || 0,