@jackwener/opencli 1.7.14 → 1.7.16

package/clis/twitter/bookmark-folder.test.js

@@ -0,0 +1,337 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { __test__ } from './bookmark-folder.js';
+
+const { parseBookmarkFolderTimeline, buildFolderTimelineUrl, FOLDER_ID_PATTERN } = __test__;
+
+describe('twitter bookmark-folder URL builder', () => {
+    it('embeds the folder id and count in the variables payload', () => {
+        const url = buildFolderTimelineUrl('queryX', '12345', 50, null);
+        const m = url.match(/variables=([^&]+)/);
+        const vars = JSON.parse(decodeURIComponent(m[1]));
+        expect(vars.bookmark_collection_id).toBe('12345');
+        expect(vars.count).toBe(50);
+        expect(vars.includePromotedContent).toBe(false);
+        expect(vars.cursor).toBeUndefined();
+    });
+
+    it('appends the cursor when one is supplied', () => {
+        const url = buildFolderTimelineUrl('queryX', '12345', 50, 'CURSOR_VAL');
+        const m = url.match(/variables=([^&]+)/);
+        const vars = JSON.parse(decodeURIComponent(m[1]));
+        expect(vars.cursor).toBe('CURSOR_VAL');
+    });
+
+    it('coerces a numeric folder id to a string', () => {
+        const url = buildFolderTimelineUrl('queryX', 555, 10);
+        const m = url.match(/variables=([^&]+)/);
+        const vars = JSON.parse(decodeURIComponent(m[1]));
+        expect(vars.bookmark_collection_id).toBe('555');
+    });
+
+    it('preserves opaque folder ids without truncating them', () => {
+        const url = buildFolderTimelineUrl('queryX', 'folder_AbC-123', 10);
+        const m = url.match(/variables=([^&]+)/);
+        const vars = JSON.parse(decodeURIComponent(m[1]));
+        expect(vars.bookmark_collection_id).toBe('folder_AbC-123');
+    });
+});
+
+describe('twitter bookmark-folder timeline parser', () => {
+    it('extracts tweets from bookmark_timeline_v2 envelope', () => {
+        const data = {
+            data: {
+                bookmark_timeline_v2: {
+                    timeline: {
+                        instructions: [
+                            {
+                                type: 'TimelineAddEntries',
+                                entries: [
+                                    {
+                                        entryId: 'tweet-1',
+                                        content: {
+                                            itemContent: {
+                                                tweet_results: {
+                                                    result: {
+                                                        rest_id: '1',
+                                                        legacy: {
+                                                            full_text: 'first folder tweet',
+                                                            favorite_count: 9,
+                                                            retweet_count: 2,
+                                                            bookmark_count: 3,
+                                                            created_at: 'Tue Mar 17 09:00:00 +0000 2026',
+                                                        },
+                                                        core: {
+                                                            user_results: {
+                                                                result: { core: { screen_name: 'alice' } },
+                                                            },
+                                                        },
+                                                    },
+                                                },
+                                            },
+                                        },
+                                    },
+                                    {
+                                        entryId: 'cursor-bottom-X',
+                                        content: {
+                                            __typename: 'TimelineTimelineCursor',
+                                            cursorType: 'Bottom',
+                                            value: 'NEXT_CURSOR',
+                                        },
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                },
+            },
+        };
+        const { tweets, nextCursor } = parseBookmarkFolderTimeline(data, new Set());
+        expect(tweets).toEqual([
+            {
+                id: '1',
+                author: 'alice',
+                text: 'first folder tweet',
+                likes: 9,
+                retweets: 2,
+                bookmarks: 3,
+                created_at: 'Tue Mar 17 09:00:00 +0000 2026',
+                url: 'https://x.com/alice/status/1',
+            },
+        ]);
+        expect(nextCursor).toBe('NEXT_CURSOR');
+    });
+
+    it('falls back to bookmark_collection_timeline envelope', () => {
+        const data = {
+            data: {
+                bookmark_collection_timeline: {
+                    timeline: {
+                        instructions: [
+                            {
+                                entries: [
+                                    {
+                                        entryId: 'tweet-2',
+                                        content: {
+                                            itemContent: {
+                                                tweet_results: {
+                                                    result: {
+                                                        rest_id: '2',
+                                                        legacy: { full_text: 'collection envelope', favorite_count: 1, retweet_count: 0, bookmark_count: 0 },
+                                                        core: { user_results: { result: { legacy: { screen_name: 'bob' } } } },
+                                                    },
+                                                },
+                                            },
+                                        },
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                },
+            },
+        };
+        const { tweets } = parseBookmarkFolderTimeline(data, new Set());
+        expect(tweets).toHaveLength(1);
+        expect(tweets[0].id).toBe('2');
+        expect(tweets[0].author).toBe('bob');
+    });
+
+    it('uses note_tweet text when present (long-form tweets)', () => {
+        const data = {
+            data: {
+                bookmark_timeline_v2: {
+                    timeline: {
+                        instructions: [{
+                            entries: [{
+                                entryId: 'tweet-3',
+                                content: {
+                                    itemContent: {
+                                        tweet_results: {
+                                            result: {
+                                                rest_id: '3',
+                                                legacy: { full_text: 'short text', favorite_count: 0, retweet_count: 0, bookmark_count: 0 },
+                                                note_tweet: { note_tweet_results: { result: { text: 'full long-form text' } } },
+                                                core: { user_results: { result: { core: { screen_name: 'carol' } } } },
+                                            },
+                                        },
+                                    },
+                                },
+                            }],
+                        }],
+                    },
+                },
+            },
+        };
+        const { tweets } = parseBookmarkFolderTimeline(data, new Set());
+        expect(tweets[0].text).toBe('full long-form text');
+    });
+
+    it('deduplicates tweets across the seen Set', () => {
+        const data = {
+            data: {
+                bookmark_timeline_v2: {
+                    timeline: {
+                        instructions: [{
+                            entries: [
+                                {
+                                    entryId: 'tweet-4',
+                                    content: {
+                                        itemContent: {
+                                            tweet_results: {
+                                                result: {
+                                                    rest_id: '4',
+                                                    legacy: { full_text: 'first', favorite_count: 0, retweet_count: 0, bookmark_count: 0 },
+                                                    core: { user_results: { result: { core: { screen_name: 'dan' } } } },
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                                {
+                                    entryId: 'tweet-4-dup',
+                                    content: {
+                                        itemContent: {
+                                            tweet_results: {
+                                                result: {
+                                                    rest_id: '4',
+                                                    legacy: { full_text: 'duplicate' },
+                                                    core: { user_results: { result: { core: { screen_name: 'dan' } } } },
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            ],
+                        }],
+                    },
+                },
+            },
+        };
+        const seen = new Set();
+        const { tweets } = parseBookmarkFolderTimeline(data, seen);
+        expect(tweets).toHaveLength(1);
+        expect(tweets[0].text).toBe('first');
+    });
+
+    it('does not synthesize an unknown author sentinel when screen_name is missing', () => {
+        const data = {
+            data: {
+                bookmark_timeline_v2: {
+                    timeline: {
+                        instructions: [{
+                            entries: [{
+                                entryId: 'tweet-5',
+                                content: {
+                                    itemContent: {
+                                        tweet_results: {
+                                            result: {
+                                                rest_id: '5',
+                                                legacy: { full_text: 'missing author', favorite_count: 0, retweet_count: 0, bookmark_count: 0 },
+                                                core: { user_results: { result: {} } },
+                                            },
+                                        },
+                                    },
+                                },
+                            }],
+                        }],
+                    },
+                },
+            },
+        };
+        const { tweets } = parseBookmarkFolderTimeline(data, new Set());
+        expect(tweets[0].author).toBe('');
+        expect(tweets[0].url).toBe('https://x.com/i/status/5');
+    });
+
+    it('returns empty array + null cursor for unknown envelope', () => {
+        expect(parseBookmarkFolderTimeline({}, new Set())).toEqual({ tweets: [], nextCursor: null });
+    });
+});
+
+describe('twitter bookmark-folder id validation', () => {
+    it('accepts numeric and opaque safe ids from bookmark-folders output', () => {
+        expect(FOLDER_ID_PATTERN.test('1234567890')).toBe(true);
+        expect(FOLDER_ID_PATTERN.test('folder_AbC-123')).toBe(true);
+    });
+
+    it('rejects ids that could pollute GraphQL variables or URL construction', () => {
+        for (const value of ['folder/123', 'folder?x=1', 'folder%2F123', 'folder.123', 'folder 123', '']) {
+            expect(FOLDER_ID_PATTERN.test(value)).toBe(false);
+        }
+    });
+});
+
+describe('twitter bookmark-folder command (registry)', () => {
+    it('throws ArgumentError on unsafe folder-id before navigation', async () => {
+        const command = getRegistry().get('twitter/bookmark-folder');
+        expect(command?.func).toBeTypeOf('function');
+        const page = {
+            goto: vi.fn(),
+            wait: vi.fn(),
+            evaluate: vi.fn(),
+        };
+        await expect(command.func(page, { 'folder-id': 'folder/123', limit: 5 }))
+            .rejects
+            .toThrow(/Invalid folder-id/);
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+
+    it('throws ArgumentError on empty folder-id', async () => {
+        const command = getRegistry().get('twitter/bookmark-folder');
+        const page = {
+            goto: vi.fn(),
+            wait: vi.fn(),
+            evaluate: vi.fn(),
+        };
+        await expect(command.func(page, { 'folder-id': '   ', limit: 5 }))
+            .rejects
+            .toThrow(/Invalid folder-id/);
+    });
+
+    it('throws ArgumentError on invalid limit before navigation', async () => {
+        const command = getRegistry().get('twitter/bookmark-folder');
+        for (const limit of [0, -1, 1.5, Number.NaN]) {
+            const page = {
+                goto: vi.fn(),
+                wait: vi.fn(),
+                evaluate: vi.fn(),
+            };
+            await expect(command.func(page, { 'folder-id': '12345', limit }))
+                .rejects
+                .toThrow(/Invalid --limit/);
+            expect(page.goto).not.toHaveBeenCalled();
+        }
+    });
+
+    it('throws AuthRequiredError when ct0 cookie is missing', async () => {
+        const command = getRegistry().get('twitter/bookmark-folder');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            getCookies: vi.fn().mockResolvedValue([]),
+            evaluate: vi.fn().mockResolvedValue(null),
+        };
+        await expect(command.func(page, { 'folder-id': '12345', limit: 5 }))
+            .rejects
+            .toThrow(/Not logged into x.com/);
+        expect(page.getCookies).toHaveBeenCalledWith({ url: 'https://x.com' });
+    });
+
+    it('accepts an opaque safe folder-id and sends it in the GraphQL variables', async () => {
+        const command = getRegistry().get('twitter/bookmark-folder');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            getCookies: vi.fn().mockResolvedValue([{ name: 'ct0', value: 'ct0-token' }]),
+            evaluate: vi.fn()
+                .mockResolvedValueOnce('queryX')
+                .mockResolvedValueOnce({ data: { bookmark_timeline_v2: { timeline: { instructions: [] } } } }),
+        };
+        const result = await command.func(page, { 'folder-id': 'folder_AbC-123', limit: 5 });
+        expect(result).toEqual([]);
+        expect(page.getCookies).toHaveBeenCalledWith({ url: 'https://x.com' });
+        const fetchScript = page.evaluate.mock.calls[1][0];
+        expect(decodeURIComponent(fetchScript)).toContain('"bookmark_collection_id":"folder_AbC-123"');
+    });
+});

package/clis/twitter/bookmark-folders.js

@@ -0,0 +1,115 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { TWITTER_BEARER_TOKEN } from './utils.js';
+import { resolveTwitterQueryId } from './shared.js';
+
+// X surfaces user-created bookmark folders through a GraphQL slice query.
+// We mirror the patterns used in bookmarks.js / lists.js: a literal
+// fallback queryId combined with a runtime lookup against the
+// twitter-openapi placeholder.json so we keep working when X rotates IDs.
+const OPERATION_NAME = 'bookmarkFoldersSlice';
+const FALLBACK_QUERY_ID = 'i78YDd0Tza-dWKw5H2Y7WA';
+
+const FEATURES = {
+    rweb_tipjar_consumption_enabled: false,
+    responsive_web_graphql_exclude_directive_enabled: true,
+    verified_phone_label_enabled: false,
+    creator_subscriptions_tweet_preview_api_enabled: true,
+    responsive_web_graphql_timeline_navigation_enabled: true,
+    responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
+};
+
+function buildUrl(queryId) {
+    const variables = JSON.stringify({});
+    return `/i/api/graphql/${queryId}/${OPERATION_NAME}`
+        + `?variables=${encodeURIComponent(variables)}`
+        + `&features=${encodeURIComponent(JSON.stringify(FEATURES))}`;
+}
+
+/**
+ * Walk the GraphQL response shape used by X's bookmark folders slice and
+ * project each folder onto our column row.
+ *
+ * X has shipped at least three different envelope shapes for this query
+ * across the last two years; the precedence order below preserves
+ * compatibility with older accounts whose Premium-eligibility flag is
+ * still on the legacy V2 envelope.
+ *
+ * Exported via __test__ so the parser is unit-testable without a browser.
+ */
+export function parseBookmarkFolders(data, seen) {
+    const folders = [];
+    const slice = data?.data?.viewer?.bookmark_collections_slice
+        || data?.data?.viewer_v2?.user_results?.result?.bookmark_collections_slice
+        || data?.data?.bookmark_collections_slice
+        || null;
+    const items = slice?.items || slice?.timeline?.timeline?.instructions?.flatMap?.(i => i.entries || []) || [];
+    for (const item of items) {
+        // Two known item shapes: direct {id, name, ...} (newer) or wrapped
+        // {content: {bookmarkCollectionResult: {...}}} (older / nested).
+        const folder
+            = item?.bookmarkCollection
+            || item?.content?.bookmarkCollection
+            || item?.content?.itemContent?.bookmark_collection
+            || item;
+        const id = folder?.id_str || folder?.id || folder?.rest_id || '';
+        if (!id || seen.has(id)) continue;
+        seen.add(id);
+        const name = folder?.name || folder?.collection_name || '';
+        // bookmarks_count is the X UI label; older envelopes used `count`.
+        const itemsCount = Number(folder?.bookmarks_count ?? folder?.items_count ?? folder?.count ?? 0) || 0;
+        const createdAt = folder?.created_at || folder?.timestamp_ms || '';
+        folders.push({
+            id: String(id),
+            name: String(name),
+            items: itemsCount,
+            created_at: String(createdAt),
+        });
+    }
+    return folders;
+}
+
+cli({
+    site: 'twitter',
+    name: 'bookmark-folders',
+    access: 'read',
+    description: 'List your Twitter/X bookmark folders (the user-created collections under Bookmarks). Returns folder id, name, item count, and created_at.',
+    domain: 'x.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    browserSession: { reuse: 'site' },
+    args: [],
+    columns: ['id', 'name', 'items', 'created_at'],
+    func: async (page) => {
+        const cookies = await page.getCookies({ url: 'https://x.com' });
+        const ct0 = cookies.find((c) => c.name === 'ct0')?.value || null;
+        if (!ct0)
+            throw new AuthRequiredError('x.com', 'Not logged into x.com (no ct0 cookie)');
+
+        // Try the fa0311/twitter-openapi placeholder first; fall back to scraping
+        // client-web bundles for the queryId; final fallback is the pinned constant.
+        const queryId = await resolveTwitterQueryId(page, OPERATION_NAME, FALLBACK_QUERY_ID);
+
+        const headers = JSON.stringify({
+            'Authorization': `Bearer ${decodeURIComponent(TWITTER_BEARER_TOKEN)}`,
+            'X-Csrf-Token': ct0,
+            'X-Twitter-Auth-Type': 'OAuth2Session',
+            'X-Twitter-Active-User': 'yes',
+        });
+        const apiUrl = buildUrl(queryId);
+        const data = await page.evaluate(`async () => {
+            const r = await fetch(${JSON.stringify(apiUrl)}, { headers: ${headers}, credentials: 'include' });
+            return r.ok ? await r.json() : { error: r.status };
+        }`);
+        if (data?.error) {
+            throw new CommandExecutionError(`HTTP ${data.error}: Failed to fetch bookmark folders. queryId may have expired, or your account may not have folder access.`);
+        }
+        const seen = new Set();
+        return parseBookmarkFolders(data, seen);
+    },
+});
+
+export const __test__ = {
+    parseBookmarkFolders,
+    buildUrl,
+};

package/clis/twitter/bookmark-folders.test.js

@@ -0,0 +1,152 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { __test__ } from './bookmark-folders.js';
+
+const { parseBookmarkFolders, buildUrl } = __test__;
+
+describe('twitter bookmark-folders parser', () => {
+    it('returns [] for empty payload', () => {
+        expect(parseBookmarkFolders({}, new Set())).toEqual([]);
+        expect(parseBookmarkFolders({ data: {} }, new Set())).toEqual([]);
+    });
+
+    it('extracts folders from the modern viewer.bookmark_collections_slice envelope', () => {
+        const data = {
+            data: {
+                viewer: {
+                    bookmark_collections_slice: {
+                        items: [
+                            {
+                                bookmarkCollection: {
+                                    id_str: '1234567890',
+                                    name: 'Reading list',
+                                    bookmarks_count: 42,
+                                    created_at: '2025-09-15T10:00:00.000Z',
+                                },
+                            },
+                            {
+                                bookmarkCollection: {
+                                    id_str: '9876543210',
+                                    name: 'Recipes',
+                                    bookmarks_count: 7,
+                                    created_at: '2026-01-03T03:14:00.000Z',
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+        };
+        expect(parseBookmarkFolders(data, new Set())).toEqual([
+            { id: '1234567890', name: 'Reading list', items: 42, created_at: '2025-09-15T10:00:00.000Z' },
+            { id: '9876543210', name: 'Recipes', items: 7, created_at: '2026-01-03T03:14:00.000Z' },
+        ]);
+    });
+
+    it('falls back to legacy viewer_v2 envelope', () => {
+        const data = {
+            data: {
+                viewer_v2: {
+                    user_results: {
+                        result: {
+                            bookmark_collections_slice: {
+                                items: [{ bookmarkCollection: { id: 'abc', name: 'Old', count: 3 } }],
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        expect(parseBookmarkFolders(data, new Set())).toEqual([
+            { id: 'abc', name: 'Old', items: 3, created_at: '' },
+        ]);
+    });
+
+    it('falls back to flat bookmark_collections_slice envelope', () => {
+        const data = {
+            data: {
+                bookmark_collections_slice: {
+                    items: [{ id_str: '5', name: 'Flat', bookmarks_count: 1, created_at: '2024-01-01' }],
+                },
+            },
+        };
+        expect(parseBookmarkFolders(data, new Set())).toEqual([
+            { id: '5', name: 'Flat', items: 1, created_at: '2024-01-01' },
+        ]);
+    });
+
+    it('deduplicates folders by id across the seen Set', () => {
+        const data = {
+            data: {
+                viewer: {
+                    bookmark_collections_slice: {
+                        items: [
+                            { bookmarkCollection: { id_str: '1', name: 'A', bookmarks_count: 0 } },
+                            { bookmarkCollection: { id_str: '1', name: 'A again', bookmarks_count: 0 } },
+                            { bookmarkCollection: { id_str: '2', name: 'B', bookmarks_count: 0 } },
+                        ],
+                    },
+                },
+            },
+        };
+        expect(parseBookmarkFolders(data, new Set())).toEqual([
+            { id: '1', name: 'A', items: 0, created_at: '' },
+            { id: '2', name: 'B', items: 0, created_at: '' },
+        ]);
+    });
+
+    it('coerces missing items count to 0', () => {
+        const data = {
+            data: {
+                viewer: {
+                    bookmark_collections_slice: {
+                        items: [{ bookmarkCollection: { id: '1', name: 'No count' } }],
+                    },
+                },
+            },
+        };
+        expect(parseBookmarkFolders(data, new Set())[0].items).toBe(0);
+    });
+
+    it('skips entries without an id', () => {
+        const data = {
+            data: {
+                viewer: {
+                    bookmark_collections_slice: {
+                        items: [
+                            { bookmarkCollection: { name: 'Anonymous' } },
+                            { bookmarkCollection: { id: '1', name: 'OK' } },
+                        ],
+                    },
+                },
+            },
+        };
+        expect(parseBookmarkFolders(data, new Set())).toEqual([
+            { id: '1', name: 'OK', items: 0, created_at: '' },
+        ]);
+    });
+});
+
+describe('twitter bookmark-folders URL builder', () => {
+    it('encodes the empty variables object and includes the queryId in the path', () => {
+        const url = buildUrl('queryid123');
+        expect(url).toContain('/i/api/graphql/queryid123/bookmarkFoldersSlice');
+        expect(url).toContain('variables=' + encodeURIComponent('{}'));
+        expect(url).toContain('features=');
+    });
+});
+
+describe('twitter bookmark-folders command (registry)', () => {
+    it('throws AuthRequiredError when ct0 cookie is missing', async () => {
+        const command = getRegistry().get('twitter/bookmark-folders');
+        expect(command?.func).toBeTypeOf('function');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            getCookies: vi.fn().mockResolvedValue([]), // no ct0 cookie → AuthRequired
+            evaluate: vi.fn().mockResolvedValue(null),
+        };
+        await expect(command.func(page, {})).rejects.toThrow(/Not logged into x.com/);
+        expect(page.getCookies).toHaveBeenCalledWith({ url: 'https://x.com' });
+    });
+});

package/clis/twitter/bookmark.js

@@ -1,5 +1,7 @@
 import { CommandExecutionError } from '@jackwener/opencli/errors';
 import { cli, Strategy } from '@jackwener/opencli/registry';
+import { parseTweetUrl, buildTwitterArticleScopeSource } from './shared.js';
+
 cli({
     site: 'twitter',
     name: 'bookmark',
@@ -15,22 +17,28 @@ cli({
     func: async (page, kwargs) => {
         if (!page)
             throw new CommandExecutionError('Browser session required for twitter bookmark');
-        await page.goto(kwargs.url);
+        const target = parseTweetUrl(kwargs.url);
+        await page.goto(target.url);
         await page.wait({ selector: '[data-testid="primaryColumn"]' });
         const result = await page.evaluate(`(async () => {
         try {
+            ${buildTwitterArticleScopeSource(target.id)}
+            // Article-scoped: on conversation pages multiple bookmark/remove
+            // buttons render and a bare querySelector would silently bookmark
+            // a different tweet (e.g. the parent of the requested reply).
             let attempts = 0;
             let bookmarkBtn = null;
             let removeBtn = null;
+            let targetArticle = null;
 
             while (attempts < 20) {
-                // Check if already bookmarked
-                removeBtn = document.querySelector('[data-testid="removeBookmark"]');
+                targetArticle = findTargetArticle();
+                removeBtn = targetArticle?.querySelector('[data-testid="removeBookmark"]') || null;
                 if (removeBtn) {
                     return { ok: true, message: 'Tweet is already bookmarked.' };
                 }
 
-                bookmarkBtn = document.querySelector('[data-testid="bookmark"]');
+                bookmarkBtn = targetArticle?.querySelector('[data-testid="bookmark"]') || null;
                 if (bookmarkBtn) break;
 
                 await new Promise(r => setTimeout(r, 500));
@@ -38,14 +46,15 @@ cli({
             }
 
             if (!bookmarkBtn) {
-                return { ok: false, message: 'Could not find Bookmark button. Are you logged in?' };
+                return { ok: false, message: 'Could not find Bookmark button on the requested tweet. Are you logged in?' };
             }
 
             bookmarkBtn.click();
             await new Promise(r => setTimeout(r, 1000));
 
             // Verify
-            const verify = document.querySelector('[data-testid="removeBookmark"]');
+            const verifyArticle = findTargetArticle() || targetArticle;
+            const verify = verifyArticle?.querySelector('[data-testid="removeBookmark"]');
             if (verify) {
                 return { ok: true, message: 'Tweet successfully bookmarked.' };
             } else {