@jackwener/opencli 1.7.15 → 1.7.16

package/clis/openreview/author.js

@@ -0,0 +1,58 @@
+/**
+ * OpenReview submissions by author profile id (newest first).
+ *
+ * Pairs with `openreview paper <id>` and `openreview reviews <id>` for the
+ * full read-side workflow: list every submission an author put on
+ * OpenReview, then drill into a specific paper or its review thread.
+ *
+ * Uses the public v2 endpoint `/notes?content.authorids=~<profile-id>`,
+ * which returns the same note shape as `paper`, sorted by `cdate:desc`.
+ */
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import {
+    noteToRow,
+    openreviewFetch,
+    requireBoundedInt,
+    requireProfileId,
+} from './utils.js';
+
+cli({
+    site: 'openreview',
+    name: 'author',
+    access: 'read',
+    description: 'List OpenReview submissions by an author profile id (newest first)',
+    domain: 'openreview.net',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'profile', positional: true, required: true, help: 'OpenReview profile id (e.g. "~Yoshua_Bengio1"). Find it on the author profile URL on openreview.net.' },
+        { name: 'limit', type: 'int', default: 50, help: 'Max submissions (1-1000)' },
+    ],
+    columns: ['rank', 'id', 'title', 'authors', 'venue', 'pdate', 'url'],
+    func: async (args) => {
+        const profile = requireProfileId(args.profile);
+        const limit = requireBoundedInt(args.limit, 50, 1000);
+        const path = `/notes?content.authorids=${encodeURIComponent(profile)}&limit=${limit}&sort=cdate:desc`;
+        const json = await openreviewFetch(path, `openreview author ${profile}`);
+        const notes = Array.isArray(json?.notes) ? json.notes : [];
+        if (!notes.length) {
+            throw new EmptyResultError(
+                'openreview author',
+                `No OpenReview submissions found for profile "${profile}". Confirm the id format (~First_LastN) and that the profile has public submissions.`,
+            );
+        }
+        return notes.slice(0, limit).map((note, i) => {
+            const row = noteToRow(note);
+            return {
+                rank: i + 1,
+                id: row.id,
+                title: row.title,
+                authors: row.authors,
+                venue: row.venue,
+                pdate: row.pdate,
+                url: row.url,
+            };
+        });
+    },
+});

package/clis/openreview/openreview.test.js

@@ -8,11 +8,13 @@ import {
     requireBoundedInt,
     requireForumId,
     requireNonNegativeInt,
+    requireProfileId,
 } from './utils.js';
 import './search.js';
 import './venue.js';
 import './paper.js';
 import './reviews.js';
+import './author.js';
 
 const SAMPLE_NOTE = {
     id: 'abc123XYZ_',
@@ -37,21 +39,24 @@ afterEach(() => {
 });
 
 describe('openreview adapter', () => {
-    it('registers all four commands with the expected columns', () => {
+    it('registers all five commands with the expected columns', () => {
         const search = getRegistry().get('openreview/search');
         const venue = getRegistry().get('openreview/venue');
         const paper = getRegistry().get('openreview/paper');
         const reviews = getRegistry().get('openreview/reviews');
+        const author = getRegistry().get('openreview/author');
 
         expect(search).toBeDefined();
         expect(venue).toBeDefined();
         expect(paper).toBeDefined();
         expect(reviews).toBeDefined();
+        expect(author).toBeDefined();
 
         expect(search.columns).toEqual(['rank', 'id', 'title', 'authors', 'venue', 'pdate', 'url']);
         expect(venue.columns).toEqual(['rank', 'id', 'title', 'authors', 'keywords', 'primary_area', 'pdate', 'pdf', 'url']);
         expect(paper.columns).toEqual(['id', 'title', 'authors', 'keywords', 'venue', 'venueid', 'primary_area', 'abstract', 'pdate', 'pdf', 'url']);
         expect(reviews.columns).toEqual(['type', 'author', 'rating', 'confidence', 'text']);
+        expect(author.columns).toEqual(['rank', 'id', 'title', 'authors', 'venue', 'pdate', 'url']);
     });
 
     it('noteToRow extracts every wrapped v2 field, joins lists, and builds absolute URLs', () => {
@@ -109,6 +114,30 @@ describe('openreview adapter', () => {
         expect(() => requireForumId('short')).toThrow('not a valid forum id');
     });
 
+    it('requireProfileId accepts canonical profile ids and rejects malformed input', () => {
+        expect(requireProfileId('~Yoshua_Bengio1')).toBe('~Yoshua_Bengio1');
+        expect(requireProfileId('~Bo_Liu17')).toBe('~Bo_Liu17');
+        expect(requireProfileId('~Geoffrey_Everest_Hinton1')).toBe('~Geoffrey_Everest_Hinton1');
+        expect(requireProfileId('~Anne-Christin_Hauschild1')).toBe('~Anne-Christin_Hauschild1');
+        expect(requireProfileId('~S.Aruna_Deepthi1')).toBe('~S.Aruna_Deepthi1');
+        expect(requireProfileId('~Andrzej_Czyżewski1')).toBe('~Andrzej_Czyżewski1');
+        expect(requireProfileId('~August_Bøgh_Rønberg1')).toBe('~August_Bøgh_Rønberg1');
+        expect(requireProfileId('~Wagner_Meira_Jr.1')).toBe('~Wagner_Meira_Jr.1');
+        expect(() => requireProfileId('')).toThrow('required');
+        expect(() => requireProfileId('   ')).toThrow('required');
+        // Missing leading tilde.
+        expect(() => requireProfileId('Bo_Liu17')).toThrow('not a valid profile id');
+        // Missing trailing disambiguator number.
+        expect(() => requireProfileId('~Bo_Liu')).toThrow('not a valid profile id');
+        // Spaces / non-letter characters break the underscore-joined name.
+        expect(() => requireProfileId('~Bo Liu1')).toThrow('not a valid profile id');
+        // dblp-style PID must not silently fall through.
+        expect(() => requireProfileId('56/953')).toThrow('not a valid profile id');
+        expect(() => requireProfileId('~Bo_Liu1?evil=1')).toThrow('not a valid profile id');
+        expect(() => requireProfileId('~Bo/Liu1')).toThrow('not a valid profile id');
+        expect(() => requireProfileId('~123')).toThrow('not a valid profile id');
+    });
+
     it('formatDate handles ms-since-epoch and rejects invalid input', () => {
         expect(formatDate(1727524853394)).toBe('2024-09-28');
         expect(formatDate(0)).toBe('');
@@ -342,4 +371,57 @@ describe('openreview adapter', () => {
         expect(rows[1].text.length).toBe(500);
         expect(rows[1].text.endsWith('...')).toBe(true);
     });
+
+    it('author rejects invalid profile ids before calling the network', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+        const author = getRegistry().get('openreview/author');
+        await expect(author.func({ profile: 'Bo_Liu17', limit: 5 })).rejects.toMatchObject({ code: 'ARGUMENT' });
+        await expect(author.func({ profile: '', limit: 5 })).rejects.toMatchObject({ code: 'ARGUMENT' });
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('author throws EmptyResult when the profile has no submissions', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify({ notes: [] }), { status: 200 })));
+        const author = getRegistry().get('openreview/author');
+        await expect(author.func({ profile: '~No_Submissions1', limit: 5 })).rejects.toMatchObject({ code: 'EMPTY_RESULT' });
+    });
+
+    it('author wraps non-200 responses as CommandExecutionError', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('rate limited', { status: 429 })));
+        const author = getRegistry().get('openreview/author');
+        await expect(author.func({ profile: '~Bo_Liu17', limit: 5 })).rejects.toMatchObject({ code: 'COMMAND_EXEC' });
+    });
+
+    it('author wraps fetch network errors as CommandExecutionError', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('ECONNRESET')));
+        const author = getRegistry().get('openreview/author');
+        await expect(author.func({ profile: '~Bo_Liu17', limit: 5 })).rejects.toMatchObject({
+            code: 'COMMAND_EXEC',
+            message: expect.stringContaining('Network failure'),
+        });
+    });
+
+    it('author hits /notes?content.authorids and returns rank-ordered rows', async () => {
+        const fetchMock = vi.fn().mockResolvedValue(new Response(JSON.stringify({ notes: [SAMPLE_NOTE, SAMPLE_NOTE] }), { status: 200 }));
+        vi.stubGlobal('fetch', fetchMock);
+        const author = getRegistry().get('openreview/author');
+        const rows = await author.func({ profile: '~Bo_Liu17', limit: 50 });
+        expect(rows).toHaveLength(2);
+        expect(rows[0]).toEqual({
+            rank: 1,
+            id: 'abc123XYZ_',
+            title: 'Test Paper Title with spaces',
+            authors: 'Alice Smith, Bob Jones',
+            venue: 'ICLR 2024 oral',
+            pdate: '2024-09-28',
+            url: 'https://openreview.net/forum?id=abc123XYZ_',
+        });
+        expect(rows[1].rank).toBe(2);
+        // Confirm the request shape: canonical authorids filter + cdate sort.
+        const url = fetchMock.mock.calls[0][0];
+        expect(url).toContain('content.authorids=');
+        expect(url).toContain(encodeURIComponent('~Bo_Liu17'));
+        expect(url).toContain('sort=cdate:desc');
+    });
 });

package/clis/openreview/utils.js

@@ -55,6 +55,20 @@ export function requireForumId(value, label = 'id') {
     return id;
 }
 
+/** OpenReview profile ids are `~...N` slugs and may include dots, hyphens, and Unicode letters. */
+const PROFILE_ID_PATTERN = /^~(?=.*\p{L})[\p{L}\p{M}0-9._-]+\d+$/u;
+
+export function requireProfileId(value, label = 'profile') {
+    const id = String(value ?? '').trim();
+    if (!id) {
+        throw new ArgumentError(`openreview ${label} is required`);
+    }
+    if (!PROFILE_ID_PATTERN.test(id)) {
+        throw new ArgumentError(`openreview ${label} "${value}" is not a valid profile id (expected "~First_Last1" or similar; find it on the author's openreview.net profile URL)`);
+    }
+    return id;
+}
+
 /** Wrap fetch + json with typed errors so failures never look like empty results. */
 export async function openreviewFetch(path, label) {
     const url = `${OPENREVIEW_API}${path}`;

package/clis/reddit/comment.js

@@ -8,6 +8,7 @@ cli({
     domain: 'reddit.com',
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     args: [
         { name: 'post-id', type: 'string', required: true, positional: true, help: 'Post ID (e.g. 1abc123) or fullname (t3_xxx)' },
         { name: 'text', type: 'string', required: true, positional: true, help: 'Comment text' },

package/clis/reddit/frontpage.js

@@ -7,6 +7,7 @@ cli({
     domain: 'reddit.com',
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     args: [
         { name: 'limit', type: 'int', default: 15 },
     ],

package/clis/reddit/popular.js

@@ -7,6 +7,7 @@ cli({
     domain: 'reddit.com',
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     args: [
         { name: 'limit', type: 'int', default: 20 },
     ],

package/clis/reddit/read.js

@@ -15,6 +15,8 @@ cli({
     description: 'Read a Reddit post and its comments',
     domain: 'reddit.com',
     strategy: Strategy.COOKIE,
+    browser: true,
+    browserSession: { reuse: 'site' },
     args: [
         { name: 'post-id', required: true, positional: true, help: 'Post ID (e.g. 1abc123) or full URL' },
         { name: 'sort', default: 'best', help: 'Comment sort: best, top, new, controversial, old, qa' },

package/clis/reddit/read.test.js

@@ -3,6 +3,10 @@ import { getRegistry } from '@jackwener/opencli/registry';
 import './read.js';
 describe('reddit read adapter', () => {
     const command = getRegistry().get('reddit/read');
+    it('opts into the Reddit site browser session lease', () => {
+        expect(command?.browser).toBe(true);
+        expect(command?.browserSession).toEqual({ reuse: 'site' });
+    });
     it('returns threaded rows from the browser-evaluated payload', async () => {
         const page = {
             goto: vi.fn().mockResolvedValue(undefined),

package/clis/reddit/save.js

@@ -8,6 +8,7 @@ cli({
     domain: 'reddit.com',
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     args: [
         { name: 'post-id', type: 'string', required: true, positional: true, help: 'Post ID (e.g. 1abc123) or fullname (t3_xxx)' },
         { name: 'undo', type: 'boolean', default: false, help: 'Unsave instead of save' },

package/clis/reddit/saved.js

@@ -8,6 +8,7 @@ cli({
     domain: 'reddit.com',
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     args: [
         { name: 'limit', type: 'int', default: 15 },
     ],

package/clis/reddit/search.js

@@ -7,6 +7,7 @@ cli({
     domain: 'reddit.com',
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     args: [
         { name: 'query', type: 'string', required: true, positional: true, help: 'Reddit search query' },
         {

package/clis/reddit/subreddit.js

@@ -7,6 +7,7 @@ cli({
     domain: 'reddit.com',
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     args: [
         { name: 'name', type: 'string', required: true, positional: true, help: 'Subreddit name (no `r/` prefix; e.g. `python`)' },
         {

package/clis/reddit/subscribe.js

@@ -8,6 +8,7 @@ cli({
     domain: 'reddit.com',
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     args: [
         { name: 'subreddit', type: 'string', required: true, positional: true, help: 'Subreddit name (e.g. python)' },
         { name: 'undo', type: 'boolean', default: false, help: 'Unsubscribe instead of subscribe' },

package/clis/reddit/upvote.js

@@ -8,6 +8,7 @@ cli({
     domain: 'reddit.com',
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     args: [
         { name: 'post-id', type: 'string', required: true, positional: true, help: 'Post ID (e.g. 1abc123) or fullname (t3_xxx)' },
         { name: 'direction', type: 'string', default: 'up', help: 'Vote direction: up, down, none' },

package/clis/reddit/upvoted.js

@@ -8,6 +8,7 @@ cli({
     domain: 'reddit.com',
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     args: [
         { name: 'limit', type: 'int', default: 15 },
     ],

package/clis/reddit/user-comments.js

@@ -7,6 +7,7 @@ cli({
     domain: 'reddit.com',
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     args: [
         { name: 'username', type: 'string', required: true, positional: true, help: 'Reddit username (no `u/` prefix needed)' },
         { name: 'limit', type: 'int', default: 15 },

package/clis/reddit/user-posts.js

@@ -7,6 +7,7 @@ cli({
     domain: 'reddit.com',
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     args: [
         { name: 'username', type: 'string', required: true, positional: true, help: 'Reddit username (no `u/` prefix needed)' },
         { name: 'limit', type: 'int', default: 15 },

package/clis/reddit/user.js

@@ -7,6 +7,7 @@ cli({
     domain: 'reddit.com',
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     args: [
         { name: 'username', type: 'string', required: true, positional: true, help: 'Reddit username (no `u/` prefix needed)' },
     ],

package/clis/twitter/article.js

@@ -11,6 +11,7 @@ cli({
     domain: 'x.com',
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     args: [
         { name: 'tweet-id', type: 'string', positional: true, required: true, help: 'Tweet ID or URL containing the article' },
     ],
@@ -51,12 +52,16 @@ cli({
         // Navigate to the tweet page for cookie context
         await page.goto(`https://x.com/i/status/${tweetId}`);
         await page.wait(3);
+        // Read CSRF token directly from the cookie store via CDP — zero page.evaluate round-trip
+        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)');
         const queryId = await resolveTwitterQueryId(page, 'TweetResultByRestId', TWEET_RESULT_BY_REST_ID_QUERY_ID);
         const result = await page.evaluate(`
       async () => {
         const tweetId = "${tweetId}";
-        const ct0 = document.cookie.split(';').map(c=>c.trim()).find(c=>c.startsWith('ct0='))?.split('=')[1];
-        if (!ct0) return {error: 'No ct0 cookie — not logged into x.com'};
+        const ct0 = ${JSON.stringify(ct0)};
 
         const bearer = ${JSON.stringify(TWITTER_BEARER_TOKEN)};
         const headers = {
@@ -156,8 +161,6 @@ cli({
       }
     `);
         if (result?.error) {
-            if (String(result.error).includes('No ct0 cookie'))
-                throw new AuthRequiredError('x.com', result.error);
             throw new CommandExecutionError(result.error + (result.hint ? ` (${result.hint})` : ''));
         }
         return result || [];

package/clis/twitter/bookmark-folder.js

@@ -122,6 +122,7 @@ cli({
     domain: 'x.com',
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     args: [
         { name: 'folder-id', positional: true, type: 'string', required: true, help: 'Folder id from `opencli twitter bookmark-folders`.' },
         { name: 'limit', type: 'int', default: 20, help: 'Maximum number of bookmarks to return (default 20).' },
@@ -140,11 +141,8 @@ cli({
             throw new ArgumentError(`Invalid --limit: ${JSON.stringify(kwargs.limit)}. Expected a positive integer.`);
         }
 
-        await page.goto('https://x.com');
-        await page.wait(3);
-        const ct0 = await page.evaluate(`() => {
-            return document.cookie.split(';').map(c => c.trim()).find(c => c.startsWith('ct0='))?.split('=')[1] || null;
-        }`);
+        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)');
 

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

@@ -309,11 +309,13 @@ describe('twitter bookmark-folder command (registry)', () => {
         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 () => {
@@ -321,14 +323,15 @@ describe('twitter bookmark-folder command (registry)', () => {
         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('ct0-token')
                 .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([]);
-        const fetchScript = page.evaluate.mock.calls[2][0];
+        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

@@ -77,14 +77,12 @@ cli({
     domain: 'x.com',
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     args: [],
     columns: ['id', 'name', 'items', 'created_at'],
     func: async (page) => {
-        await page.goto('https://x.com');
-        await page.wait(3);
-        const ct0 = await page.evaluate(`() => {
-            return document.cookie.split(';').map(c => c.trim()).find(c => c.startsWith('ct0='))?.split('=')[1] || null;
-        }`);
+        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)');
 

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

@@ -143,8 +143,10 @@ describe('twitter bookmark-folders command (registry)', () => {
         const page = {
             goto: vi.fn().mockResolvedValue(undefined),
             wait: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn().mockResolvedValue(null), // null cookie → AuthRequired
+            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/bookmarks.js

@@ -105,6 +105,7 @@ cli({
     domain: 'x.com',
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     args: [
         { name: 'limit', type: 'int', default: 20, help: 'Maximum number of bookmarks to return (default 20).' },
         { name: 'top-by-engagement', type: 'int', default: 0, help: 'When set to N>0, re-rank the bookmarks by weighted engagement (likes×1 + retweets×3 + replies×2 + bookmarks×5 + log10(views+1)×0.5) and return the top N. Default 0 keeps the API\'s native (saved-time) ordering.' },
@@ -112,11 +113,8 @@ cli({
     columns: ['id', 'author', 'text', 'likes', 'retweets', 'bookmarks', 'created_at', 'url'],
     func: async (page, kwargs) => {
         const limit = kwargs.limit || 20;
-        await page.goto('https://x.com');
-        await page.wait(3);
-        const ct0 = await page.evaluate(`() => {
-      return document.cookie.split(';').map(c => c.trim()).find(c => c.startsWith('ct0='))?.split('=')[1] || null;
-    }`);
+        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)');
         const queryId = await page.evaluate(`async () => {

package/clis/twitter/download.js

@@ -15,6 +15,7 @@ cli({
     description: 'Download Twitter/X media (images and videos). Provide either <username> to scan a profile\'s media tab, or --tweet-url to download a single tweet.',
     domain: 'x.com',
     strategy: Strategy.COOKIE,
+    browserSession: { reuse: 'site' },
     args: [
         { name: 'username', positional: true, help: 'Twitter username (with or without @) to scan their /media tab. Either <username> or --tweet-url is required.' },
         { name: 'tweet-url', help: 'Single tweet URL to download. Use this OR <username>, not both required at once.' },

package/clis/twitter/followers.js

@@ -83,6 +83,7 @@ cli({
     domain: 'x.com',
     strategy: Strategy.UI,
     browser: true,
+    browserSession: { reuse: 'site' },
     args: [
         {
             name: 'user',

package/clis/twitter/following.js

@@ -139,6 +139,7 @@ cli({
     domain: 'x.com',
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     args: [
         {
             name: 'user',
@@ -157,12 +158,8 @@ cli({
         }
         let targetUser = normalizeScreenName(kwargs.user);
 
-        await page.goto('https://x.com');
-        await page.wait(3);
-
-        const ct0 = await page.evaluate(`() => {
-            return document.cookie.split(';').map(c => c.trim()).find(c => c.startsWith('ct0='))?.split('=')[1] || null;
-        }`);
+        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)');
 

package/clis/twitter/following.test.js

@@ -205,8 +205,8 @@ function createFollowingPage(followingResponses, { ct0 = 'token', userLookup = {
     const page = {
         goto: vi.fn().mockResolvedValue(undefined),
         wait: vi.fn().mockResolvedValue(undefined),
+        getCookies: vi.fn(async () => (ct0 ? [{ name: 'ct0', value: ct0 }] : [])),
         evaluate: vi.fn(async (script) => {
-            if (script.includes('document.cookie')) return ct0;
             if (script.includes('operationName')) return null;
             if (script.includes('/UserByScreenName')) return userLookup;
             if (script.includes('/Following')) return followingResponses.shift() || followingPayload([], null);
@@ -228,6 +228,7 @@ describe('twitter following command', () => {
         const rows = await command.func(page, { user: '@elonmusk', limit: 3 });
 
         expect(rows.map((row) => row.screen_name)).toEqual(['alice', 'bob', 'carol']);
+        expect(page.getCookies).toHaveBeenCalledWith({ url: 'https://x.com' });
         const userLookupScript = page.evaluate.mock.calls.find(([script]) => script.includes('/UserByScreenName'))?.[0] || '';
         expect(decodeURIComponent(userLookupScript)).toContain('"screen_name":"elonmusk"');
         expect(decodeURIComponent(userLookupScript)).not.toContain('"screen_name":"@elonmusk"');

package/clis/twitter/likes.js

@@ -142,6 +142,7 @@ cli({
     domain: 'x.com',
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     args: [
         { name: 'username', type: 'string', positional: true, help: 'Twitter screen name (with or without @). Defaults to the logged-in user when omitted.' },
         { name: 'limit', type: 'int', default: 20, help: 'Maximum number of liked tweets to return (default 20).' },
@@ -151,11 +152,8 @@ cli({
     func: async (page, kwargs) => {
         const limit = kwargs.limit || 20;
         let username = (kwargs.username || '').replace(/^@/, '');
-        await page.goto('https://x.com');
-        await page.wait(3);
-        const ct0 = await page.evaluate(`() => {
-      return document.cookie.split(';').map(c => c.trim()).find(c => c.startsWith('ct0='))?.split('=')[1] || null;
-    }`);
+        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)');
         // If no username provided, detect the logged-in user

package/clis/twitter/list-add.js

@@ -84,11 +84,12 @@ cli({
         if (!username) {
             throw new CommandExecutionError('Username is required');
         }
+        // Strategy.UI does not get a domain URL pre-nav from the framework.
+        // This page context is load-bearing for pre-target GraphQL calls below.
         await page.goto('https://x.com');
         await page.wait(3);
-        const ct0 = await page.evaluate(`() => {
-            return document.cookie.split(';').map(c => c.trim()).find(c => c.startsWith('ct0='))?.split('=')[1] || null;
-        }`);
+        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)');
 
         const userByScreenNameQueryId = await resolveTwitterQueryId(page, 'UserByScreenName', USER_BY_SCREEN_NAME_QUERY_ID);

package/clis/twitter/list-add.test.js

@@ -1,4 +1,4 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { getRegistry } from '@jackwener/opencli/registry';
 import './list-add.js';
 
@@ -12,4 +12,26 @@ describe('twitter list-add registration', () => {
         expect(listIdArg?.required).toBe(true);
         expect(listIdArg?.positional).toBe(true);
     });
+
+    it('keeps the x.com root navigation before pre-target GraphQL calls', async () => {
+        const cmd = getRegistry().get('twitter/list-add');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            getCookies: vi.fn().mockResolvedValue([{ name: 'ct0', value: 'token' }]),
+            evaluate: vi.fn()
+                .mockResolvedValueOnce(null) // UserByScreenName queryId fallback
+                .mockResolvedValueOnce('user-1')
+                .mockResolvedValueOnce(null) // ListsManagement queryId fallback
+                .mockResolvedValueOnce({}),
+        };
+
+        await expect(cmd.func(page, { listId: '123', username: 'alice' }))
+            .rejects
+            .toThrow(/List 123 not found/);
+        expect(page.goto).toHaveBeenCalledWith('https://x.com');
+        expect(page.goto).toHaveBeenCalledTimes(1);
+        expect(page.wait).toHaveBeenCalledWith(3);
+        expect(page.getCookies).toHaveBeenCalledWith({ url: 'https://x.com' });
+    });
 });