@jackwener/opencli 1.7.11 → 1.7.13

package/clis/tvmaze/tvmaze.test.js

@@ -0,0 +1,93 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import './search.js';
+import './show.js';
+
+afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+});
+
+describe('tvmaze search adapter', () => {
+    const cmd = getRegistry().get('tvmaze/search');
+
+    it('rejects empty query and bad limit before fetching', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+
+        await expect(cmd.func({ query: '', limit: 5 })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ query: 'foo', limit: 0 })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ query: 'foo', limit: 100 })).rejects.toThrow(ArgumentError);
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('maps HTTP 429 to CommandExecutionError', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('rate limited', { status: 429 })));
+        await expect(cmd.func({ query: 'foo', limit: 5 })).rejects.toThrow(CommandExecutionError);
+    });
+
+    it('throws EmptyResultError when no shows match', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('[]', { status: 200 })));
+        await expect(cmd.func({ query: 'asdfghjkl', limit: 5 })).rejects.toThrow(EmptyResultError);
+    });
+
+    it('strips HTML from summary and ids round-trip into tvmaze show <id>', async () => {
+        const list = [{
+            score: 1.2,
+            show: {
+                id: 169, name: 'Breaking Bad', type: 'Scripted', language: 'English',
+                genres: ['Drama'], status: 'Ended', premiered: '2008-01-20', ended: '2019-10-11',
+                network: { name: 'AMC' }, rating: { average: 9.2 },
+                summary: '<p><b>Breaking Bad</b> is a show with &amp; entities &#39;here&#39;, &#x27;hex&#x27;, and &hellip;.</p>',
+                url: 'https://www.tvmaze.com/shows/169/breaking-bad',
+            },
+        }];
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify(list), { status: 200 })));
+
+        const rows = await cmd.func({ query: 'breaking bad', limit: 5 });
+        expect(rows[0]).toMatchObject({
+            rank: 1, id: 169, name: 'Breaking Bad', network: 'AMC', rating: 9.2, matchScore: 1.2,
+        });
+        expect(rows[0].summary).toBe("Breaking Bad is a show with & entities 'here', 'hex', and ….");
+        // id round-trip
+        expect(typeof rows[0].id).toBe('number');
+    });
+});
+
+describe('tvmaze show adapter', () => {
+    const cmd = getRegistry().get('tvmaze/show');
+
+    it('rejects non-positive id before fetching', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+
+        await expect(cmd.func({ id: 0 })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ id: -5 })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ id: 'abc' })).rejects.toThrow(ArgumentError);
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('maps HTTP 404 to EmptyResultError', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('not found', { status: 404 })));
+        await expect(cmd.func({ id: 99999999 })).rejects.toThrow(EmptyResultError);
+    });
+
+    it('returns full show detail with externals + schedule', async () => {
+        const show = {
+            id: 169, name: 'Breaking Bad', type: 'Scripted', language: 'English', genres: ['Drama'],
+            status: 'Ended', premiered: '2008-01-20', ended: '2019-10-11', runtime: 60, averageRuntime: 60,
+            network: { name: 'AMC', country: { name: 'United States' } }, schedule: { time: '22:00', days: ['Sunday'] },
+            rating: { average: 9.2 }, externals: { imdb: 'tt0903747', thetvdb: 81189 },
+            officialSite: 'http://www.amc.com/shows/breaking-bad',
+            summary: '<p>Plain.</p>', url: 'https://www.tvmaze.com/shows/169/breaking-bad',
+        };
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify(show), { status: 200 })));
+
+        const rows = await cmd.func({ id: 169 });
+        expect(rows[0]).toMatchObject({
+            id: 169, name: 'Breaking Bad', country: 'United States', schedule: 'Sunday 22:00',
+            imdb: 'tt0903747', thetvdb: 81189, rating: 9.2, summary: 'Plain.',
+        });
+    });
+});

package/clis/tvmaze/utils.js

@@ -0,0 +1,110 @@
+// Shared helpers for the TVmaze adapters.
+//
+// TVmaze publishes a free, unauthenticated REST API at https://api.tvmaze.com.
+// Docs: https://www.tvmaze.com/api
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+export const TVMAZE_BASE = 'https://api.tvmaze.com';
+const UA = 'opencli-tvmaze-adapter (+https://github.com/jackwener/opencli)';
+
+export function requireString(value, label) {
+    const s = String(value ?? '').trim();
+    if (!s) throw new ArgumentError(`tvmaze ${label} cannot be empty`);
+    return s;
+}
+
+export function requireShowId(value) {
+    const raw = value;
+    const n = typeof raw === 'number' ? raw : Number(String(raw ?? '').trim());
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new ArgumentError(
+            'tvmaze show id is required and must be a positive integer',
+            'TVmaze show ids appear in the URL: https://www.tvmaze.com/shows/<id>/<slug>.',
+        );
+    }
+    return n;
+}
+
+export function requireBoundedInt(value, defaultValue, maxValue, label = 'limit') {
+    const raw = value ?? defaultValue;
+    const n = typeof raw === 'number' ? raw : Number(raw);
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new ArgumentError(`tvmaze ${label} must be a positive integer`);
+    }
+    if (n > maxValue) {
+        throw new ArgumentError(`tvmaze ${label} must be <= ${maxValue}`);
+    }
+    return n;
+}
+
+export async function tvmazeFetch(url, label) {
+    let resp;
+    try {
+        resp = await fetch(url, { headers: { 'user-agent': UA, accept: 'application/json' } });
+    }
+    catch (err) {
+        throw new CommandExecutionError(
+            `${label} request failed: ${err?.message ?? err}`,
+            'Check that api.tvmaze.com is reachable from this network.',
+        );
+    }
+    if (resp.status === 404) {
+        throw new EmptyResultError(label, `TVmaze returned 404 for ${url}.`);
+    }
+    if (resp.status === 429) {
+        throw new CommandExecutionError(
+            `${label} returned HTTP 429 (rate limited)`,
+            'TVmaze caps unauthenticated traffic at ~20 req/10s; wait a few seconds and retry.',
+        );
+    }
+    if (!resp.ok) {
+        throw new CommandExecutionError(`${label} returned HTTP ${resp.status}`);
+    }
+    let body;
+    try {
+        body = await resp.json();
+    }
+    catch (err) {
+        throw new CommandExecutionError(`${label} returned malformed JSON: ${err?.message ?? err}`);
+    }
+    return body;
+}
+
+const HTML_ENTITY_MAP = {
+    amp: '&',
+    lt: '<',
+    gt: '>',
+    quot: '"',
+    apos: "'",
+    nbsp: ' ',
+    rsquo: '’',
+    lsquo: '‘',
+    rdquo: '”',
+    ldquo: '“',
+    hellip: '…',
+    ndash: '–',
+    mdash: '—',
+};
+
+// TVmaze ships HTML in `summary` ("<p><b>...</b> ...</p>"). Strip tags + decode
+// named and numeric entities so output is plain text.
+export function stripHtml(html) {
+    if (html == null) return '';
+    let s = String(html);
+    s = s.replace(/<[^>]+>/g, '');
+    s = s
+        .replace(/&#x([0-9a-fA-F]+);/g, (_, hex) => {
+            const code = parseInt(hex, 16);
+            return Number.isFinite(code) ? String.fromCodePoint(code) : '';
+        })
+        .replace(/&#(\d+);/g, (_, dec) => {
+            const code = parseInt(dec, 10);
+            return Number.isFinite(code) ? String.fromCodePoint(code) : '';
+        })
+        .replace(/&([a-zA-Z]+);/g, (match, name) => HTML_ENTITY_MAP[name] ?? match);
+    return s.replace(/\s+/g, ' ').trim();
+}
+
+export function joinList(value) {
+    return Array.isArray(value) ? value.filter(Boolean).join(', ') : '';
+}

package/clis/twitter/accept.js

@@ -3,14 +3,15 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 cli({
     site: 'twitter',
     name: 'accept',
+    access: 'write',
     description: 'Auto-accept DM requests containing specific keywords',
     domain: 'x.com',
     strategy: Strategy.UI,
     browser: true,
-    timeoutSeconds: 600, // 10 min — batch operation iterating many conversations
     args: [
         { name: 'query', type: 'string', required: true, positional: true, help: 'Keywords to match (comma-separated for OR, e.g. "群,微信")' },
         { name: 'max', type: 'int', required: false, default: 20, help: 'Maximum number of requests to accept (default: 20)' },
+        { name: 'timeout', type: 'int', required: false, default: 600, help: 'Max seconds for the overall command (default: 600 — batch op)' },
     ],
     columns: ['index', 'status', 'user', 'message'],
     func: async (page, kwargs) => {

package/clis/twitter/article.js

@@ -5,6 +5,7 @@ const TWEET_RESULT_BY_REST_ID_QUERY_ID = '7xflPyRiUxGVbJd4uWmbfg';
 cli({
     site: 'twitter',
     name: 'article',
+    access: 'read',
     description: 'Fetch a Twitter Article (long-form content) and export as Markdown',
     domain: 'x.com',
     strategy: Strategy.COOKIE,

package/clis/twitter/block.js

@@ -3,6 +3,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 cli({
     site: 'twitter',
     name: 'block',
+    access: 'write',
     description: 'Block a Twitter user',
     domain: 'x.com',
     strategy: Strategy.UI,

package/clis/twitter/bookmark.js

@@ -3,6 +3,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 cli({
     site: 'twitter',
     name: 'bookmark',
+    access: 'write',
     description: 'Bookmark a tweet',
     domain: 'x.com',
     strategy: Strategy.UI,

package/clis/twitter/bookmarks.js

@@ -100,6 +100,7 @@ function parseBookmarks(data, seen) {
 cli({
     site: 'twitter',
     name: 'bookmarks',
+    access: 'read',
     description: 'Fetch Twitter/X bookmarks',
     domain: 'x.com',
     strategy: Strategy.COOKIE,
@@ -107,7 +108,7 @@ cli({
     args: [
         { name: 'limit', type: 'int', default: 20 },
     ],
-    columns: ['author', 'text', 'likes', 'retweets', 'bookmarks', 'url'],
+    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');

package/clis/twitter/delete.js

@@ -70,6 +70,7 @@ function buildDeleteScript(tweetId) {
 cli({
     site: 'twitter',
     name: 'delete',
+    access: 'write',
     description: 'Delete a specific tweet by URL',
     domain: 'x.com',
     strategy: Strategy.UI, // Utilizes internal DOM flows for interaction

package/clis/twitter/download.js

@@ -11,6 +11,7 @@ import { downloadMedia } from '@jackwener/opencli/download/media-download';
 cli({
     site: 'twitter',
     name: 'download',
+    access: 'read',
     description: '下载 Twitter/X 媒体（图片和视频）',
     domain: 'x.com',
     strategy: Strategy.COOKIE,

package/clis/twitter/follow.js

@@ -3,6 +3,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 cli({
     site: 'twitter',
     name: 'follow',
+    access: 'write',
     description: 'Follow a Twitter user',
     domain: 'x.com',
     strategy: Strategy.UI,

package/clis/twitter/followers.js

@@ -1,102 +1,168 @@
-import { AuthRequiredError, selectorError } from '@jackwener/opencli/errors';
+import { ArgumentError, AuthRequiredError, selectorError, EmptyResultError } from '@jackwener/opencli/errors';
 import { cli, Strategy } from '@jackwener/opencli/registry';
+
+/**
+ * Extract follower rows from Twitter/X follower-list SPA cells.
+ *
+ * Verified DOM shape on x.com followers list (confirmed live 2026-05-05):
+ *   - `[data-testid="UserCell"]` per follower
+ *     - `[data-testid="UserAvatar-Container-<handle>"]` — stable handle source
+ *     - `[data-testid="<userId>-follow"]` — follow button (i18n-independent)
+ *     - `[data-testid="userFollowIndicator"]` — "Follows you" badge when present
+ *     - the bio (when present) is rendered into `cell.innerText` but has NO
+ *       dedicated testid in the list view (`UserDescription` only appears on
+ *       the standalone profile page, NOT inside follower-list cells).
+ *
+ * Strategy: subtract the i18n-variable button / badge texts from the lines of
+ * `cell.innerText`, treat the first remaining `@…` line as the handle, the
+ * first non-handle line as display name, and the rest as bio. We avoid
+ * locale-coupled string matching (`"Follow"` / `"关注"` / `"Folgen"`).
+ *
+ * Note: Twitter does NOT render follower COUNTS in the list view, so the
+ * `followers` column is omitted from the output schema. Use
+ * `opencli twitter profile <user>` to read a per-user follower count.
+ */
+async function extractFollowersFromDOM(page) {
+    const script = `() => {
+        const cells = document.querySelectorAll('[data-testid="UserCell"]');
+        const out = [];
+        for (const cell of cells) {
+            // Collect i18n-variable UI strings to strip from the cell text.
+            const stripTexts = new Set();
+            const buttons = cell.querySelectorAll(
+                '[data-testid$="-follow"],[data-testid$="-unfollow"],[data-testid="userFollowIndicator"]'
+            );
+            for (const el of buttons) {
+                const t = (el.innerText || '').trim();
+                if (t) stripTexts.add(t);
+            }
+            const lines = (cell.innerText || '')
+                .split('\\n')
+                .map(s => s.trim())
+                .filter(Boolean)
+                .filter(l => !stripTexts.has(l));
+            // Pull the @handle line; fall back to UserAvatar-Container-<handle>.
+            let screen_name = '';
+            const remaining = [];
+            for (const l of lines) {
+                if (!screen_name && l.startsWith('@')) {
+                    screen_name = l.slice(1).split(/\\s/)[0];
+                } else {
+                    remaining.push(l);
+                }
+            }
+            if (!screen_name) {
+                const av = cell.querySelector('[data-testid^="UserAvatar-Container-"]');
+                const tid = av ? av.getAttribute('data-testid') || '' : '';
+                if (tid.startsWith('UserAvatar-Container-')) {
+                    screen_name = tid.slice('UserAvatar-Container-'.length);
+                }
+            }
+            // First non-handle line is display name (may equal handle when the user hasn't set one).
+            const name = remaining[0] || screen_name;
+            // Lines past the display name form the bio.
+            const bio = remaining.slice(1).join(' ').replace(/\\s+/g, ' ').trim();
+            if (screen_name) {
+                out.push({ screen_name, name, bio });
+            }
+        }
+        return out;
+    }`;
+    return page.evaluate(script);
+}
+
+function normalizeScreenName(value) {
+    return String(value ?? '').trim().replace(/^\/+/, '').replace(/^@+/, '');
+}
+
 cli({
     site: 'twitter',
     name: 'followers',
+    access: 'read',
     description: 'Get accounts following a Twitter/X user',
     domain: 'x.com',
-    strategy: Strategy.INTERCEPT,
+    strategy: Strategy.UI,
     browser: true,
     args: [
         { name: 'user', positional: true, type: 'string', required: false },
         { name: 'limit', type: 'int', default: 50 },
     ],
-    columns: ['screen_name', 'name', 'bio', 'followers'],
+    // `followers` (count) is NOT exposed: the SPA followers-list view does not
+    // render it. Use `twitter profile <user>` for per-user follower counts.
+    columns: ['screen_name', 'name', 'bio'],
     func: async (page, kwargs) => {
-        let targetUser = kwargs.user;
-        // If no user is specified, figure out the logged-in user's handle
+        const limit = kwargs.limit;
+        if (!Number.isInteger(limit) || limit <= 0) {
+            throw new ArgumentError('limit must be a positive integer');
+        }
+
+        let targetUser = normalizeScreenName(kwargs.user);
         if (!targetUser) {
             await page.goto('https://x.com/home');
             await page.wait({ selector: '[data-testid="primaryColumn"]' });
             const href = await page.evaluate(`() => {
-            const link = document.querySelector('a[data-testid="AppTabBar_Profile_Link"]');
-            return link ? link.getAttribute('href') : null;
-        }`);
+                const link = document.querySelector('a[data-testid="AppTabBar_Profile_Link"]');
+                return link ? link.getAttribute('href') : null;
+            }`);
             if (!href) {
                 throw new AuthRequiredError('x.com', 'Could not find logged-in user profile link. Are you logged in?');
             }
-            targetUser = href.replace('/', '');
+            targetUser = normalizeScreenName(href);
         }
+        if (!targetUser) {
+            throw new ArgumentError('twitter followers user cannot be empty', 'Example: opencli twitter followers @elonmusk --limit 100');
+        }
+
         // 1. Navigate to profile page
         await page.goto(`https://x.com/${targetUser}`);
         await page.wait(3);
-        // 2. Install interceptor BEFORE SPA navigation.
-        //    goto() resets JS context, but SPA click preserves it.
-        await page.installInterceptor('Followers');
-        // 3. Click the followers link via SPA navigation (preserves interceptor).
-        //    Twitter uses /verified_followers instead of /followers now.
+
+        // 2. Click the followers tab via SPA navigation (preserves session/state).
+        //    Twitter sometimes only renders /verified_followers on profiles with
+        //    badge filtering enabled; try the canonical link first, fall back.
         const safeUser = JSON.stringify(targetUser);
         const clicked = await page.evaluate(`() => {
-        const target = ${safeUser};
-        const selectors = [
-            'a[href="/' + target + '/verified_followers"]',
-            'a[href="/' + target + '/followers"]',
-        ];
-        for (const sel of selectors) {
-            const link = document.querySelector(sel);
-            if (link) { link.click(); return true; }
-        }
-        return false;
-    }`);
+            const target = ${safeUser};
+            const selectors = [
+                'a[href="/' + target + '/followers"]',
+                'a[href="/' + target + '/verified_followers"]',
+            ];
+            for (const sel of selectors) {
+                const link = document.querySelector(sel);
+                if (link) { link.click(); return true; }
+            }
+            return false;
+        }`);
         if (!clicked) {
             throw selectorError('Twitter followers link', 'Twitter may have changed the layout.');
         }
-        await page.waitForCapture(5);
-        // 4. Scroll to trigger pagination API calls
-        await page.autoScroll({ times: Math.ceil(kwargs.limit / 20), delayMs: 2000 });
-        // 5. Retrieve intercepted data
-        const requests = await page.getInterceptedRequests();
-        const requestList = Array.isArray(requests) ? requests : [];
-        if (requestList.length === 0) {
-            return [];
-        }
-        let results = [];
-        for (const req of requestList) {
-            try {
-                // GraphQL response: { data: { user: { result: { timeline: ... } } } }
-                let instructions = req.data?.user?.result?.timeline?.timeline?.instructions;
-                if (!instructions)
-                    continue;
-                let addEntries = instructions.find((i) => i.type === 'TimelineAddEntries');
-                if (!addEntries) {
-                    addEntries = instructions.find((i) => i.entries && Array.isArray(i.entries));
-                }
-                if (!addEntries)
-                    continue;
-                for (const entry of addEntries.entries) {
-                    if (!entry.entryId.startsWith('user-'))
-                        continue;
-                    const item = entry.content?.itemContent?.user_results?.result;
-                    if (!item || item.__typename !== 'User')
-                        continue;
-                    const core = item.core || {};
-                    const legacy = item.legacy || {};
-                    results.push({
-                        screen_name: core.screen_name || legacy.screen_name || 'unknown',
-                        name: core.name || legacy.name || 'unknown',
-                        bio: legacy.description || item.profile_bio?.description || '',
-                        followers: legacy.followers_count || legacy.normal_followers_count || 0
-                    });
-                }
+
+        // 3. Wait for follower cells to appear
+        await page.wait({ selector: '[data-testid="UserCell"]', timeout: 10000 });
+
+        // 4. Extract from DOM, scroll to load more, dedupe by screen_name
+        const allFollowers = [];
+        const seen = new Set();
+        let sameCount = 0;
+        while (allFollowers.length < limit && sameCount < 3) {
+            const followers = await extractFollowersFromDOM(page);
+            const newFollowers = followers.filter(f => !seen.has(f.screen_name));
+            for (const f of newFollowers) {
+                seen.add(f.screen_name);
+                allFollowers.push(f);
             }
-            catch (e) {
-                // ignore parsing errors for individual payloads
+            if (newFollowers.length === 0) {
+                sameCount++;
+            } else {
+                sameCount = 0;
             }
+            if (allFollowers.length >= limit) break;
+            await page.autoScroll({ times: 1, delayMs: 500 });
+            await page.wait(2);
+        }
+        if (allFollowers.length === 0) {
+            throw new EmptyResultError('twitter followers', `No followers found for @${targetUser}`);
         }
-        // Deduplicate by screen_name
-        const unique = new Map();
-        results.forEach(r => unique.set(r.screen_name, r));
-        const deduplicatedResults = Array.from(unique.values());
-        return deduplicatedResults.slice(0, kwargs.limit);
+        return allFollowers.slice(0, limit);
     }
 });

package/clis/twitter/following.js

@@ -134,6 +134,7 @@ function normalizeScreenName(value) {
 cli({
     site: 'twitter',
     name: 'following',
+    access: 'read',
     description: 'Get accounts a Twitter/X user is following',
     domain: 'x.com',
     strategy: Strategy.COOKIE,

package/clis/twitter/hide-reply.js

@@ -3,6 +3,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 cli({
     site: 'twitter',
     name: 'hide-reply',
+    access: 'write',
     description: 'Hide a reply on your tweet (useful for hiding bot/spam replies)',
     domain: 'x.com',
     strategy: Strategy.UI,

package/clis/twitter/like.js

@@ -3,6 +3,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 cli({
     site: 'twitter',
     name: 'like',
+    access: 'write',
     description: 'Like a specific tweet',
     domain: 'x.com',
     strategy: Strategy.UI, // Utilizes internal DOM flows for interaction

package/clis/twitter/likes.js

@@ -137,6 +137,7 @@ function parseLikes(data, seen) {
 cli({
     site: 'twitter',
     name: 'likes',
+    access: 'read',
     description: 'Fetch liked tweets of a Twitter user',
     domain: 'x.com',
     strategy: Strategy.COOKIE,
@@ -145,7 +146,7 @@ cli({
         { name: 'username', type: 'string', positional: true, help: 'Twitter screen name (without @). Defaults to logged-in user.' },
         { name: 'limit', type: 'int', default: 20 },
     ],
-    columns: ['author', 'name', 'text', 'likes', 'url', 'has_media', 'media_urls'],
+    columns: ['id', 'author', 'name', 'text', 'likes', 'retweets', 'created_at', 'url', 'has_media', 'media_urls'],
     func: async (page, kwargs) => {
         const limit = kwargs.limit || 20;
         let username = (kwargs.username || '').replace(/^@/, '');

package/clis/twitter/list-add.js

@@ -65,6 +65,7 @@ function buildUserByScreenNameUrl(queryId, screenName) {
 cli({
     site: 'twitter',
     name: 'list-add',
+    access: 'write',
     description: 'Add a user to a Twitter/X list you own (no-op if already a member)',
     domain: 'x.com',
     strategy: Strategy.UI,

package/clis/twitter/list-remove.js

@@ -74,6 +74,7 @@ export function interpretRemoveResponse(status, json) {
 cli({
     site: 'twitter',
     name: 'list-remove',
+    access: 'write',
     description: 'Remove a user from a Twitter/X list you own (toggles via UI; no-op if not currently a member)',
     domain: 'x.com',
     strategy: Strategy.UI,

package/clis/twitter/list-tweets.js

@@ -107,6 +107,7 @@ export function parseListTimeline(data, seen) {
 cli({
     site: 'twitter',
     name: 'list-tweets',
+    access: 'read',
     description: 'Fetch tweets from a Twitter/X list timeline',
     domain: 'x.com',
     strategy: Strategy.COOKIE,

package/clis/twitter/lists.js

@@ -87,6 +87,7 @@ export function parseListsManagement(data, seen) {
 export const command = cli({
     site: 'twitter',
     name: 'lists',
+    access: 'read',
     description: 'Get Twitter/X lists for the logged-in user (owned + subscribed)',
     domain: 'x.com',
     strategy: Strategy.COOKIE,

package/clis/twitter/notifications.js

@@ -3,6 +3,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 cli({
     site: 'twitter',
     name: 'notifications',
+    access: 'read',
     description: 'Get Twitter/X notifications',
     domain: 'x.com',
     strategy: Strategy.INTERCEPT,

package/clis/twitter/post.js

@@ -185,6 +185,7 @@ async function submitTweet(page, text) {
 cli({
     site: 'twitter',
     name: 'post',
+    access: 'write',
     description: 'Post a new tweet/thread',
     domain: 'x.com',
     strategy: Strategy.UI,

package/clis/twitter/profile.js

@@ -5,6 +5,7 @@ const USER_BY_SCREEN_NAME_QUERY_ID = 'qRednkZG-rn1P6b48NINmQ';
 cli({
     site: 'twitter',
     name: 'profile',
+    access: 'read',
     description: 'Fetch a Twitter user profile (bio, stats, etc.)',
     domain: 'x.com',
     strategy: Strategy.COOKIE,