rsshub 1.0.0-master.fcceb6e → 1.0.0-master.fcee9cd

package/lib/routes/twitter/utils.js

@@ -1,10 +1,55 @@
+const querystring = require('querystring');
 const URL = require('url');
 const config = require('@/config').value;
 const Twit = require('twit');
+const { fallback, queryToBoolean, queryToInteger } = require('@/utils/readable-social');
+
+const ProcessFeed = (ctx, { data = [] }, params = {}) => {
+    // undefined and strings like "exclude_rts_replies" is also safely parsed, so no if branch is needed
+    const routeParams = querystring.parse(ctx.params.routeParams);
+
+    const mergedParams = {
+        readable: fallback(params.readable, queryToBoolean(routeParams.readable), false),
+        authorNameBold: fallback(params.authorNameBold, queryToBoolean(routeParams.authorNameBold), false),
+        showAuthorInTitle: fallback(params.showAuthorInTitle, queryToBoolean(routeParams.showAuthorInTitle), false),
+        showAuthorInDesc: fallback(params.showAuthorInDesc, queryToBoolean(routeParams.showAuthorInDesc), false),
+        showQuotedAuthorAvatarInDesc: fallback(params.showQuotedAuthorAvatarInDesc, queryToBoolean(routeParams.showQuotedAuthorAvatarInDesc), false),
+        showAuthorAvatarInDesc: fallback(params.showAuthorAvatarInDesc, queryToBoolean(routeParams.showAuthorAvatarInDesc), false),
+        showEmojiForRetweetAndReply: fallback(params.showEmojiForRetweetAndReply, queryToBoolean(routeParams.showEmojiForRetweetAndReply), false),
+        showRetweetTextInTitle: fallback(params.showRetweetTextInTitle, queryToBoolean(routeParams.showRetweetTextInTitle), true),
+        addLinkForPics: fallback(params.addLinkForPics, queryToBoolean(routeParams.addLinkForPics), false),
+        showTimestampInDescription: fallback(params.showTimestampInDescription, queryToBoolean(routeParams.showTimestampInDescription), false),
+        showQuotedInTitle: fallback(params.showQuotedInTitle, queryToBoolean(routeParams.showQuotedInTitle), false),
+
+        widthOfPics: fallback(params.widthOfPics, queryToInteger(routeParams.widthOfPics), -1),
+        heightOfPics: fallback(params.heightOfPics, queryToInteger(routeParams.heightOfPics), -1),
+        sizeOfAuthorAvatar: fallback(params.sizeOfAuthorAvatar, queryToInteger(routeParams.sizeOfAuthorAvatar), 48),
+        sizeOfQuotedAuthorAvatar: fallback(params.sizeOfQuotedAuthorAvatar, queryToInteger(routeParams.sizeOfQuotedAuthorAvatar), 24),
+    };
+
+    params = mergedParams;
+
+    const {
+        readable,
+        authorNameBold,
+        showAuthorInTitle,
+        showAuthorInDesc,
+        showQuotedAuthorAvatarInDesc,
+        showAuthorAvatarInDesc,
+        showEmojiForRetweetAndReply,
+        showRetweetTextInTitle,
+        addLinkForPics,
+        showTimestampInDescription,
+        showQuotedInTitle,
+
+        widthOfPics,
+        heightOfPics,
+        sizeOfAuthorAvatar,
+        sizeOfQuotedAuthorAvatar,
+    } = params;
 
-const ProcessFeed = ({ data = [] }, showAuthor = false) => {
     const getQueryParams = (url) => URL.parse(url, true).query;
-    const getOrigionImg = (url) => {
+    const getOriginalImg = (url) => {
         // https://greasyfork.org/zh-CN/scripts/2312-resize-image-on-open-image-in-new-tab/code#n150
         let m = null;
         if ((m = url.match(/^(https?:\/\/\w+\.twimg\.com\/media\/[^/:]+)\.(jpg|jpeg|gif|png|bmp|webp)(:\w+)?$/i))) {
@@ -28,8 +73,13 @@ const ProcessFeed = ({ data = [] }, showAuthor = false) => {
     };
 
     const replaceBreak = (text) => text.replace(/<br><br>|<br>/g, ' ');
-    const formatText = (text) => text.replace(/https:\/\/t\.co(.*)/g, '').replace(/\n/g, '<br>');
-    const formatVideo = (media) => {
+    const formatText = (text) =>
+        text
+            .replace(/https:\/\/t\.co(.*)/g, '')
+            .trim()
+            .replace(/\n/g, '<br>');
+    const formatTextToPlain = (text) => text.replace(/https:\/\/t\.co(.*)/g, '').trim();
+    const formatVideo = (media, extraAttrs = '') => {
         let content = '';
         const video = media.video_info.variants.reduce((video, item) => {
             if ((item.bitrate || 0) > (video.bitrate || -Infinity)) {
@@ -40,7 +90,10 @@ const ProcessFeed = ({ data = [] }, showAuthor = false) => {
 
         if (video.url) {
             const gifAutoPlayAttr = media.type === 'animated_gif' ? `autoplay loop muted webkit-playsinline playsinline` : '';
-            content = `<br><video src="${video.url}" ${gifAutoPlayAttr} controls="controls" poster="${getOrigionImg(media.media_url_https)}" style="width: 100%"></video>`;
+            if (!readable) {
+                content += '<br>';
+            }
+            content += `<video src='${video.url}' ${gifAutoPlayAttr} controls='controls' poster='${getOriginalImg(media.media_url_https)}' ${extraAttrs}></video>`;
         }
 
         return content;
@@ -52,6 +105,8 @@ const ProcessFeed = ({ data = [] }, showAuthor = false) => {
             item.extended_entities.media.forEach((item) => {
                 // https://developer.twitter.com/en/docs/tweets/data-dictionary/overview/extended-entities-object
                 let content = '';
+                let style = '';
+                let originalImg;
                 switch (item.type) {
                     case 'animated_gif':
                     case 'video':
@@ -60,39 +115,147 @@ const ProcessFeed = ({ data = [] }, showAuthor = false) => {
 
                     case 'photo':
                     default:
-                        content = `<br><img src="${getOrigionImg(item.media_url_https)}">`;
+                        originalImg = getOriginalImg(item.media_url_https);
+                        if (!readable) {
+                            content += `<br>`;
+                        }
+                        if (addLinkForPics) {
+                            content += `<a href='${originalImg}' target='_blank' rel='noopener noreferrer'>`;
+                        }
+                        content += `<img `;
+                        if (widthOfPics >= 0) {
+                            content += ` width="${widthOfPics}"`;
+                            style += `width: ${widthOfPics}px;`;
+                        }
+                        if (heightOfPics > 0) {
+                            content += `height="${heightOfPics}" `;
+                            style += `height: ${heightOfPics}px;`;
+                        }
+                        content += ` style="${style}" ` + `${readable ? 'hspace="4" vspace="8"' : ''} src="${originalImg}">`;
+                        if (addLinkForPics) {
+                            content += `</a>`;
+                        }
                         break;
                 }
 
                 img += content;
             });
 
+        if (readable && img) {
+            img = `<br clear='both' /><div style='clear: both'></div>` + img;
+        }
         return img;
     };
+    const generatePicsPrefix = (item) => {
+        // When author avatar is shown, generate invisible <img> for inner images at the beginning of HTML
+        // to please some RSS readers
+        let picsPrefix = '';
+        item.extended_entities &&
+            item.extended_entities.media.forEach((item) => {
+                let content;
+                let originalImg;
+                switch (item.type) {
+                    case 'video':
+                        content = formatVideo(item, `width="0" height="0"`);
+                        break;
+
+                    case 'photo':
+                    default:
+                        originalImg = getOriginalImg(item.media_url_https);
+                        content = `<img width='0' height='0' hidden='true' src='${originalImg}'>`;
+                        break;
+                }
+
+                picsPrefix += content;
+            });
+        return picsPrefix;
+    };
     const formatUrl = (item) => {
         let url = '';
-        item.entities.urls.forEach((u) => {
-            url += `<a href="${u.expanded_url}" target="_blank" rel="noopener noreferrer">${u.expanded_url}</a>`;
-        });
+        item.entities.urls &&
+            item.entities.urls.forEach((u) => {
+                if (readable) {
+                    url += '<br>';
+                } else {
+                    url += '&ensp;';
+                }
+                url += `<a href='${u.expanded_url}' target='_blank' rel='noopener noreferrer'>${u.expanded_url}</a>`;
+            });
 
         return url;
     };
 
     return data.map((item) => {
+        const originalItem = item;
         item = item.retweeted_status || item;
         item.full_text = formatText(item.full_text);
         const img = formatMedia(item);
+        let picsPrefix = generatePicsPrefix(item);
         let url = '';
         let quote = '';
+        let quoteInTitle = '';
 
+        // Make quote in description
         if (item.is_quote_status) {
             const quoteData = item.quoted_status;
 
             if (quoteData) {
                 const author = quoteData.user;
-                quote += `<br><br>${author.name}: ${formatText(quoteData.full_text)}<br>`;
+                if (readable) {
+                    quote += `<br clear='both' /><div style='clear: both'></div>`;
+                    quote += `<blockquote style='background: #80808010;border-top:1px solid #80808030;border-bottom:1px solid #80808030;margin:0;padding:5px 20px;'>`;
+                } else {
+                    quote += `<br><br>`;
+                }
+
+                if (readable) {
+                    quote += `<a href='https://twitter.com/${author.screen_name}' target='_blank' rel='noopener noreferrer'>`;
+                }
+
+                if (showQuotedAuthorAvatarInDesc) {
+                    quote += `<img width='${sizeOfQuotedAuthorAvatar}' height='${sizeOfQuotedAuthorAvatar}' src='${author.profile_image_url_https}' ${readable ? 'hspace="8" vspace="8" align="left"' : ''}>`;
+                }
+
+                if (authorNameBold) {
+                    quote += `<strong>`;
+                }
+
+                quote += author.name;
+
+                if (authorNameBold) {
+                    quote += `</strong>`;
+                }
+
+                if (readable) {
+                    quote += `</a>`;
+                }
+
+                quote += `:&ensp;`;
+                quote += formatText(quoteData.full_text);
+
+                if (!readable) {
+                    quote += '<br>';
+                }
                 quote += formatMedia(quoteData);
+                picsPrefix += generatePicsPrefix(quoteData);
                 quote += formatUrl(quoteData);
+                quoteInTitle += showEmojiForRetweetAndReply ? ' 💬 ' : ' RT ';
+                quoteInTitle += `${author.name}: ${formatTextToPlain(quoteData.full_text)}`;
+
+                if (readable) {
+                    quote += `<br><small>Link: <a href='https://twitter.com/${author.screen_name}/status/${quoteData.id_str}' target='_blank' rel='noopener noreferrer'>https://twitter.com/${author.screen_name}/status/${quoteData.id_str}</a></small>`;
+                }
+                if (showTimestampInDescription) {
+                    quote += '<br><small>' + new Date(quoteData.created_at).toLocaleString();
+                    quote += `</small>`;
+                    if (readable) {
+                        quote += `<br clear='both' /><div style='clear: both'></div>`;
+                    }
+                }
+
+                if (readable) {
+                    quote += `</blockquote>`;
+                }
             } else {
                 url = formatUrl(item);
             }
@@ -100,12 +263,119 @@ const ProcessFeed = ({ data = [] }, showAuthor = false) => {
             url = formatUrl(item);
         }
 
+        // Make title
+        let title = '';
+        if (showAuthorInTitle) {
+            title += originalItem.user.name + ': ';
+        }
+        const isRetweet = originalItem !== item;
+        const isQuote = item.is_quote_status;
+        if (!isRetweet && (!isQuote || showRetweetTextInTitle)) {
+            if (item.in_reply_to_screen_name) {
+                title += showEmojiForRetweetAndReply ? '↩️ ' : 'Re ';
+            }
+            title += replaceBreak(originalItem.full_text);
+        }
+        if (isRetweet) {
+            title += showEmojiForRetweetAndReply ? '🔁 ' : 'RT ';
+            title += item.user.name + ': ';
+            if (item.in_reply_to_screen_name) {
+                title += showEmojiForRetweetAndReply ? ' ↩️ ' : ' Re ';
+            }
+            title += replaceBreak(item.full_text);
+        }
+
+        if (showQuotedInTitle) {
+            title += quoteInTitle;
+        }
+
+        // Make description
+        let description = '';
+        if (showAuthorInDesc && showAuthorAvatarInDesc) {
+            description += picsPrefix;
+        }
+        if (isRetweet) {
+            if (showAuthorInDesc) {
+                if (readable) {
+                    description += '<small>';
+                    description += `<a href='https://twitter.com/${originalItem.user.screen_name}' target='_blank' rel='noopener noreferrer'>`;
+                }
+                if (authorNameBold) {
+                    description += `<strong>`;
+                }
+                description += originalItem.user.name;
+                if (authorNameBold) {
+                    description += `</strong>`;
+                }
+                if (readable) {
+                    description += '</a>';
+                }
+                description += '&ensp;';
+            }
+            description += showEmojiForRetweetAndReply ? '🔁' : 'RT';
+            if (!showAuthorInDesc) {
+                description += '&ensp;';
+                if (readable) {
+                    description += `<a href='https://twitter.com/${item.user.screen_name}' target='_blank' rel='noopener noreferrer'>`;
+                }
+                if (authorNameBold) {
+                    description += `<strong>`;
+                }
+                description += item.user.name;
+                if (authorNameBold) {
+                    description += `</strong>`;
+                }
+                if (readable) {
+                    description += '</a>';
+                }
+            }
+            if (readable) {
+                description += '</small>';
+            }
+            description += '<br>';
+        }
+        if (showAuthorInDesc) {
+            if (readable) {
+                description += `<a href='https://twitter.com/${item.user.screen_name}' target='_blank' rel='noopener noreferrer'>`;
+            }
+
+            if (showAuthorAvatarInDesc) {
+                description += `<img width='${sizeOfAuthorAvatar}' height='${sizeOfAuthorAvatar}' src='${item.user.profile_image_url_https}' ${readable ? 'hspace="8" vspace="8" align="left"' : ''}>`;
+            }
+            if (authorNameBold) {
+                description += `<strong>`;
+            }
+            description += item.user.name;
+            if (authorNameBold) {
+                description += `</strong>`;
+            }
+            if (readable) {
+                description += `</a>`;
+            }
+            description += `:&ensp;`;
+        }
+        if (item.in_reply_to_screen_name) {
+            description += showEmojiForRetweetAndReply ? '↩️ ' : 'Re ';
+        }
+
+        description += item.full_text;
+        description += url;
+        description += img;
+        description += quote;
+
+        if (readable) {
+            description += `<br clear='both' /><div style='clear: both'></div><hr>`;
+        }
+
+        if (showTimestampInDescription) {
+            description += `<small>${new Date(item.created_at).toLocaleString()}</small>`;
+        }
+
+        const authorName = originalItem.user.name;
         return {
-            title: `${showAuthor ? item.user.name + ': ' : ''}${item.in_reply_to_screen_name ? 'Re ' : ''}${replaceBreak(item.full_text)}`,
-            author: item.user.name,
-            description: `${showAuthor ? `<img width="15px" src="${item.user.profile_image_url_https}"><strong>${item.user.name}:</strong><br><br>` : ''}${item.in_reply_to_screen_name ? 'Re ' : ''}${
-                item.full_text
-            }${url}${img}${quote}`,
+            title,
+            author: authorName,
+            description,
             pubDate: new Date(item.created_at).toUTCString(),
             link: `https://twitter.com/${item.user.screen_name}/status/${item.id_str}`,
         };
@@ -138,7 +408,29 @@ if (config.twitter.consumer_key && config.twitter.consumer_secret) {
     };
 }
 
+function parseRouteParams(routeParams) {
+    let exclude_replies, include_rts;
+    let count = undefined;
+    if (routeParams === 'exclude_rts_replies' || routeParams === 'exclude_replies_rts') {
+        exclude_replies = true;
+        include_rts = false;
+    } else if (routeParams === 'exclude_replies') {
+        exclude_replies = true;
+        include_rts = true;
+    } else if (routeParams === 'exclude_rts') {
+        exclude_replies = false;
+        include_rts = false;
+    } else {
+        const parsed = querystring.parse(routeParams);
+        count = fallback(undefined, queryToInteger(parsed.count), undefined);
+        exclude_replies = fallback(undefined, queryToBoolean(parsed.excludeReplies), false);
+        include_rts = fallback(undefined, queryToBoolean(parsed.includeRts), true);
+    }
+    return { count, exclude_replies, include_rts };
+}
+
 module.exports = {
     ProcessFeed,
     getTwit,
+    parseRouteParams,
 };

package/lib/routes/twitter/web-api/media.js

@@ -0,0 +1,20 @@
+const utils = require('../utils');
+// const config = require('@/config').value;
+const { getUser, getUserMedia } = require('./twitter-api');
+
+module.exports = async (ctx) => {
+    const id = ctx.params.id;
+    const userInfo = await getUser(ctx.cache, id);
+    const data = await getUserMedia(ctx.cache, id);
+    const profileImageUrl = userInfo.profile_image_url || userInfo.profile_image_url_https;
+
+    ctx.state.data = {
+        title: `Twitter @${userInfo.name}`,
+        link: `https://twitter.com/${id}/media`,
+        image: profileImageUrl,
+        description: userInfo.description,
+        item: utils.ProcessFeed(ctx, {
+            data,
+        }),
+    };
+};

package/lib/routes/twitter/web-api/search.js

@@ -0,0 +1,16 @@
+const utils = require('../utils');
+const { getSearch } = require('./twitter-api');
+
+module.exports = async (ctx) => {
+    const keyword = ctx.params.keyword;
+    const data = await getSearch(keyword);
+
+    ctx.state.data = {
+        title: `Twitter Keyword - ${keyword}`,
+        link: `https://twitter.com/search?q=${encodeURIComponent(keyword)}`,
+        item: utils.ProcessFeed(ctx, {
+            data,
+        }),
+        allowEmpty: true,
+    };
+};

package/lib/routes/twitter/web-api/twitter-api.js

@@ -0,0 +1,123 @@
+const twitterGot = require('./twitter-got');
+const _params = {
+    count: 20,
+    include_profile_interstitial_type: 1,
+    include_blocking: 1,
+    include_blocked_by: 1,
+    include_followed_by: 1,
+    include_want_retweets: 1,
+    include_mute_edge: 1,
+    include_can_dm: 1,
+    include_can_media_tag: 1,
+    skip_status: 1,
+    cards_platform: 'Web-12',
+    include_cards: 1,
+    include_ext_alt_text: true,
+    include_quote_count: true,
+    include_reply_count: 1,
+    tweet_mode: 'extended',
+    include_entities: true,
+    include_user_entities: true,
+    include_ext_media_color: true,
+    include_ext_media_availability: true,
+    send_error_codes: true,
+    simple_quoted_tweet: true,
+    include_tweet_replies: false,
+    ext: 'mediaStats,highlightedLabel',
+};
+
+const pagination = (endpoint, userId, params) =>
+    twitterGot('https://api.twitter.com' + endpoint, {
+        ..._params,
+        ...params,
+        userId,
+    });
+const timelineMedia = (userId, params = {}) => pagination(`/2/timeline/media/${userId}.json`, userId, params);
+const timelineTweets = (userId, params = {}) => pagination(`/2/timeline/profile/${userId}.json`, userId, params);
+const timelineTweetsAndReplies = (userId, params = {}) =>
+    pagination(`/2/timeline/profile/${userId}.json`, userId, {
+        ...params,
+        include_tweet_replies: true,
+    });
+const timelineLikes = (userId, params = {}) =>
+    pagination(`/2/timeline/favorites/${userId}.json`, userId, {
+        ...params,
+        sorted_by_time: true,
+    });
+const timelineKeywords = (keywords, params = {}) =>
+    twitterGot('https://twitter.com/i/api/2/search/adaptive.json', {
+        ..._params,
+        ...params,
+        q: keywords,
+        query_source: 'typed_query',
+        pc: 1,
+    });
+
+function pickLegacyByID(id, tweets_dict, users_dict) {
+    function pickLegacyFromTweet(tweet) {
+        tweet.user = users_dict[tweet.user_id_str];
+        if (tweet.retweeted_status_id_str) {
+            tweet.retweeted_status = pickLegacyFromTweet(tweets_dict[tweet.retweeted_status_id_str]);
+        }
+        return tweet;
+    }
+
+    if (tweets_dict[id]) {
+        return pickLegacyFromTweet(tweets_dict[id]);
+    }
+}
+
+function gatherLegacyFromData(data, filter = 'tweet-') {
+    const tweets_dict = data.globalObjects.tweets;
+    const users_dict = data.globalObjects.users;
+    const tweets = [];
+    data.timeline.instructions[0].addEntries.entries.forEach((entry) => {
+        if (entry.entryId && entry.entryId.indexOf(filter) !== -1) {
+            const tweet = pickLegacyByID(entry.content.item.content.tweet.id, tweets_dict, users_dict);
+            if (tweet) {
+                tweets.push(tweet);
+            }
+        }
+    });
+    return tweets;
+}
+
+const getUserTweetsByID = async (id, params = {}) => gatherLegacyFromData(await timelineTweets(id, params));
+const getUserTweetsAndRepliesByID = async (id, params = {}) => gatherLegacyFromData(await timelineTweetsAndReplies(id, params));
+const getUserMediaByID = async (id, params = {}) => gatherLegacyFromData(await timelineMedia(id, params));
+const getUserLikesByID = async (id, params = {}) => gatherLegacyFromData(await timelineLikes(id, params));
+
+const excludeRetweet = function (tweets) {
+    const excluded = [];
+    for (const t of tweets) {
+        if (t.retweeted_status) {
+            continue;
+        }
+        excluded.push(t);
+    }
+    return excluded;
+};
+
+const userByScreenName = (screenName) =>
+    twitterGot('https://twitter.com/i/api/graphql/hc-pka9A7gyS3xODIafnrQ/UserByScreenName', {
+        variables: `{"screen_name":"${screenName}","withHighlightedLabel":true}`,
+    });
+const getUserData = (cache, screenName) => cache.tryGet(`twitter-userdata-${screenName}`, () => userByScreenName(screenName));
+const getUserID = async (cache, screenName) => (await getUserData(cache, screenName)).data.user.rest_id;
+const getUser = async (cache, screenName) => (await getUserData(cache, screenName)).data.user.legacy;
+
+const getUserTweets = async (cache, screenName, params = {}) => getUserTweetsByID(await getUserID(cache, screenName), params);
+const getUserTweetsAndReplies = async (cache, screenName, params = {}) => getUserTweetsAndRepliesByID(await getUserID(cache, screenName), params);
+const getUserMedia = async (cache, screenName, params = {}) => getUserMediaByID(await getUserID(cache, screenName), params);
+const getUserLikes = async (cache, screenName, params = {}) => getUserLikesByID(await getUserID(cache, screenName), params);
+const getSearch = async (keywords, params = {}) => gatherLegacyFromData(await timelineKeywords(keywords, params), 'sq-I-t-');
+
+module.exports = {
+    getUser,
+    getUserTweets,
+    getUserTweetsAndReplies,
+    getUserMedia,
+    getUserLikes,
+    excludeRetweet,
+    getSearch,
+};

package/lib/routes/twitter/web-api/twitter-got.js

@@ -0,0 +1,87 @@
+const { CookieJar, Cookie } = require('tough-cookie');
+const { promisify } = require('util');
+const queryString = require('query-string');
+const got = require('@/utils/got');
+const config = require('@/config').value;
+const headers = {
+    authorization: config.twitter.authorization,
+    'x-guest-token': undefined,
+    'x-twitter-auth-type': undefined,
+    'x-twitter-client-language': 'en',
+    'x-twitter-active-user': 'yes',
+    'x-csrf-token': undefined,
+};
+let cookieJar, setCookie, getCookies;
+
+const cookiedomain = 'twitter.com';
+const cookieurl = 'https://twitter.com';
+
+async function twitterGot(options) {
+    const response = await got({
+        ...options,
+        headers: { ...headers, ...(options.headers || {}) },
+        cookieJar,
+    });
+    // 更新csrfToken
+    for (const c of await getCookies(cookieurl)) {
+        if (c.key === 'ct0') {
+            headers['x-csrf-token'] = c.value;
+        }
+    }
+    return response;
+}
+
+async function resetSession() {
+    cookieJar = new CookieJar();
+    getCookies = promisify(cookieJar.getCookies.bind(cookieJar));
+    setCookie = promisify(cookieJar.setCookie.bind(cookieJar));
+    // 生成csrf-token
+    const csrfToken = [...Array(16 * 2)].map(() => Math.floor(Math.random() * 16).toString(16)).join('');
+    await setCookie(new Cookie({ key: 'ct0', value: csrfToken, domain: cookiedomain, secure: false }), cookieurl);
+    headers['x-csrf-token'] = csrfToken;
+    headers['x-guest-token'] = undefined;
+    // 发起初始化请求
+    const response = await twitterGot({
+        url: 'https://api.twitter.com/1.1/guest/activate.json',
+        method: 'POST',
+    });
+    // 获取guest-token
+    // TODO: OAuth2Session, 参见 https://github.com/DIYgod/RSSHub/pull/7739#discussionR655932602
+    const guestToken = response.data.guest_token;
+    headers['x-guest-token'] = guestToken;
+    await setCookie(new Cookie({ key: 'gt', value: guestToken, domain: cookiedomain, secure: false }), cookieurl);
+    // 发起第二个初始化请求, 获取_twitter_sess
+    await twitterGot({
+        url: 'https://twitter.com/i/js_inst',
+        method: 'GET',
+        searchParams: queryString.stringify({ c_name: 'ui_metrics' }),
+    });
+    return cookieJar;
+}
+
+const initSession = () => cookieJar || resetSession();
+
+async function twitterRequest(url, params, method) {
+    await initSession();
+    // 发起请求
+    const request = () =>
+        twitterGot({
+            url,
+            method,
+            searchParams: queryString.stringify(params),
+        });
+    let response;
+    try {
+        response = await request();
+    } catch (e) {
+        if (e.response.status === 403) {
+            await resetSession();
+            response = await request();
+        } else {
+            throw e;
+        }
+    }
+    return response.data;
+}
+
+module.exports = twitterRequest;

package/lib/routes/twitter/web-api/user.js

@@ -0,0 +1,32 @@
+const utils = require('../utils');
+const { getUser, getUserTweets, getUserTweetsAndReplies, excludeRetweet } = require('./twitter-api');
+
+module.exports = async (ctx) => {
+    const id = ctx.params.id;
+
+    // For compatibility
+    const { exclude_replies, include_rts } = utils.parseRouteParams(ctx.params.routeParams);
+
+    let data;
+    const userInfo = await getUser(ctx.cache, id);
+    if (exclude_replies) {
+        data = await getUserTweets(ctx.cache, id);
+    } else {
+        data = await getUserTweetsAndReplies(ctx.cache, id);
+    }
+    if (!include_rts) {
+        data = excludeRetweet(data);
+    }
+
+    const profileImageUrl = userInfo.profile_image_url || userInfo.profile_image_url_https;
+
+    ctx.state.data = {
+        title: `Twitter @${userInfo.name}`,
+        link: `https://twitter.com/${id}`,
+        image: profileImageUrl,
+        description: userInfo.description,
+        item: utils.ProcessFeed(ctx, {
+            data,
+        }),
+    };
+};