rsshub 1.0.0-master.ff487f3 → 1.0.0-master.ff76aa7

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

@@ -1,47 +1,51 @@
 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/tD8zKvQzwY3kdx5yz6YmOw/UserByRestId',
-    '/graphql/flaR-PUMshxFWZWPNpq4zA/SearchTimeline',
-    '/graphql/TOTgqavWmxywKv5IbMMK1w/ListLatestTweetsTimeline',
-    '/graphql/zJvfJs3gSbrVhC0MKjt_OQ/TweetDetail',
+    '/graphql/E3opETHurmVJflFsUBVuUQ/UserTweets',
+    '/graphql/Yka-W8dz7RaEuQNkroPkYw/UserByScreenName',
+    '/graphql/HJFjzBgCs16TqxewQOeLNg/HomeTimeline',
+    '/graphql/DiTkXJgLqBBxCs7zaYsbtA/HomeLatestTimeline',
+    '/graphql/bt4TKuFz4T7Ckk-VvQVSow/UserTweetsAndReplies',
+    '/graphql/dexO_2tohK86JDudXXG3Yw/UserMedia',
+    '/graphql/Qw77dDjp9xCpUY-AXwt-yQ/UserByRestId',
+    '/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,
@@ -60,8 +64,7 @@ const TweetDetailFeatures = {
     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: false,
-    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,
@@ -72,7 +75,6 @@ const TweetDetailFeatures = {
     freedom_of_speech_not_reach_fetch_enabled: true,
     standardized_nudges_misinfo: true,
     tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled: true,
-    tweet_with_visibility_results_prefer_gql_media_interstitial_enabled: true,
     rweb_video_timestamps_enabled: true,
     longform_notetweets_rich_text_read_enabled: true,
     longform_notetweets_inline_media_enabled: true,
@@ -87,6 +89,7 @@ const gqlFeatures = {
     SearchTimeline: gqlFeatureFeed,
     ListLatestTweetsTimeline: gqlFeatureFeed,
     HomeTimeline: gqlFeatureFeed,
+    HomeLatestTimeline: TweetDetailFeatures,
     TweetDetail: TweetDetailFeatures,
     Likes: gqlFeatureFeed,
 };

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,35 +1,18 @@
 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, 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 { RateLimiterMemory, RateLimiterRedis, RateLimiterQueue } from 'rate-limiter-flexible';
 import ofetch from '@/utils/ofetch';
 import proxy from '@/utils/proxy';
+import login from './login';
 
-const dispatchers = {};
 let authTokenIndex = 0;
 
-const loginLimiter = cache.clients.redisClient
-    ? new RateLimiterRedis({
-          points: 1,
-          duration: 5,
-          execEvenly: true,
-          storeClient: cache.clients.redisClient,
-      })
-    : new RateLimiterMemory({
-          points: 1,
-          duration: 5,
-          execEvenly: true,
-      });
-
-const loginLimiterQueue = new RateLimiterQueue(loginLimiter);
-
 const token2Cookie = (token) =>
     cache.tryGet(`twitter:cookie:${token}`, async () => {
         const jar = new CookieJar();
@@ -41,9 +24,19 @@ const token2Cookie = (token) =>
                       uri: proxy.proxyUri,
                   })
                 : new CookieAgent({ cookies: { jar } });
-            await got('https://x.com', {
-                dispatcher: agent,
-            });
+            if (token) {
+                await ofetch('https://x.com', {
+                    dispatcher: agent,
+                });
+            } else {
+                const data = await ofetch('https://x.com/narendramodi?mx=2', {
+                    dispatcher: agent,
+                });
+                const gt = data.match(/document\.cookie="gt=(\d+)/)?.[1];
+                if (gt) {
+                    jar.setCookieSync(`gt=${gt}`, 'https://x.com');
+                }
+            }
             return JSON.stringify(jar.serializeSync());
         } catch {
             // ignore
@@ -51,15 +44,60 @@ const token2Cookie = (token) =>
         }
     });
 
-export const twitterGot = async (url, params) => {
-    if (!config.twitter.authToken) {
-        throw new ConfigNotFoundError('Twitter cookie is not configured');
+const lockPrefix = 'twitter:lock-token1:';
+
+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(`${lockPrefix}${token}`, false);
+        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(`${lockPrefix}${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,
+    options?: {
+        allowNoAuth?: boolean;
     }
-    await loginLimiterQueue.removeTokens(1);
-    const token = config.twitter.authToken[authTokenIndex++ % config.twitter.authToken.length];
-    let cookie = await token2Cookie(token);
+) => {
+    const auth = await getAuth(30);
+
+    if (!auth && !options?.allowNoAuth) {
+        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 && auth) {
+        cookie = await login({
+            username: auth.username,
+            password: auth.password,
+            authenticationSecret: auth.authenticationSecret,
+        });
+    }
+    let dispatchers:
+        | {
+              jar: CookieJar;
+              agent: CookieAgent | ProxyAgent;
+          }
+        | undefined;
     if (cookie) {
-        logger.debug(`Got twitter cookie for token ${token}`);
+        logger.debug(`twitter debug: got twitter cookie for token ${auth?.token}`);
         if (typeof cookie === 'string') {
             cookie = JSON.parse(cookie);
         }
@@ -70,22 +108,28 @@ export const twitterGot = async (url, params) => {
                   uri: proxy.proxyUri,
               })
             : new CookieAgent({ cookies: { jar } });
-        dispatchers[token] = {
+        if (proxy.proxyUri) {
+            logger.debug(`twitter debug: Proxying request: ${requestUrl}`);
+        }
+        dispatchers = {
             jar,
             agent,
         };
-    } else {
-        throw new ConfigNotFoundError(`Twitter cookie for token ${token} is not valid`);
+    } else if (auth) {
+        throw new ConfigNotFoundError(`Twitter cookie for token ${auth?.token} is not valid`);
     }
-    const jsonCookie = Object.fromEntries(
-        dispatchers[token].jar
-            .getCookieStringSync(url)
-            .split(';')
-            .map((c) => Cookie.parse(c)?.toJSON())
-            .map((c) => [c?.key, c?.value])
-    );
+    const jsonCookie = dispatchers
+        ? Object.fromEntries(
+              dispatchers.jar
+                  .getCookieStringSync(url)
+                  .split(';')
+                  .map((c) => Cookie.parse(c)?.toJSON())
+                  .map((c) => [c?.key, c?.value])
+          )
+        : {};
 
-    const response = await ofetch.raw(`${url}?${queryString.stringify(params)}`, {
+    const response = await ofetch.raw(requestUrl, {
+        retry: 0,
         headers: {
             authority: 'x.com',
             accept: '*/*',
@@ -95,24 +139,75 @@ export const twitterGot = async (url, params) => {
             'content-type': 'application/json',
             dnt: '1',
             pragma: 'no-cache',
-            referer: 'https://x.com/narendramodi',
+            referer: 'https://x.com/',
             'x-twitter-active-user': 'yes',
-            'x-twitter-auth-type': 'OAuth2Session',
             'x-twitter-client-language': 'en',
             'x-csrf-token': jsonCookie.ct0,
+            ...(auth?.token
+                ? {
+                      'x-twitter-auth-type': 'OAuth2Session',
+                  }
+                : {
+                      'x-guest-token': jsonCookie.gt,
+                  }),
         },
-        dispatcher: dispatchers[token].agent,
+        dispatcher: dispatchers?.agent,
         onResponse: async ({ response }) => {
-            if (response.status === 403) {
-                logger.debug(`Delete twitter cookie for token ${token}`);
-                await cache.set(`twitter:cookie:${token}`, '', config.cache.contentExpire);
+            const remaining = response.headers.get('x-rate-limit-remaining');
+            const remainingInt = Number.parseInt(remaining || '0');
+            const reset = response.headers.get('x-rate-limit-reset');
+            logger.debug(`twitter debug: twitter rate limit remaining for token ${auth?.token} is ${remaining} and reset at ${reset}`);
+            if (auth) {
+                if (remaining && remainingInt < 2 && reset) {
+                    const resetTime = new Date(Number.parseInt(reset) * 1000);
+                    const delay = (resetTime.getTime() - Date.now()) / 1000;
+                    logger.debug(`twitter debug: twitter rate limit exceeded for token ${auth.token} with status ${response.status}, will unlock after ${delay}s`);
+                    await cache.set(`${lockPrefix}${auth.token}`, '1', Math.ceil(delay));
+                } else if (response.status === 429 || JSON.stringify(response._data?.data) === '{"user":{}}') {
+                    logger.debug(`twitter debug: twitter rate limit exceeded for token ${auth.token} with status ${response.status}`);
+                    await cache.set(`${lockPrefix}${auth.token}`, '1', 2000);
+                } else if (response.status === 403 || response.status === 401) {
+                    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 for token ${auth.token} with error1`);
+                        await cache.set(`${lockPrefix}${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} with status ${response.status}, remaining tokens: ${config.twitter.authToken?.length}`);
+                        await cache.set(`${lockPrefix}${auth.token}`, '1', 86400);
+                    }
+                } else {
+                    logger.debug(`twitter debug: unlock twitter cookie with success for token ${auth.token}`);
+                    await cache.set(`${lockPrefix}${auth.token}`, '', 1);
+                }
             }
         },
     });
 
-    if (token) {
-        logger.debug(`Reset twitter cookie for token ${token}`);
-        await cache.set(`twitter:cookie:${token}`, JSON.stringify(dispatchers[token].jar.serializeSync()), config.cache.contentExpire);
+    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);
     }
 
     return response._data;
@@ -138,13 +233,13 @@ export const paginationTweets = async (endpoint: string, userId: number | undefi
             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(`Instructions not found in data: ${JSON.stringify(data)}`);
+            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) {

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/list.ts

@@ -41,11 +41,14 @@ 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}`,

package/lib/routes/twitter/media.ts

@@ -1,6 +1,7 @@
 import { Route, ViewType } from '@/types';
 import api from './api';
 import utils from './utils';
+import logger from '@/utils/logger';
 
 export const route: Route = {
     path: '/media/:id/:routeParams?',
@@ -47,7 +48,12 @@ async function handler(ctx) {
 
     await api.init();
     const userInfo = await api.getUser(id);
-    const data = await api.getUserMedia(id, params);
+    let data;
+    try {
+        data = await api.getUserMedia(id, params);
+    } catch (error) {
+        logger.error(error);
+    }
     const profileImageUrl = userInfo?.profile_image_url || userInfo?.profile_image_url_https;
 
     return {
@@ -55,8 +61,11 @@ async function handler(ctx) {
         link: `https://x.com/${userInfo?.screen_name}/media`,
         image: profileImageUrl.replace(/_normal.jpg$/, '.jpg'),
         description: userInfo?.description,
-        item: utils.ProcessFeed(ctx, {
-            data,
-        }),
+        item:
+            data &&
+            utils.ProcessFeed(ctx, {
+                data,
+            }),
+        allowEmpty: true,
     };
 }

package/lib/routes/twitter/tweet.ts

@@ -2,6 +2,7 @@ import { Route } from '@/types';
 import api from './api';
 import utils from './utils';
 import { fallback, queryToBoolean } from '@/utils/readable-social';
+import { config } from '@/config';
 
 export const route: Route = {
     path: '/tweet/:id/status/:status/:original?',

package/lib/routes/twitter/user.ts

@@ -1,6 +1,7 @@
 import { Route, ViewType } from '@/types';
 import utils from './utils';
 import api from './api';
+import logger from '@/utils/logger';
 
 export const route: Route = {
     path: '/user/:id/:routeParams?',
@@ -58,9 +59,14 @@ async function handler(ctx) {
 
     await api.init();
     const userInfo = await api.getUser(id);
-    let data = await (exclude_replies ? api.getUserTweets(id, params) : api.getUserTweetsAndReplies(id, params));
-    if (!include_rts) {
-        data = utils.excludeRetweet(data);
+    let data;
+    try {
+        data = await (exclude_replies ? api.getUserTweets(id, params) : api.getUserTweetsAndReplies(id, params));
+        if (!include_rts) {
+            data = utils.excludeRetweet(data);
+        }
+    } catch (error) {
+        logger.error(error);
     }
 
     const profileImageUrl = userInfo?.profile_image_url || userInfo?.profile_image_url_https;
@@ -70,8 +76,11 @@ async function handler(ctx) {
         link: `https://x.com/${userInfo?.screen_name}`,
         image: profileImageUrl.replace(/_normal.jpg$/, '.jpg'),
         description: userInfo?.description,
-        item: utils.ProcessFeed(ctx, {
-            data,
-        }),
+        item:
+            data &&
+            utils.ProcessFeed(ctx, {
+                data,
+            }),
+        allowEmpty: true,
     };
 }

package/lib/routes/uber/blog.ts

@@ -21,7 +21,7 @@ export const route: Route = {
     },
     radar: [
         {
-            source: ['www.uber.com/blog/pittsburgh/engineering'],
+            source: ['www.uber.com/:language/blog/engineering', 'www.uber.com/:language/blog'],
             target: '/blog',
         },
     ],

package/lib/routes/udn/breaking-news.ts

@@ -87,11 +87,11 @@ async function handler(ctx) {
 
                 if (data.publisher.name === '轉角國際 udn Global') {
                     // 轉角24小時
-                    description += $('.story_body_content')
+                    description = $('.story_body_content')
                         .html()
                         .split(/<!--\d+?-->/g)
                         .slice(1, -1)
-                        .join(',');
+                        .join('');
                 }
 
                 return {