rsshub 1.0.0-master.f71451d → 1.0.0-master.f72af1b

package/lib/routes/twitter/api/web-api/constants.ts

@@ -1,46 +1,77 @@
-const baseUrl = 'https://twitter.com/i/api';
+const baseUrl = 'https://x.com/i/api';
 
 const graphQLEndpointsPlain = [
-    '/graphql/eS7LO5Jy3xgmd3dbL044EA/UserTweets',
-    '/graphql/k5XapwcSikNsEsILW5FvgA/UserByScreenName',
-    '/graphql/k3YiLNE_MAy5J-NANLERdg/HomeTimeline',
-    '/graphql/3GeIaLmNhTm1YsUmxR57tg/UserTweetsAndReplies',
-    '/graphql/TOU4gQw8wXIqpSzA4TYKgg/UserMedia',
-    '/graphql/B8I_QCljDBVfin21TTWMqA/Likes',
+    '/graphql/E3opETHurmVJflFsUBVuUQ/UserTweets',
+    '/graphql/Yka-W8dz7RaEuQNkroPkYw/UserByScreenName',
+    '/graphql/HJFjzBgCs16TqxewQOeLNg/HomeTimeline',
+    '/graphql/DiTkXJgLqBBxCs7zaYsbtA/HomeLatestTimeline',
+    '/graphql/bt4TKuFz4T7Ckk-VvQVSow/UserTweetsAndReplies',
+    '/graphql/dexO_2tohK86JDudXXG3Yw/UserMedia',
     '/graphql/tD8zKvQzwY3kdx5yz6YmOw/UserByRestId',
-    '/graphql/flaR-PUMshxFWZWPNpq4zA/SearchTimeline',
-    '/graphql/TOTgqavWmxywKv5IbMMK1w/ListLatestTweetsTimeline',
+    '/graphql/UN1i3zUiCWa-6r-Uaho4fw/SearchTimeline',
+    '/graphql/Pa45JvqZuKcW1plybfgBlQ/ListLatestTweetsTimeline',
+    '/graphql/QuBlQ6SxNAQCt6-kBiCXCQ/TweetDetail',
 ];
 
 const gqlMap = Object.fromEntries(graphQLEndpointsPlain.map((endpoint) => [endpoint.split('/')[3].replace(/V2$|Query$|QueryV2$/, ''), endpoint]));
 
 const gqlFeatureUser = {
-    hidden_profile_likes_enabled: true,
     hidden_profile_subscriptions_enabled: true,
+    rweb_tipjar_consumption_enabled: true,
     responsive_web_graphql_exclude_directive_enabled: true,
     verified_phone_label_enabled: false,
     subscriptions_verification_info_is_identity_verified_enabled: true,
     subscriptions_verification_info_verified_since_enabled: true,
     highlights_tweets_tab_ui_enabled: true,
     responsive_web_twitter_article_notes_tab_enabled: true,
+    subscriptions_feature_can_gift_premium: true,
     creator_subscriptions_tweet_preview_api_enabled: true,
     responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
     responsive_web_graphql_timeline_navigation_enabled: true,
 };
 const gqlFeatureFeed = {
+    rweb_tipjar_consumption_enabled: true,
     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,
+    communities_web_enable_tweet_community_results_fetch: true,
     c9s_tweet_anatomy_moderator_badge_enabled: true,
-    tweetypie_unmention_optimization_enabled: true,
+    articles_preview_enabled: true,
     responsive_web_edit_tweet_api_enabled: true,
     graphql_is_translatable_rweb_tweet_is_translatable_enabled: true,
     view_counts_everywhere_api_enabled: true,
     longform_notetweets_consumption_enabled: true,
     responsive_web_twitter_article_tweet_consumption_enabled: true,
     tweet_awards_web_tipping_enabled: false,
+    creator_subscriptions_quote_tweet_preview_enabled: false,
+    freedom_of_speech_not_reach_fetch_enabled: true,
+    standardized_nudges_misinfo: true,
+    tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled: true,
+    rweb_video_timestamps_enabled: true,
+    longform_notetweets_rich_text_read_enabled: true,
+    longform_notetweets_inline_media_enabled: true,
+    responsive_web_enhance_cards_enabled: false,
+};
+
+const TweetDetailFeatures = {
+    rweb_tipjar_consumption_enabled: true,
+    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,
+    communities_web_enable_tweet_community_results_fetch: true,
+    c9s_tweet_anatomy_moderator_badge_enabled: true,
+    articles_preview_enabled: true,
+    responsive_web_edit_tweet_api_enabled: true,
+    graphql_is_translatable_rweb_tweet_is_translatable_enabled: true,
+    view_counts_everywhere_api_enabled: true,
+    longform_notetweets_consumption_enabled: true,
+    responsive_web_twitter_article_tweet_consumption_enabled: true,
+    tweet_awards_web_tipping_enabled: false,
+    creator_subscriptions_quote_tweet_preview_enabled: false,
     freedom_of_speech_not_reach_fetch_enabled: true,
     standardized_nudges_misinfo: true,
     tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled: true,
@@ -58,6 +89,9 @@ const gqlFeatures = {
     SearchTimeline: gqlFeatureFeed,
     ListLatestTweetsTimeline: gqlFeatureFeed,
     HomeTimeline: gqlFeatureFeed,
+    HomeLatestTimeline: TweetDetailFeatures,
+    TweetDetail: TweetDetailFeatures,
+    Likes: gqlFeatureFeed,
 };
 
 const timelineParams = {

package/lib/routes/twitter/api/web-api/login.ts

@@ -0,0 +1,75 @@
+import { authenticator } from 'otplib';
+import logger from '@/utils/logger';
+import cache from '@/utils/cache';
+import { RateLimiterMemory, RateLimiterRedis, RateLimiterQueue } from 'rate-limiter-flexible';
+import puppeteer from '@/utils/puppeteer';
+import { CookieJar } from 'tough-cookie';
+
+const loginLimiter = cache.clients.redisClient
+    ? new RateLimiterRedis({
+          points: 1,
+          duration: 20,
+          execEvenly: true,
+          storeClient: cache.clients.redisClient,
+      })
+    : new RateLimiterMemory({
+          points: 1,
+          duration: 20,
+          execEvenly: true,
+      });
+
+const loginLimiterQueue = new RateLimiterQueue(loginLimiter);
+
+async function login({ username, password, authenticationSecret }) {
+    if (!username || !password) {
+        return;
+    }
+    try {
+        await loginLimiterQueue.removeTokens(1);
+
+        const cookieJar = new CookieJar();
+        const browser = await puppeteer({
+            stealth: true,
+        });
+        const page = await browser.newPage();
+        await page.goto('https://x.com/i/flow/login');
+        await page.waitForSelector('input[autocomplete="username"]');
+        await page.type('input[autocomplete="username"]', username);
+        const buttons = await page.$$('button');
+        await buttons[3]?.click();
+        await page.waitForSelector('input[autocomplete="current-password"]');
+        await page.type('input[autocomplete="current-password"]', password);
+        (await page.waitForSelector('button[data-testid="LoginForm_Login_Button"]'))?.click();
+        if (authenticationSecret) {
+            await page.waitForSelector('input[inputmode="numeric"]');
+            const token = authenticator.generate(authenticationSecret);
+            await page.type('input[inputmode="numeric"]', token);
+            (await page.waitForSelector('button[data-testid="ocfEnterTextNextButton"]'))?.click();
+        }
+        const waitForRequest = new Promise<string>((resolve) => {
+            page.on('response', async (response) => {
+                if (response.url().includes('/HomeTimeline')) {
+                    const data = await response.json();
+                    const message = data?.data?.home?.home_timeline_urt?.instructions?.[0]?.entries?.[0]?.entryId;
+                    if (message === 'messageprompt-suspended-prompt') {
+                        logger.error(`twitter debug: twitter username ${username} login failed: messageprompt-suspended-prompt`);
+                        resolve('');
+                    }
+                    const cookies = await page.cookies();
+                    for (const cookie of cookies) {
+                        cookieJar.setCookieSync(`${cookie.name}=${cookie.value}`, 'https://x.com');
+                    }
+                    logger.debug(`twitter debug: twitter username ${username} login success`);
+                    resolve(JSON.stringify(cookieJar.serializeSync()));
+                }
+            });
+        });
+        const cookieString = await waitForRequest;
+        await browser.close();
+        return cookieString;
+    } catch (error) {
+        logger.error(`twitter debug: twitter username ${username} login failed:`, error);
+    }
+}
+
+export default login;

package/lib/routes/twitter/api/web-api/utils.ts

@@ -1,50 +1,178 @@
 import ConfigNotFoundError from '@/errors/types/config-not-found';
 import { baseUrl, gqlFeatures, bearerToken, gqlMap } from './constants';
 import { config } from '@/config';
-import got from '@/utils/got';
 import queryString from 'query-string';
-import { Cookie } from 'tough-cookie';
+import { Cookie, CookieJar } from 'tough-cookie';
+import { CookieAgent, CookieClient } from 'http-cookie-agent/undici';
+import { ProxyAgent } from 'undici';
+import cache from '@/utils/cache';
+import logger from '@/utils/logger';
+import ofetch from '@/utils/ofetch';
+import proxy from '@/utils/proxy';
+import login from './login';
+
+let authTokenIndex = 0;
+
+const token2Cookie = (token) =>
+    cache.tryGet(`twitter:cookie:${token}`, async () => {
+        const jar = new CookieJar();
+        jar.setCookieSync(`auth_token=${token}`, 'https://x.com');
+        try {
+            const agent = proxy.proxyUri
+                ? new ProxyAgent({
+                      factory: (origin, opts) => new CookieClient(origin as string, { ...opts, cookies: { jar } }),
+                      uri: proxy.proxyUri,
+                  })
+                : new CookieAgent({ cookies: { jar } });
+            await ofetch('https://x.com', {
+                dispatcher: agent,
+            });
+            return JSON.stringify(jar.serializeSync());
+        } catch {
+            // ignore
+            return '';
+        }
+    });
+
+const getAuth = async (retry: number) => {
+    if (config.twitter.authToken && retry > 0) {
+        const index = authTokenIndex++ % config.twitter.authToken.length;
+        const token = config.twitter.authToken[index];
+        const lock = await cache.get(`twitter:lock-token:${token}`);
+        if (lock) {
+            await new Promise((resolve) => setTimeout(resolve, Math.random() * 500 + 500));
+            return await getAuth(retry - 1);
+        } else {
+            logger.debug(`twitter debug: lock twitter cookie for token ${token}`);
+            await cache.set(`twitter:lock-token:${token}`, '1', 20);
+            return {
+                token,
+                username: config.twitter.username?.[index],
+                password: config.twitter.password?.[index],
+                authenticationSecret: config.twitter.authenticationSecret?.[index],
+            };
+        }
+    }
+};
 
 export const twitterGot = async (url, params) => {
-    if (!config.twitter.cookie) {
-        throw new ConfigNotFoundError('Twitter cookie is not configured');
+    const auth = await getAuth(30);
+
+    if (!auth) {
+        throw new ConfigNotFoundError('No valid Twitter token found');
+    }
+
+    const requestUrl = `${url}?${queryString.stringify(params)}`;
+
+    let cookie: string | Record<string, any> | null | undefined = await token2Cookie(auth.token);
+    if (!cookie) {
+        cookie = await login({
+            username: auth.username,
+            password: auth.password,
+            authenticationSecret: auth.authenticationSecret,
+        });
+    }
+    let dispatchers:
+        | {
+              jar: CookieJar;
+              agent: CookieAgent | ProxyAgent;
+          }
+        | undefined;
+    if (cookie) {
+        logger.debug(`twitter debug: got twitter cookie for token ${auth.token}`);
+        if (typeof cookie === 'string') {
+            cookie = JSON.parse(cookie);
+        }
+        const jar = CookieJar.deserializeSync(cookie as any);
+        const agent = proxy.proxyUri
+            ? new ProxyAgent({
+                  factory: (origin, opts) => new CookieClient(origin as string, { ...opts, cookies: { jar } }),
+                  uri: proxy.proxyUri,
+              })
+            : new CookieAgent({ cookies: { jar } });
+        if (proxy.proxyUri) {
+            logger.debug(`twitter debug: Proxying request: ${requestUrl}`);
+        }
+        dispatchers = {
+            jar,
+            agent,
+        };
+    } else {
+        throw new ConfigNotFoundError(`Twitter cookie for token ${auth.token} is not valid`);
     }
     const jsonCookie = Object.fromEntries(
-        config.twitter.cookie
+        dispatchers.jar
+            .getCookieStringSync(url)
             .split(';')
             .map((c) => Cookie.parse(c)?.toJSON())
             .map((c) => [c?.key, c?.value])
     );
-    if (!jsonCookie || !jsonCookie.auth_token || !jsonCookie.ct0) {
-        throw new ConfigNotFoundError('Twitter cookie is not valid');
-    }
 
-    const requestData = {
-        url: `${url}?${queryString.stringify(params)}`,
-        method: 'GET',
+    const response = await ofetch.raw(requestUrl, {
+        retry: 0,
         headers: {
-            authority: 'twitter.com',
+            authority: 'x.com',
             accept: '*/*',
             'accept-language': 'en-US,en;q=0.9',
             authorization: bearerToken,
             'cache-control': 'no-cache',
             'content-type': 'application/json',
-            cookie: config.twitter.cookie,
             dnt: '1',
             pragma: 'no-cache',
-            referer: 'https://twitter.com/narendramodi',
-            'x-csrf-token': jsonCookie.ct0,
+            referer: 'https://x.com/narendramodi',
             'x-twitter-active-user': 'yes',
             'x-twitter-auth-type': 'OAuth2Session',
             'x-twitter-client-language': 'en',
+            'x-csrf-token': jsonCookie.ct0,
+        },
+        dispatcher: dispatchers.agent,
+        onResponse: async ({ response }) => {
+            if (response.status === 429) {
+                logger.debug(`twitter debug: twitter rate limit exceeded for token ${auth.token}`);
+                await cache.set(`twitter:lock-token:${auth.token}`, '1', 1000);
+            } else if (response.status === 403 || response.status === 401 || JSON.stringify(response._data?.data) === '{"user":{}}') {
+                const newCookie = await login({
+                    username: auth.username,
+                    password: auth.password,
+                    authenticationSecret: auth.authenticationSecret,
+                });
+                if (newCookie) {
+                    logger.debug(`twitter debug: reset twitter cookie for token ${auth.token}, ${newCookie}`);
+                    await cache.set(`twitter:cookie:${auth.token}`, newCookie, config.cache.contentExpire);
+                    logger.debug(`twitter debug: unlock twitter cookie with error1 for token ${auth.token}`);
+                    await cache.set(`twitter:lock-token:${auth.token}`, '', 1);
+                } else {
+                    const tokenIndex = config.twitter.authToken?.indexOf(auth.token);
+                    if (tokenIndex !== undefined && tokenIndex !== -1) {
+                        config.twitter.authToken?.splice(tokenIndex, 1);
+                    }
+                    if (auth.username) {
+                        const usernameIndex = config.twitter.username?.indexOf(auth.username);
+                        if (usernameIndex !== undefined && usernameIndex !== -1) {
+                            config.twitter.username?.splice(usernameIndex, 1);
+                        }
+                    }
+                    if (auth.password) {
+                        const passwordIndex = config.twitter.password?.indexOf(auth.password);
+                        if (passwordIndex !== undefined && passwordIndex !== -1) {
+                            config.twitter.password?.splice(passwordIndex, 1);
+                        }
+                    }
+                    logger.debug(`twitter debug: delete twitter cookie for token ${auth.token}, remaining tokens: ${config.twitter.authToken?.length}`);
+                    await cache.set(`twitter:lock-token:${auth.token}`, '1', 86400);
+                }
+            }
         },
-    };
-
-    const response = await got(requestData.url, {
-        headers: requestData.headers,
     });
 
-    return response.data;
+    if (auth.token) {
+        logger.debug(`twitter debug: update twitter cookie for token ${auth.token}`);
+        await cache.set(`twitter:cookie:${auth.token}`, JSON.stringify(dispatchers.jar.serializeSync()), config.cache.contentExpire);
+        logger.debug(`twitter debug: unlock twitter cookie with success for token ${auth.token}`);
+        await cache.set(`twitter:lock-token:${auth.token}`, '', 1);
+    }
+
+    return response._data;
 };
 
 export const paginationTweets = async (endpoint: string, userId: number | undefined, variables: Record<string, any>, path?: string[]) => {
@@ -55,7 +183,6 @@ export const paginationTweets = async (endpoint: string, userId: number | undefi
         }),
         features: JSON.stringify(gqlFeatures[endpoint]),
     });
-
     let instructions;
     if (path) {
         instructions = data;
@@ -64,12 +191,17 @@ export const paginationTweets = async (endpoint: string, userId: number | undefi
         }
         instructions = instructions.instructions;
     } else {
-        instructions = data.user.result.timeline_v2.timeline.instructions;
+        if (data?.user?.result?.timeline_v2?.timeline?.instructions) {
+            instructions = data.user.result.timeline_v2.timeline.instructions;
+        } else {
+            // throw new Error('Because Twitter Premium has features that hide your likes, this RSS link is not available for Twitter Premium accounts.');
+            logger.debug(`twitter debug: instructions not found in data: ${JSON.stringify(data)}`);
+        }
     }
 
-    const entries1 = instructions.find((i) => i.type === 'TimelineAddToModule')?.moduleItems; // Media
-    const entries2 = instructions.find((i) => i.type === 'TimelineAddEntries').entries;
-    return entries1 || entries2;
+    const entries1 = instructions?.find((i) => i.type === 'TimelineAddToModule')?.moduleItems; // Media
+    const entries2 = instructions?.find((i) => i.type === 'TimelineAddEntries').entries;
+    return entries1 || entries2 || [];
 };
 
 export function gatherLegacyFromData(entries: any[], filterNested?: string[], userId?: number | string) {
@@ -121,5 +253,6 @@ export function gatherLegacyFromData(entries: any[], filterNested?: string[], us
             }
         }
     }
+
     return tweets;
 }

package/lib/routes/twitter/home-latest.ts

@@ -0,0 +1,60 @@
+import { Route } from '@/types';
+import utils from './utils';
+import api from './api';
+
+export const route: Route = {
+    path: '/home_latest/:routeParams?',
+    categories: ['social-media'],
+    example: '/twitter/home_latest',
+    features: {
+        requireConfig: [
+            {
+                name: 'TWITTER_USERNAME',
+                description: 'Please see above for details.',
+            },
+            {
+                name: 'TWITTER_PASSWORD',
+                description: 'Please see above for details.',
+            },
+            {
+                name: 'TWITTER_AUTH_TOKEN',
+                description: 'Please see above for details.',
+            },
+        ],
+        requirePuppeteer: false,
+        antiCrawler: false,
+        supportBT: false,
+        supportPodcast: false,
+        supportScihub: false,
+    },
+    name: 'Home latest timeline',
+    maintainers: ['DIYgod', 'CaoMeiYouRen'],
+    handler,
+    radar: [
+        {
+            source: ['x.com/home'],
+            target: '/home_latest',
+        },
+    ],
+};
+
+async function handler(ctx) {
+    // For compatibility
+    const { count, include_rts } = utils.parseRouteParams(ctx.req.param('routeParams'));
+    const params = count ? { count } : {};
+
+    await api.init();
+    let data = await api.getHomeLatestTimeline('', params);
+    if (!include_rts) {
+        data = utils.excludeRetweet(data);
+    }
+
+    return {
+        title: `Twitter following timeline`,
+        link: `https://x.com/home`,
+        // description: userInfo?.description,
+        item: utils.ProcessFeed(ctx, {
+            data,
+        }),
+    };
+}

package/lib/routes/twitter/home.ts

@@ -17,7 +17,7 @@ export const route: Route = {
                 description: 'Please see above for details.',
             },
             {
-                name: 'TWITTER_COOKIE',
+                name: 'TWITTER_AUTH_TOKEN',
                 description: 'Please see above for details.',
             },
         ],
@@ -28,11 +28,11 @@ export const route: Route = {
         supportScihub: false,
     },
     name: 'Home timeline',
-    maintainers: ['DIYgod'],
+    maintainers: ['DIYgod', 'CaoMeiYouRen'],
     handler,
     radar: [
         {
-            source: ['twitter.com/home'],
+            source: ['x.com/home'],
             target: '/home',
         },
     ],
@@ -51,7 +51,7 @@ async function handler(ctx) {
 
     return {
         title: `Twitter following timeline`,
-        link: `https://twitter.com/home`,
+        link: `https://x.com/home`,
         // description: userInfo?.description,
         item: utils.ProcessFeed(ctx, {
             data,

package/lib/routes/twitter/keyword.ts

@@ -1,10 +1,11 @@
-import { Route } from '@/types';
+import { Route, ViewType } from '@/types';
 import api from './api';
 import utils from './utils';
 
 export const route: Route = {
     path: '/keyword/:keyword/:routeParams?',
-    categories: ['social-media'],
+    categories: ['social-media', 'popular'],
+    view: ViewType.SocialMedia,
     example: '/twitter/keyword/RSSHub',
     parameters: { keyword: 'keyword', routeParams: 'extra parameters, see the table above' },
     features: {
@@ -18,7 +19,7 @@ export const route: Route = {
                 description: 'Please see above for details.',
             },
             {
-                name: 'TWITTER_COOKIE',
+                name: 'TWITTER_AUTH_TOKEN',
                 description: 'Please see above for details.',
             },
         ],
@@ -33,7 +34,7 @@ export const route: Route = {
     handler,
     radar: [
         {
-            source: ['twitter.com/search'],
+            source: ['x.com/search'],
         },
     ],
 };
@@ -45,7 +46,7 @@ async function handler(ctx) {
 
     return {
         title: `Twitter Keyword - ${keyword}`,
-        link: `https://twitter.com/search?q=${encodeURIComponent(keyword)}`,
+        link: `https://x.com/search?q=${encodeURIComponent(keyword)}`,
         item: utils.ProcessFeed(ctx, {
             data,
         }),

package/lib/routes/twitter/likes.ts

@@ -1,7 +1,6 @@
 import { Route } from '@/types';
 import utils from './utils';
-import { config } from '@/config';
-import ConfigNotFoundError from '@/errors/types/config-not-found';
+import api from './api';
 
 export const route: Route = {
     path: '/likes/:id/:routeParams?',
@@ -9,7 +8,12 @@ export const route: Route = {
     example: '/twitter/likes/DIYgod',
     parameters: { id: 'username', routeParams: 'extra parameters, see the table above' },
     features: {
-        requireConfig: false,
+        requireConfig: [
+            {
+                name: 'TWITTER_AUTH_TOKEN',
+                description: 'Please see above for details.',
+            },
+        ],
         requirePuppeteer: false,
         antiCrawler: false,
         supportBT: false,
@@ -22,19 +26,19 @@ export const route: Route = {
 };
 
 async function handler(ctx) {
-    if (!config.twitter || !config.twitter.consumer_key || !config.twitter.consumer_secret) {
-        throw new ConfigNotFoundError('Twitter RSS is disabled due to the lack of <a href="https://docs.rsshub.app/deploy/config#route-specific-configurations">relevant config</a>');
-    }
     const id = ctx.req.param('id');
-    const client = await utils.getAppClient();
-    const data = await client.v1.get('favorites/list.json', {
-        screen_name: id,
-        tweet_mode: 'extended',
-    });
+    const { count, include_rts } = utils.parseRouteParams(ctx.req.param('routeParams'));
+    const params = count ? { count } : {};
+
+    await api.init();
+    let data = await api.getUserLikes(id, params);
+    if (!include_rts) {
+        data = utils.excludeRetweet(data);
+    }
 
     return {
         title: `Twitter Likes - ${id}`,
-        link: `https://twitter.com/${id}/likes`,
+        link: `https://x.com/${id}/likes`,
         item: utils.ProcessFeed(ctx, {
             data,
         }),

package/lib/routes/twitter/list.ts

@@ -18,7 +18,7 @@ export const route: Route = {
                 description: 'Please see above for details.',
             },
             {
-                name: 'TWITTER_COOKIE',
+                name: 'TWITTER_AUTH_TOKEN',
                 description: 'Please see above for details.',
             },
         ],
@@ -33,7 +33,7 @@ export const route: Route = {
     handler,
     radar: [
         {
-            source: ['twitter.com/i/lists/:id'],
+            source: ['x.com/i/lists/:id'],
             target: '/list/:id',
         },
     ],
@@ -41,15 +41,18 @@ export const route: Route = {
 
 async function handler(ctx) {
     const id = ctx.req.param('id');
-    const { count } = utils.parseRouteParams(ctx.req.param('routeParams'));
+    const { count, include_rts } = utils.parseRouteParams(ctx.req.param('routeParams'));
     const params = count ? { count } : {};
 
     await api.init();
-    const data = await api.getList(id, params);
+    let data = await api.getList(id, params);
+    if (!include_rts) {
+        data = utils.excludeRetweet(data);
+    }
 
     return {
         title: `Twitter List - ${id}`,
-        link: `https://twitter.com/i/lists/${id}`,
+        link: `https://x.com/i/lists/${id}`,
         item: utils.ProcessFeed(ctx, {
             data,
         }),

package/lib/routes/twitter/media.ts

@@ -1,11 +1,12 @@
-import { Route } from '@/types';
+import { Route, ViewType } from '@/types';
 import api from './api';
 import utils from './utils';
 
 export const route: Route = {
     path: '/media/:id/:routeParams?',
-    categories: ['social-media'],
-    example: '/twitter/media/DIYgod',
+    categories: ['social-media', 'popular'],
+    view: ViewType.Pictures,
+    example: '/twitter/media/_RSSHub',
     parameters: { id: 'username; in particular, if starts with `+`, it will be recognized as a [unique ID](https://github.com/DIYgod/RSSHub/issues/12221), e.g. `+44196397`', routeParams: 'extra parameters, see the table above.' },
     features: {
         requireConfig: [
@@ -18,7 +19,7 @@ export const route: Route = {
                 description: 'Please see above for details.',
             },
             {
-                name: 'TWITTER_COOKIE',
+                name: 'TWITTER_AUTH_TOKEN',
                 description: 'Please see above for details.',
             },
         ],
@@ -33,7 +34,7 @@ export const route: Route = {
     handler,
     radar: [
         {
-            source: ['twitter.com/:id/media'],
+            source: ['x.com/:id/media'],
             target: '/media/:id',
         },
     ],
@@ -51,7 +52,7 @@ async function handler(ctx) {
 
     return {
         title: `Twitter @${userInfo?.name}`,
-        link: `https://twitter.com/${userInfo?.screen_name}/media`,
+        link: `https://x.com/${userInfo?.screen_name}/media`,
         image: profileImageUrl.replace(/_normal.jpg$/, '.jpg'),
         description: userInfo?.description,
         item: utils.ProcessFeed(ctx, {