@jackwener/opencli 1.7.22 → 1.8.1

package/clis/twitter/quote.js

@@ -62,10 +62,15 @@ async function submitQuote(page, text, tweetId) {
                 return { ok: false, message: 'Quote target did not render in the composer. The source tweet may be deleted or restricted.' };
             }
 
-            const buttons = Array.from(
-                document.querySelectorAll('[data-testid="tweetButton"], [data-testid="tweetButtonInline"]')
-            );
-            const btn = buttons.find((el) => visible(el) && !el.disabled && el.getAttribute('aria-disabled') !== 'true');
+            let btn = null;
+            for (let i = 0; i < 30; i++) {
+                const buttons = Array.from(
+                    document.querySelectorAll('[data-testid="tweetButton"], [data-testid="tweetButtonInline"]')
+                );
+                btn = buttons.find((el) => visible(el) && !el.disabled && el.getAttribute('aria-disabled') !== 'true');
+                if (btn) break;
+                await new Promise(r => setTimeout(r, 500));
+            }
             if (!btn) {
                 return { ok: false, message: 'Tweet button is disabled or not found.' };
             }

package/clis/twitter/reply.js

@@ -90,19 +90,22 @@ async function insertReplyText(page, text) {
 }
 
 async function clickReplyButton(page) {
-    return page.evaluate(`(() => {
+    const iterations = Math.ceil(SUBMIT_TIMEOUT_MS / SUBMIT_POLL_MS);
+    return page.evaluate(`(async () => {
       try {
           const visible = (el) => !!el && (el.offsetParent !== null || el.getClientRects().length > 0);
-          const buttons = Array.from(
-              document.querySelectorAll('[data-testid="tweetButton"], [data-testid="tweetButtonInline"]')
-          );
-          const btn = buttons.find((el) => visible(el) && !el.disabled && el.getAttribute('aria-disabled') !== 'true');
-          if (!btn) {
-              return { ok: false, message: 'Reply button is disabled or not found.' };
+          for (let i = 0; i < ${JSON.stringify(iterations)}; i++) {
+              const buttons = Array.from(
+                  document.querySelectorAll('[data-testid="tweetButton"], [data-testid="tweetButtonInline"]')
+              );
+              const btn = buttons.find((el) => visible(el) && !el.disabled && el.getAttribute('aria-disabled') !== 'true');
+              if (btn) {
+                  btn.click();
+                  return { ok: true };
+              }
+              await new Promise(r => setTimeout(r, ${JSON.stringify(SUBMIT_POLL_MS)}));
           }
-
-          btn.click();
-          return { ok: true };
+          return { ok: false, message: 'Reply button is disabled or not found.' };
       } catch (e) {
           return { ok: false, message: e.toString() };
       }

package/clis/twitter/reply.test.js

@@ -1,6 +1,7 @@
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
+import { JSDOM } from 'jsdom';
 import { describe, expect, it, vi } from 'vitest';
 import { ArgumentError, CommandExecutionError } from '@jackwener/opencli/errors';
 import { getRegistry } from '@jackwener/opencli/registry';
@@ -193,4 +194,44 @@ describe('twitter image helpers (utils.js)', () => {
         expect(utilsTest.resolveImageExtension('https://example.com/no-ext', 'image/webp')).toBe('.webp');
         expect(utilsTest.resolveImageExtension('https://example.com/a.jpeg?x=1', null)).toBe('.jpeg');
     });
+
+    it('classifies CDP NotAllowed file-input failures as recoverable', () => {
+        expect(utilsTest.isRecoverableFileInputError(new Error('NotAllowedError: Not allowed'))).toBe(true);
+        expect(utilsTest.isRecoverableFileInputError(new Error('ProtocolError: not-allowed'))).toBe(true);
+        expect(utilsTest.isRecoverableFileInputError(new Error('Permission denied'))).toBe(false);
+    });
+
+    it('fails closed when a composer image preview never appears', async () => {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-twitter-helper-'));
+        const imagePath = path.join(tempDir, 'missing-preview.png');
+        fs.writeFileSync(imagePath, Buffer.from([0x89, 0x50, 0x4e, 0x47]));
+        const page = createPageMock([{ ok: false, message: 'Image upload timed out (30s).' }], {
+            setFileInput: vi.fn().mockResolvedValue(undefined),
+        });
+
+        await expect(utilsTest.attachComposerImage(page, imagePath)).rejects.toThrow('Image upload timed out');
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+
+    it('does not treat an empty attachments container as uploaded media', async () => {
+        const runMediaReadyProbe = async (html) => {
+            const dom = new JSDOM(`<!doctype html><body>${html}</body>`, {
+                url: 'https://x.com/compose/post',
+                runScripts: 'outside-only',
+            });
+            dom.window.setTimeout = (callback) => {
+                callback();
+                return 0;
+            };
+            const page = {
+                evaluate: vi.fn(async (script) => dom.window.eval(script)),
+            };
+            return utilsTest.waitForComposerMediaReady(page, 1);
+        };
+
+        await expect(runMediaReadyProbe('<div data-testid="attachments"></div>'))
+            .resolves.toMatchObject({ ok: false });
+        await expect(runMediaReadyProbe('<div data-testid="attachments"><img src="blob:https://x.com/1"></div>'))
+            .resolves.toMatchObject({ ok: true, previewCount: 1 });
+    });
 });

package/clis/twitter/search.js

@@ -1,6 +1,6 @@
 import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { extractMedia, normalizeTwitterGraphqlPayload, resolveTwitterOperationMetadata } from './shared.js';
+import { extractMedia, extractCard, extractQuotedTweet, normalizeTwitterGraphqlPayload, resolveTwitterOperationMetadata } from './shared.js';
 import { TWITTER_BEARER_TOKEN, applyTopByEngagement } from './utils.js';
 
 // ── Public-search operator surface ─────────────────────────────────────
@@ -212,15 +212,19 @@ function tweetToRow(result, seen) {
     if (!tweet?.rest_id || seen.has(tweet.rest_id)) return null;
     seen.add(tweet.rest_id);
     const tweetUser = tweet.core?.user_results?.result;
+    const bio = tweetUser?.legacy?.description || '';
     return {
         id: tweet.rest_id,
-        author: tweetUser?.core?.screen_name || tweetUser?.legacy?.screen_name || 'unknown',
+        author: tweetUser?.core?.screen_name || tweetUser?.legacy?.screen_name || '',
+        bio,
         text: tweet.note_tweet?.note_tweet_results?.result?.text || tweet.legacy?.full_text || '',
         created_at: tweet.legacy?.created_at || '',
         likes: tweet.legacy?.favorite_count || 0,
         views: tweet.views?.count || '0',
         url: `https://x.com/i/status/${tweet.rest_id}`,
         ...extractMedia(tweet.legacy),
+        card: extractCard(tweet),
+        quoted_tweet: extractQuotedTweet(tweet),
     };
 }
 
@@ -271,7 +275,7 @@ cli({
         { name: 'limit', type: 'int', default: 15, help: 'Maximum number of tweets to return (default 15). Result count after server-side filtering.' },
         { name: 'top-by-engagement', type: 'int', default: 0, help: 'When set to N>0, re-rank the results by weighted engagement (likes×1 + retweets×3 + replies×2 + bookmarks×5 + log10(views+1)×0.5) and return the top N. Default 0 keeps X\'s native ordering.' },
     ],
-    columns: ['id', 'author', 'text', 'created_at', 'likes', 'views', 'url', 'has_media', 'media_urls'],
+    columns: ['id', 'author', 'bio', 'text', 'created_at', 'likes', 'views', 'url', 'has_media', 'media_urls', 'card', 'quoted_tweet'],
     func: async (page, kwargs) => {
         const finalQuery = buildSearchQuery(kwargs.query, kwargs);
         if (!finalQuery) {

package/clis/twitter/search.test.js

@@ -44,6 +44,9 @@ describe('twitter search command', () => {
                                                                         core: {
                                                                             screen_name: 'alice',
                                                                         },
+                                                                        legacy: {
+                                                                            description: 'Search author bio',
+                                                                        },
                                                                     },
                                                                 },
                                                             },
@@ -68,6 +71,7 @@ describe('twitter search command', () => {
             {
                 id: '1',
                 author: 'alice',
+                bio: 'Search author bio',
                 text: 'hello world',
                 created_at: 'Thu Mar 26 10:30:00 +0000 2026',
                 likes: 7,
@@ -75,6 +79,8 @@ describe('twitter search command', () => {
                 url: 'https://x.com/i/status/1',
                 has_media: false,
                 media_urls: [],
+                card: null,
+                quoted_tweet: null,
             },
         ]);
         expect(page.getCookies).toHaveBeenCalledWith({ url: 'https://x.com' });
@@ -148,6 +154,40 @@ describe('twitter search command', () => {
         expect(result.map((row) => row.id)).toEqual(['1', '2', '3', '4', '5', '6', '7']);
         expect(page.evaluate).toHaveBeenCalledTimes(8);
     });
+
+    it('surfaces empty author when the tweet has no user screen_name', () => {
+        const payload = {
+            data: {
+                search_by_raw_query: {
+                    search_timeline: {
+                        timeline: {
+                            instructions: [{
+                                type: 'TimelineAddEntries',
+                                entries: [{
+                                    entryId: 'tweet-2',
+                                    content: {
+                                        itemContent: {
+                                            tweet_results: {
+                                                result: {
+                                                    rest_id: '2',
+                                                    legacy: { full_text: 'no author here', favorite_count: 0, created_at: '' },
+                                                    core: { user_results: { result: {} } },
+                                                },
+                                            },
+                                        },
+                                    },
+                                }],
+                            }],
+                        },
+                    },
+                },
+            },
+        };
+        const { rows } = parseSearchTimeline(payload, new Set());
+        expect(rows).toHaveLength(1);
+        expect(rows[0].author).toBe('');
+        expect(rows[0].id).toBe('2');
+    });
 });
 
 describe('twitter search filter helpers', () => {
@@ -340,4 +380,5 @@ describe('twitter search end-to-end with new filters', () => {
         const searchFetch = evaluate.mock.calls[1][0];
         expect(searchFetch).toContain('\\"rawQuery\\":\\"from:alice\\"');
     });
+
 });

package/clis/twitter/shared.js

@@ -155,6 +155,16 @@ export function unwrapBrowserResult(value) {
     return value;
 }
 
+function isEmptyObject(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 0;
+}
+
+export function looksLikePrivateTwitterTimeline(data) {
+    const result = data?.data?.user?.result;
+    if (!result || typeof result !== 'object') return false;
+    return Boolean(isEmptyObject(result.timeline) || isEmptyObject(result.timeline_v2?.timeline));
+}
+
 export function normalizeTwitterGraphqlPayload(value) {
     const unwrapped = unwrapBrowserResult(value);
     if (unwrapped?.data && typeof unwrapped.data === 'object') return unwrapped;
@@ -288,6 +298,148 @@ export function extractMedia(legacy) {
     }
     return { has_media: urls.length > 0, media_urls: urls };
 }
+
+/**
+ * Extract the link-preview card from a tweet's GraphQL response.
+ *
+ * Reads `tweet.card.legacy.{name, binding_values}` plus the expanded URL from
+ * the `tweet.legacy.entities.urls` entry matching the card's t.co URL.
+ * `binding_values` is an array of `{ key, value: { type, string_value, image_value: { url } } }`.
+ *
+ * Returns `null` when:
+ *   - the tweet has no card, OR
+ *   - the card is structurally empty (no landing URL AND no title/description),
+ *     which would be useless to downstream renderers.
+ *
+ * Otherwise returns a partial card object — missing fields are simply omitted
+ * (no `undefined` values in the output) so JSON consumers see a clean shape.
+ */
+export function extractCard(tweet) {
+    const cardLegacy = tweet?.card?.legacy;
+    if (!cardLegacy) return null;
+    const bindings = Array.isArray(cardLegacy.binding_values) ? cardLegacy.binding_values : [];
+    const byKey = new Map();
+    for (const b of bindings) {
+        if (b && typeof b.key === 'string') byKey.set(b.key, b.value);
+    }
+    const str = (key) => {
+        const v = byKey.get(key);
+        return typeof v?.string_value === 'string' && v.string_value.length > 0 ? v.string_value : undefined;
+    };
+    const img = (key) => {
+        const v = byKey.get(key);
+        const u = v?.image_value?.url;
+        return typeof u === 'string' && u.length > 0 ? u : undefined;
+    };
+    const title = str('title');
+    const description = str('description');
+    const domainBinding = str('domain');
+    const cardUrlBinding = str('card_url');
+    const image_url = img('thumbnail_image_large') || img('photo_image_full_size_large') || img('summary_photo_image_large');
+    const urlEntities = Array.isArray(tweet?.legacy?.entities?.urls)
+        ? tweet.legacy.entities.urls
+        : [];
+    const matchingEntity = cardUrlBinding
+        ? urlEntities.find((entity) => entity?.url === cardUrlBinding || entity?.expanded_url === cardUrlBinding)
+        : undefined;
+    const matchedExpandedUrl = matchingEntity?.expanded_url;
+    const url = (typeof matchedExpandedUrl === 'string' && matchedExpandedUrl.length > 0)
+        ? matchedExpandedUrl
+        : cardUrlBinding;
+    let domain = domainBinding;
+    if (!domain && url) {
+        try { domain = new URL(url).hostname; }
+        catch { /* malformed url — domain stays undefined */ }
+    }
+    if (!url && !title && !description) return null;
+    const out = { name: cardLegacy.name };
+    if (title) out.title = title;
+    if (description) out.description = description;
+    if (image_url) out.image_url = image_url;
+    if (url) out.url = url;
+    if (domain) out.domain = domain;
+    return out;
+}
+
+/**
+ * Extract the quoted tweet from a tweet's GraphQL response.
+ *
+ * A quote tweet is a tweet that embeds and comments on another tweet (distinct
+ * from a reply or retweet). The author writes new commentary and the embedded
+ * tweet renders as a card-like preview under the new tweet.
+ *
+ * GraphQL surfaces this as `tweet.quoted_status_result.result`, which contains
+ * the same `legacy / core / card / note_tweet` shape as the outer tweet — so
+ * we reuse `extractMedia` / `extractCard` on the nested object. Detection is
+ * gated by `legacy.is_quote_status === true` (plus the presence of the nested
+ * result) so we don't return junk on plain replies that share field shapes.
+ *
+ * Returns `null` when:
+ *   - the tweet is not a quote, OR
+ *   - the nested `quoted_status_result.result` is missing/empty/tombstoned.
+ *
+ * Only goes ONE level deep — a quote-of-a-quote returns its level-1 quoted
+ * tweet without further nesting. Recursing would explode payload size on
+ * threads where every reply re-quotes the original.
+ *
+ * The output shape is a deliberately small subset of the main tweet shape
+ * (id/author/name/text/created_at/url + media + card). Consumers that need
+ * counts or full author bio of the quoted tweet can re-fetch the quoted id
+ * via `twitter thread <id>` — keeping this slim avoids ballooning every
+ * timeline/list/search response by 2-3x.
+ */
+export function extractQuotedTweet(tweet) {
+    const legacy = tweet?.legacy;
+    if (!legacy?.is_quote_status) return null;
+    const q = tweet?.quoted_status_result?.result
+        ?? tweet?.legacy?.quoted_status_result?.result;
+    // `result` can be a tombstone (`__typename: 'TweetTombstone'`) or
+    // `'TweetUnavailable'` when the quoted tweet was deleted / privacy-restricted.
+    if (!q) return null;
+    // Nested `tweet` wrapper appears on TweetWithVisibilityResults — same
+    // shim that callers already do at the top level (`tw.tweet || tw`).
+    const qTw = q.tweet || q;
+    if (!qTw || typeof qTw !== 'object') return null;
+    const qLegacy = qTw.legacy && typeof qTw.legacy === 'object' ? qTw.legacy : {};
+    // `rest_id` is required — tombstoned / unavailable wrappers have neither
+    // rest_id nor legacy. Don't fall back to outer `legacy.quoted_status_id_str`:
+    // the id alone can't substitute for missing content (author/text/media all
+    // empty), so emitting a stub object would mislead downstream renderers into
+    // drawing an empty "quoted tweet" preview.
+    if (typeof qTw.rest_id !== 'string' || !qTw.rest_id.trim()) return null;
+    const qUser = qTw.core?.user_results?.result;
+    const qLegacyScreenName = qUser?.legacy?.screen_name;
+    const qCoreScreenName = qUser?.core?.screen_name;
+    const qScreenName = typeof qLegacyScreenName === 'string' && qLegacyScreenName.trim()
+        ? qLegacyScreenName.trim()
+        : (typeof qCoreScreenName === 'string' && qCoreScreenName.trim() ? qCoreScreenName.trim() : '');
+    if (!SCREEN_NAME_PATTERN.test(qScreenName)) return null;
+    const qLegacyDisplayName = qUser?.legacy?.name;
+    const qCoreDisplayName = qUser?.core?.name;
+    const qDisplayName = typeof qLegacyDisplayName === 'string'
+        ? qLegacyDisplayName
+        : (typeof qCoreDisplayName === 'string' ? qCoreDisplayName : '');
+    const qNoteText = qTw.note_tweet?.note_tweet_results?.result?.text;
+    const qText = (typeof qNoteText === 'string' && qNoteText.length > 0)
+        ? qNoteText
+        : (typeof qLegacy.full_text === 'string' ? qLegacy.full_text : '');
+    const qMedia = extractMedia(qLegacy);
+    const qCard = extractCard(qTw);
+    if (!qText && !qMedia.has_media && !qCard) return null;
+    const out = {
+        id: qTw.rest_id,
+        author: qScreenName,
+        name: qDisplayName,
+        text: qText,
+        created_at: typeof qLegacy.created_at === 'string' ? qLegacy.created_at : '',
+        url: `https://x.com/${qScreenName}/status/${qTw.rest_id}`,
+        has_media: qMedia.has_media,
+        media_urls: qMedia.media_urls,
+    };
+    if (qCard) out.card = qCard;
+    return out;
+}
+
 export const __test__ = {
     sanitizeQueryId,
     sanitizeTwitterOperationMetadata,
@@ -295,6 +447,9 @@ export const __test__ = {
     normalizeTwitterGraphqlPayload,
     normalizeTwitterScreenName,
     extractMedia,
+    extractCard,
+    extractQuotedTweet,
     parseTweetUrl,
     buildTwitterArticleScopeSource,
+    looksLikePrivateTwitterTimeline,
 };