gocqhttp-twitter-bot/src/twitter.ts

import * as fs from 'fs';
import * as path from 'path';
import {
  instagramIdToUrlSegment as idToUrlSegment,
  urlSegmentToInstagramId as urlSegmentToId
} from 'instagram-id-to-url-segment';
import {
  IgApiClient,
  IgClientError, IgExactUserNotFoundError, IgNetworkError, IgNotFoundError, IgResponseError,
  MediaInfoResponseItemsItem, UserFeedResponseItemsItem
} from 'instagram-private-api';
import { RequestError } from 'request-promise/errors';

import { getLogger } from './loggers';
import QQBot, { Message } from './koishi';
import { BigNumOps } from './utils';
import Webshot, { Cookies, Page } from './webshot';

const parseLink = (link: string): {userName?: string, postUrlSegment?: string} => {
  let match =
    /instagram\.com\/p\/([A-Za-z0-9\-_]+)/.exec(link);
  if (match) return {postUrlSegment: match[1]};
  match =
    /instagram\.com\/([^\/?#]+)/.exec(link) ||
    /^([^\/?#]+)$/.exec(link);
  if (match) return {userName: ScreenNameNormalizer.normalize(match[1]).split(':')[0]};
  return;
};

const isValidUrlSegment = (input: string) => /^[A-Za-z0-9\-_]+$/.test(input);

const linkBuilder = (config: ReturnType<typeof parseLink>): string => {
  if (config.userName) return `https://www.instagram.com/${config.userName}/`;
  if (config.postUrlSegment) return `https://www.instagram.com/p/${config.postUrlSegment}/`;
};

export {linkBuilder, parseLink, isValidUrlSegment, idToUrlSegment, urlSegmentToId};

interface IWorkerOption {
  sessionLockfile: string;
  credentials: [string, string];
  lock: ILock;
  lockfile: string;
  webshotCookiesLockfile: string;
  bot: QQBot;
  workInterval: number;
  webshotDelay: number;
  mode: number;
  wsUrl: string;
}

export class SessionManager {
  private ig: IgApiClient;
  private username: string;
  private password: string;
  private lockfile: string;
  
  constructor(client: IgApiClient, file: string, credentials: [string, string]) {
    this.ig = client;
    this.lockfile = file;
    [this.username, this.password] = credentials;
  }

  public 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')) as {[key: string]: any};
        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();
  };

  public login = () =>
    this.ig.simulate.preLoginFlow()
      .then(() => this.ig.account.login(this.username, this.password))
      .then(() => new Promise(resolve => {
        logger.info(`successfully logged in as ${this.username}`);
        process.nextTick(() => resolve(this.ig.simulate.postLoginFlow()));
      }));

  public save = () =>
    this.ig.state.serialize()
      .then((serialized: {[key: string]: any}) => {
        delete serialized.constants;
        return fs.writeFileSync(path.resolve(this.lockfile), JSON.stringify(serialized, null, 2), 'utf-8');
      });
}

export class ScreenNameNormalizer {

  // tslint:disable-next-line: variable-name
  public static _queryUser: (username: string) => Promise<string>;

  public static normalize = (username: string) => `${username.toLowerCase().replace(/^@/, '')}:`;

  public static async normalizeLive(username: string) {
    if (this._queryUser) {
      return await this._queryUser(username)
        .catch((err: IgClientError) => {
          if (!(err instanceof IgExactUserNotFoundError)) {
            logger.warn(`error looking up user: ${err.message}`);
            return `${username}:`;
          }
          return null;
        });
    }
    return this.normalize(username);
  }
}

export let browserLogin = (page: Page): Promise<void> => Promise.reject();

export let getPostOwner = (segmentId: string): Promise<string> => Promise.reject();

export let sendPost = (segmentId: string, receiver: IChat): void => {
  throw Error();
};

export type MediaItem = MediaInfoResponseItemsItem & UserFeedResponseItemsItem;

const logger = getLogger('instagram');
const maxTrials = 3;
const retryInterval = 1500;
const ordinal = (n: number) => {
  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 = <T, U>(
  doWork: () => Promise<T>,
  onRetry: (error, count: number, terminate: (defaultValue: U) => void) => void
) => new Promise<T | U>(resolve => {
  const retry = (reason, count: number) => {
    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));
});

export default class {

  private client: IgApiClient;
  private lock: ILock;
  private lockfile: string;
  private workInterval: number;
  private bot: QQBot;
  private webshotDelay: number;
  private webshotCookies: Cookies;
  private webshotCookiesLockfile: string;
  private webshot: Webshot;
  private mode: number;
  private wsUrl: string;

  public session: SessionManager;

  constructor(opt: IWorkerOption) {
    this.client = new IgApiClient();
    this.session = new SessionManager(this.client, opt.sessionLockfile, opt.credentials);
    this.lockfile = opt.lockfile;
    this.webshotCookiesLockfile = opt.webshotCookiesLockfile;
    this.lock = opt.lock;
    this.workInterval = opt.workInterval;
    this.bot = opt.bot;
    this.webshotDelay = opt.webshotDelay;
    this.mode = opt.mode;
    this.wsUrl = opt.wsUrl;

    const cookiesFilePath = path.resolve(this.webshotCookiesLockfile);
    if (fs.existsSync(cookiesFilePath)) {
      try {
        this.webshotCookies = JSON.parse(fs.readFileSync(cookiesFilePath, 'utf8')) as Cookies;
        logger.info(`loaded webshot cookies from file ${this.webshotCookiesLockfile}`);
      } catch (err) {
        logger.warn(`failed to load webshot cookies from file ${this.webshotCookiesLockfile}: `, err);
        logger.warn('cookies will be saved to this file when needed');
      }
    }

    browserLogin = (page) => {
      logger.warn('blocked by login dialog, trying to log in manually...');
      return page.type('input[name="username"]', opt.credentials[0])
        .then(() => page.type('input[name="password"]', opt.credentials[1]))
        .then(() => page.click('button[type="submit"]'))
        .then(() => page.click('button:has-text("情報を保存")'))
        .then(() => page.waitForSelector('img[data-testid="user-avatar"]', {timeout: this.webshotDelay}))
        .then(() => page.context().cookies())
        .then(cookies => {
          this.webshotCookies = cookies;
          logger.info('successfully logged in, saving cookies to file...');
          fs.writeFileSync(path.resolve(this.webshotCookiesLockfile), JSON.stringify(cookies, null, 2), 'utf-8');
        })
        .catch((err: Error) => {
          if (err.name === 'TimeoutError') logger.warn('navigation timed out, assuming login has failed');
          throw err;
        });
    };
    ScreenNameNormalizer._queryUser = this.queryUser;
    const parseMediaError = (err: IgClientError) => {
      if (!(err instanceof IgResponseError && err.text === 'Media not found or unavailable')) {
        logger.warn(`error retrieving instagram media: ${err.message}`);
        return `获取媒体时出现错误：${err.message}`;
      }
      return '找不到请求的媒体，它可能已被删除。';
    };
    getPostOwner = (segmentId) => 
      this.client.media.info(urlSegmentToId(segmentId))
        .then(media => media.items[0].user)
        .then(user => `${user.username}:${user.pk}`)
        .catch((err: IgClientError) => { throw Error(parseMediaError(err)); });
    sendPost = (segmentId, receiver) => {
      this.getMedia(segmentId, this.sendMedia(`instagram media ${segmentId}`, receiver))
        .catch((err: IgClientError) => { this.bot.sendTo(receiver, parseMediaError(err)); });
    };
  }

  public launch = () => {
    this.webshot = new Webshot(
      this.wsUrl,
      this.mode,
      () => this.webshotCookies,
      () => setTimeout(this.work, this.workInterval * 1000)
    );
  };

  public queryUser = (username: string) => this.client.user.searchExact(username)
    .then(user => `${user.username}:${user.pk}`);

  private workOnMedia = (
    mediaItems: MediaItem[],
    sendMedia: (msg: string, text: string, author: string) => void
  ) => this.webshot(mediaItems, sendMedia, this.webshotDelay);

  public urlSegmentToId = urlSegmentToId;

  public getMedia = (segmentId: string, sender: (msg: string, text: string, author: string) => void) =>
    this.client.media.info(urlSegmentToId(segmentId))
      .then(media => {
        const mediaItem = media.items[0] as MediaItem;
        logger.debug(`api returned media post ${JSON.stringify(mediaItem)} for query id=${segmentId}`);
        return this.workOnMedia([mediaItem], sender);
      });

  private sendMedia = (source?: string, ...to: IChat[]) => (msg: string, text: string, author: string) => {
    to.forEach(subscriber => {
      logger.info(`pushing data${source ? ` of ${Message.ellipseBase64(source)}` : ''} to ${JSON.stringify(subscriber)}`);
      retryOnError(
        () => this.bot.sendTo(subscriber, msg),
        (_, count, terminate: (doNothing: Promise<void>) => void) => {
          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));
          }
        });
    });
  };

  public work = () => {
    const lock = this.lock;
    if (this.workInterval < 1) this.workInterval = 1;
    if (lock.feed.length === 0) {
      setTimeout(() => {
        this.work();
      }, this.workInterval * 1000);
      return;
    }
    if (lock.workon >= lock.feed.length) lock.workon = 0;
    if (!lock.threads[lock.feed[lock.workon]] ||
      !lock.threads[lock.feed[lock.workon]].subscribers ||
      lock.threads[lock.feed[lock.workon]].subscribers.length === 0) {
      logger.warn(`nobody subscribes thread ${lock.feed[lock.workon]}, removing from feed`);
      delete lock.threads[lock.feed[lock.workon]];
      lock.feed.splice(lock.workon, 1);
      fs.writeFileSync(path.resolve(this.lockfile), JSON.stringify(lock));
      this.work();
      return;
    }

    const currentFeed = lock.feed[lock.workon];
    logger.debug(`pulling feed ${currentFeed}`);

    const promise = new Promise<UserFeedResponseItemsItem[]>(resolve => {
      const match = /https:\/\/www\.instagram\.com\/([^\/]+)/.exec(currentFeed);
      if (match) {
        const feed = this.client.feed.user(lock.threads[currentFeed].id);
        const newer = (item: UserFeedResponseItemsItem) =>
          BigNumOps.compare(item.pk, lock.threads[currentFeed].offset) > 0;
        const fetchMore = () => new Promise<UserFeedResponseItemsItem[]>(fetch => {
          feed.request().then(response => {
            if (response.items.length === 0) return fetch([]);
            if (response.items.every(newer)) {
              fetchMore().then(fetched => fetch(response.items.concat(fetched)));
            } else fetch(response.items.filter(newer));
          }, (error: IgClientError & Partial<RequestError>) => {
            if (error instanceof IgNetworkError) {
              logger.warn(`error on fetching media for ${currentFeed}: ${JSON.stringify(error.cause)}`);
              if (!(error instanceof IgNotFoundError)) return;
              lock.threads[currentFeed].subscribers.forEach(subscriber => {
                logger.info(`sending notfound message of ${currentFeed} to ${JSON.stringify(subscriber)}`);
                this.bot.sendTo(subscriber, `链接 ${currentFeed} 指向的用户或列表不存在，请退订。`).catch();
              });
            } else {
              logger.error(`unhandled error on fetching media for ${currentFeed}: ${JSON.stringify(error)}`);
            }
            fetch([]);
          });
        });
        fetchMore().then(resolve);
      }
    });

    promise.then((mediaItems: MediaItem[]) => {
      const currentThread = lock.threads[currentFeed];

      const updateDate = () => currentThread.updatedAt = new Date().toString();
      if (!mediaItems || mediaItems.length === 0) { updateDate(); 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.sendMedia(`thread ${currentFeed}`, ...currentThread.subscribers))
        .then(updateDate).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);
      });
  };
}