gocqhttp-twitter-bot/dist/twitter.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.sendAllStories = exports.ScreenNameNormalizer = exports.SessionManager = exports.parseLink = exports.linkBuilder = void 0;
const crypto = require("crypto");
const fs = require("fs");
const http = require("http");
const path = require("path");
const url_1 = require("url");
const util_1 = require("util");
const instagram_private_api_1 = require("instagram-private-api");
const socks_proxy_agent_1 = require("socks-proxy-agent");
const loggers_1 = require("./loggers");
const utils_1 = require("./utils");
const webshot_1 = require("./webshot");
const parseLink = (link) => {
    let match = /instagram\.com\/stories\/([^\/?#]+)\/(\d+)/.exec(link);
    if (match)
        return { userName: ScreenNameNormalizer.normalize(match[1]).split(':')[0], storyId: match[2] };
    match =
        /instagram\.com\/([^\/?#]+)/.exec(link) ||
            /^([^\/?#]+)$/.exec(link);
    if (match)
        return { userName: ScreenNameNormalizer.normalize(match[1]).split(':')[0] };
    return;
};
exports.parseLink = parseLink;
const linkBuilder = (config) => {
    if (!config.userName)
        return;
    if (!config.storyId)
        return `https://www.instagram.com/${config.userName}/`;
    return `https://www.instagram.com/stories/${config.userName}/${config.storyId}/`;
};
exports.linkBuilder = linkBuilder;
class SessionManager {
    constructor(client, file, credentials, codeServicePort) {
        this.init = () => {
            this.ig.state.generateDevice(this.username);
            this.ig.request.end$.subscribe(() => { this.save(); });
            const filePath = path.resolve(this.lockfile);
            if (fs.existsSync(filePath)) {
                try {
                    const serialized = JSON.parse(fs.readFileSync(filePath, 'utf8'));
                    return this.ig.state.deserialize(serialized).then(() => {
                        logger.info(`successfully loaded client session cookies for user ${this.username}`);
                    });
                }
                catch (err) {
                    logger.error(`failed to load client session cookies from file ${this.lockfile}: `, err);
                    return Promise.resolve();
                }
            }
            else {
                return this.login().catch((err) => {
                    logger.error(`error while trying to log in as user ${this.username}, error: ${err}`);
                    logger.warn('attempting to retry after 1 minute...');
                    if (fs.existsSync(filePath))
                        fs.unlinkSync(filePath);
                    util_1.promisify(setTimeout)(60000).then(this.init);
                });
            }
        };
        this.handle2FA = (submitter) => new Promise((resolve, reject) => {
            const token = crypto.randomBytes(20).toString('hex');
            logger.info('please submit the code with a one-time token from your browser with this path:');
            logger.info(`/confirm-2fa?code=<the code you received>&token=${token}`);
            let working;
            const server = http.createServer((req, res) => {
                const { pathname, query } = url_1.parse(req.url, true);
                if (!working && pathname === '/confirm-2fa' && query.token === token &&
                    typeof (query.code) === 'string' && /^\d{6}$/.test(query.code)) {
                    const code = query.code;
                    logger.debug(`received code: ${code}`);
                    working = true;
                    submitter(code)
                        .then(response => { res.write('OK'); res.end(); server.close(() => resolve(response)); })
                        .catch(err => { res.write('Error'); res.end(); reject(err); })
                        .finally(() => { working = false; });
                }
            });
            server.listen(this.codeServicePort);
        });
        this.login = () => this.ig.simulate.preLoginFlow()
            .then(() => this.ig.account.login(this.username, this.password))
            .catch((err) => {
            if (err instanceof instagram_private_api_1.IgLoginTwoFactorRequiredError) {
                const { two_factor_identifier, totp_two_factor_on } = err.response.body.two_factor_info;
                logger.debug(`2FA info: ${JSON.stringify(err.response.body.two_factor_info)}`);
                logger.info(`login is requesting two-factor authentication via ${totp_two_factor_on ? 'TOTP' : 'SMS'}`);
                return this.handle2FA(code => this.ig.account.twoFactorLogin({
                    username: this.username,
                    verificationCode: code,
                    twoFactorIdentifier: two_factor_identifier,
                    verificationMethod: totp_two_factor_on ? '0' : '1',
                }));
            }
            throw err;
        })
            .then(user => new Promise(resolve => {
            logger.info(`successfully logged in as ${this.username}`);
            process.nextTick(() => resolve(this.ig.simulate.postLoginFlow().then(() => user)));
        }));
        this.save = () => this.ig.state.serialize()
            .then((serialized) => {
            delete serialized.constants;
            return fs.writeFileSync(path.resolve(this.lockfile), JSON.stringify(serialized, null, 2), 'utf-8');
        });
        this.ig = client;
        this.lockfile = file;
        [this.username, this.password] = credentials;
        this.codeServicePort = codeServicePort;
    }
}
exports.SessionManager = SessionManager;
class ScreenNameNormalizer {
    static normalizeLive(username) {
        return __awaiter(this, void 0, void 0, function* () {
            if (this._queryUser) {
                return yield this._queryUser(username)
                    .catch((err) => {
                    if (!(err instanceof instagram_private_api_1.IgExactUserNotFoundError)) {
                        logger.warn(`error looking up user: ${err.message}`);
                        return `${username}:`;
                    }
                    return null;
                });
            }
            return this.normalize(username);
        });
    }
}
exports.ScreenNameNormalizer = ScreenNameNormalizer;
ScreenNameNormalizer.normalize = (username) => `${username.toLowerCase().replace(/^@/, '')}:`;
let sendAllStories = (segmentId, receiver) => {
    throw Error();
};
exports.sendAllStories = sendAllStories;
const logger = loggers_1.getLogger('instagram');
const maxTrials = 3;
const retryInterval = 1500;
const ordinal = (n) => {
    switch ((Math.trunc(n / 10) % 10 === 1) ? 0 : n % 10) {
        case 1:
            return `${n}st`;
        case 2:
            return `${n}nd`;
        case 3:
            return `${n}rd`;
        default:
            return `${n}th`;
    }
};
const retryOnError = (doWork, onRetry) => new Promise(resolve => {
    const retry = (reason, count) => {
        setTimeout(() => {
            let terminate = false;
            onRetry(reason, count, defaultValue => { terminate = true; resolve(defaultValue); });
            if (!terminate)
                doWork().then(resolve).catch(error => retry(error, count + 1));
        }, retryInterval);
    };
    doWork().then(resolve).catch(error => retry(error, 1));
});
class default_1 {
    constructor(opt) {
        this.launch = () => {
            this.webshot = new webshot_1.default(this.wsUrl, this.mode, () => {
                setTimeout(this.workForAll, this.workInterval * 1000);
                setTimeout(() => {
                    this.work();
                    setInterval(() => { this.pullOrders = utils_1.Arr.shuffle(this.pullOrders); }, 21600000);
                    setInterval(this.workForAll, this.workInterval * 10000);
                }, this.workInterval * 1200);
            });
        };
        this.queryUser = (rawUserName) => {
            const username = ScreenNameNormalizer.normalize(rawUserName).split(':')[0];
            if (username in this.cache) {
                return Promise.resolve(`${username}:${this.cache[username].user.pk}`);
            }
            return this.client.user.searchExact(username)
                .then(user => {
                logger.info(`initialized cache item for user ${user.full_name} (@${username})`);
                this.cache[user.username] = { user, stories: {}, pullOrder: 0 };
                return `${user.username}:${user.pk}`;
            });
        };
        this.workOnMedia = (mediaItems, sendMedia) => this.webshot(mediaItems, sendMedia, this.webshotDelay);
        this.sendStories = (source, ...to) => (msg, text, author) => {
            to.forEach(subscriber => {
                logger.info(`pushing data${source ? ` of ${source}` : ''} to ${JSON.stringify(subscriber)}`);
                retryOnError(() => this.bot.sendTo(subscriber, msg), (_, count, terminate) => {
                    if (count <= maxTrials) {
                        logger.warn(`retry sending to ${subscriber.chatID} for the ${ordinal(count)} time...`);
                    }
                    else {
                        logger.warn(`${count - 1} consecutive failures while sending message chain, trying plain text instead...`);
                        terminate(this.bot.sendTo(subscriber, author + text, true));
                    }
                });
            });
        };
        this.cache = {};
        this.workForAll = () => {
            if (this.isInactiveTime)
                return;
            logger.debug(`current cache: ${JSON.stringify(this.cache)}`);
            utils_1.chainPromises(Object.entries(this.lock.threads).map(([feed, thread]) => {
                const id = thread.id;
                const userName = parseLink(feed).userName;
                logger.debug(`preparing to add user @${userName} to next pull task...`);
                return (map = {}) => {
                    if (userName in this.cache) {
                        const item = this.cache[userName];
                        if (item.pullOrder === 0)
                            item.pullOrder = -1;
                        return Promise.resolve(Object.assign(map, { [id]: item.user }));
                    }
                    return util_1.promisify(setTimeout)((Math.random() * 2 + 1) * 5000).then(() => this.client.user.info(id).then(user => {
                        logger.info(`initialized cache item for user ${user.full_name} (@${userName})`);
                        this.cache[userName] = { user, stories: {}, pullOrder: -1 };
                        return Object.assign(map, { [id]: user });
                    }));
                };
            }))
                .then(idToUserMap => {
                const userIdCache = Object.values(this.cache).some(item => item.pullOrder < 0) ?
                    this.pullOrders = utils_1.Arr.shuffle(Object.keys(idToUserMap)).map(Number) :
                    this.pullOrders;
                return utils_1.chainPromises(utils_1.Arr.chunk(userIdCache, 20).map(userIds => () => {
                    logger.info(`pulling stories from users:${userIds.map(id => ` @${idToUserMap[id].username}`)}`);
                    return this.client.feed.reelsMedia({ userIds }).items()
                        .then(storyItems => storyItems.forEach(item => {
                        if (!(item.pk in this.cache[idToUserMap[item.user.pk].username].stories)) {
                            this.cache[idToUserMap[item.user.pk].username].stories[item.pk] = item;
                        }
                    }))
                        .finally(() => Object.values(this.lock.threads).forEach(thread => {
                        if (userIds.includes(thread.id))
                            thread.updatedAt = new Date().toString();
                    }));
                }), (lp1, lp2) => () => lp1().then(() => util_1.promisify(setTimeout)(this.workInterval * 1000).then(lp2)));
            })
                .catch((error) => {
                if (error instanceof instagram_private_api_1.IgNetworkError) {
                    logger.warn(`error while fetching stories for all: ${JSON.stringify(error.cause)}`);
                }
                else if (error instanceof instagram_private_api_1.IgLoginRequiredError) {
                    logger.warn('login required, logging in again...');
                    this.session.login().then(this.workForAll);
                }
                else {
                    logger.error(`unhandled error on fetching media for all: ${error}`);
                }
            });
        };
        this.work = () => {
            const lock = this.lock;
            if (this.workInterval < 1)
                this.workInterval = 1;
            if (this.isInactiveTime || lock.feed.length === 0) {
                setTimeout(this.work, this.workInterval * 1000);
                return;
            }
            if (lock.workon >= lock.feed.length)
                lock.workon = 0;
            const currentFeed = lock.feed[lock.workon];
            if (!lock.threads[currentFeed] ||
                !lock.threads[currentFeed].subscribers ||
                lock.threads[currentFeed].subscribers.length === 0) {
                logger.warn(`nobody subscribes thread ${currentFeed}, removing from feed`);
                delete lock.threads[currentFeed];
                this.cache[parseLink(currentFeed).userName].pullOrder = 0;
                lock.feed.splice(lock.workon, 1);
                fs.writeFileSync(path.resolve(this.lockfile), JSON.stringify(lock));
                this.work();
                return;
            }
            logger.debug(`searching for new items from ${currentFeed} in cache`);
            const match = /https:\/\/www\.instagram\.com\/([^\/]+)/.exec(currentFeed);
            if (!match) {
                logger.error(`current feed "${currentFeed}" is invalid, please remove this feed manually`);
                lock.workon++;
                setTimeout(this.work, this.workInterval * 1000);
                return;
            }
            const cachedFeed = this.cache[match[1]];
            if (!cachedFeed) {
                setTimeout(this.work, this.workInterval * 1000);
                return;
            }
            const newer = (item) => utils_1.BigNumOps.compare(item.pk, lock.threads[currentFeed].offset) > 0;
            const promise = Promise.resolve(Object.values(cachedFeed.stories)
                .filter(newer)
                .map(story => (Object.assign(Object.assign({}, story), { user: cachedFeed.user })))
                .sort((i1, i2) => utils_1.BigNumOps.compare(i2.pk, i1.pk)));
            promise.then((mediaItems) => {
                const currentThread = lock.threads[currentFeed];
                if (!mediaItems || mediaItems.length === 0)
                    return;
                const topOfFeed = mediaItems[0].pk;
                const updateOffset = () => currentThread.offset = topOfFeed;
                if (currentThread.offset === '-1') {
                    updateOffset();
                    return;
                }
                if (currentThread.offset === '0')
                    mediaItems.splice(1);
                return this.workOnMedia(mediaItems, this.sendStories(`thread ${currentFeed}`, ...currentThread.subscribers))
                    .then(updateOffset);
            })
                .then(() => {
                lock.workon++;
                let timeout = this.workInterval * 1000 / lock.feed.length;
                if (timeout < 1000)
                    timeout = 1000;
                fs.writeFileSync(path.resolve(this.lockfile), JSON.stringify(lock));
                setTimeout(this.work, timeout);
            });
        };
        this.client = new instagram_private_api_1.IgApiClient();
        if (opt.proxyUrl) {
            try {
                const url = new URL(opt.proxyUrl);
                if (!/^socks(?:4a?|5h?)?:$/.test(url.protocol))
                    throw Error();
                if (!url.port)
                    url.port = '1080';
                this.client.request.defaults.agent = new socks_proxy_agent_1.SocksProxyAgent({
                    hostname: url.hostname,
                    port: url.port,
                    userId: url.username,
                    password: url.password,
                });
            }
            catch (e) {
                logger.warn(`invalid socks proxy url: ${opt.proxyUrl}, ignoring`);
            }
        }
        this.session = new SessionManager(this.client, opt.sessionLockfile, opt.credentials, opt.codeServicePort);
        this.lockfile = opt.lockfile;
        this.lock = opt.lock;
        this.inactiveHours = opt.inactiveHours;
        this.workInterval = opt.workInterval;
        this.bot = opt.bot;
        this.webshotDelay = opt.webshotDelay;
        this.mode = opt.mode;
        this.wsUrl = opt.wsUrl;
        ScreenNameNormalizer._queryUser = this.queryUser;
        exports.sendAllStories = (rawUserName, receiver) => {
            const sender = this.sendStories(`instagram stories for ${rawUserName}`, receiver);
            this.queryUser(rawUserName)
                .then(userNameId => {
                const [userName, userId] = userNameId.split(':');
                if (userName in this.cache && Object.keys(this.cache[userName].stories).length > 0) {
                    return Promise.resolve(Object.values(this.cache[userName].stories)
                        .map(story => (Object.assign(Object.assign({}, story), { user: this.cache[userName].user })))
                        .sort((i1, i2) => utils_1.BigNumOps.compare(i2.pk, i1.pk)));
                }
                return this.client.feed.reelsMedia({ userIds: [userId] }).items()
                    .then(storyItems => {
                    storyItems = storyItems.map(story => (Object.assign(Object.assign({}, story), { user: this.cache[userName].user })));
                    storyItems.forEach(item => {
                        if (!(item.pk in this.cache[userName].stories)) {
                            this.cache[userName].stories[item.pk] = item;
                        }
                    });
                    if (storyItems.length === 0)
                        this.bot.sendTo(receiver, `当前用户 (@${userName}) 没有可用的推特故事。`);
                    return storyItems;
                });
            })
                .then(storyItems => this.workOnMedia(storyItems, sender))
                .catch((error) => {
                if (error instanceof instagram_private_api_1.IgNetworkError) {
                    logger.warn(`error while fetching stories for ${rawUserName}: ${JSON.stringify(error.cause)}`);
                    this.bot.sendTo(receiver, `获取 Stories 时出现错误：原因： ${error.cause}`);
                }
                else if (error instanceof instagram_private_api_1.IgLoginRequiredError) {
                    logger.warn('login required, logging in again...');
                    this.session.login().then(() => exports.sendAllStories(rawUserName, receiver));
                }
                else {
                    logger.error(`unhandled error while fetching stories for ${rawUserName}: ${error}`);
                    this.bot.sendTo(receiver, `获取 Stories 时发生未知错误： ${error}`);
                }
            });
        };
    }
    get pullOrders() {
        const arr = [];
        Object.values(this.cache).forEach(item => { if (item.pullOrder > 0)
            arr[item.pullOrder - 1] = item.user.pk; });
        return arr;
    }
    ;
    set pullOrders(arr) {
        Object.values(this.cache).forEach(item => { item.pullOrder = arr.indexOf(item.user.pk) + 1; });
    }
    get isInactiveTime() {
        const timeToEpoch = (h = 0, m = 0) => new Date().setHours(h, m, 0, 0);
        return this.inactiveHours
            .map(rangeStr => ((start, end) => ({ start, end }))(...rangeStr.split('-', 2).map(timeStr => timeToEpoch(...timeStr.split(':', 2).map(Number)))))
            .some(range => (now => now >= range.start && now < range.end)(Date.now()));
    }
}
exports.default = default_1;