add: Megalodon, initial mastodon api

packages/megalodon/src/axios.d.ts

@@ -0,0 +1 @@
+declare module "axios/lib/adapters/http";

packages/megalodon/src/cancel.ts

@@ -0,0 +1,13 @@
+export class RequestCanceledError extends Error {
+	public isCancel: boolean;
+
+	constructor(msg: string) {
+		super(msg);
+		this.isCancel = true;
+		Object.setPrototypeOf(this, RequestCanceledError);
+	}
+}
+
+export const isCancel = (value: any): boolean => {
+	return value && value.isCancel;
+};

packages/megalodon/src/converter.ts

@@ -0,0 +1,3 @@
+import MisskeyAPI from "./misskey/api_client";
+
+export default MisskeyAPI.Converter;

packages/megalodon/src/default.ts

@@ -0,0 +1,3 @@
+export const NO_REDIRECT = "urn:ietf:wg:oauth:2.0:oob";
+export const DEFAULT_SCOPE = ["read", "write", "follow"];
+export const DEFAULT_UA = "megalodon";

packages/megalodon/src/entities/account.ts

@@ -0,0 +1,27 @@
+/// <reference path="emoji.ts" />
+/// <reference path="source.ts" />
+/// <reference path="field.ts" />
+namespace Entity {
+	export type Account = {
+		id: string;
+		username: string;
+		acct: string;
+		display_name: string;
+		locked: boolean;
+		created_at: string;
+		followers_count: number;
+		following_count: number;
+		statuses_count: number;
+		note: string;
+		url: string;
+		avatar: string;
+		avatar_static: string;
+		header: string;
+		header_static: string;
+		emojis: Array<Emoji>;
+		moved: Account | null;
+		fields: Array<Field>;
+		bot: boolean | null;
+		source?: Source;
+	};
+}

packages/megalodon/src/entities/activity.ts

@@ -0,0 +1,8 @@
+namespace Entity {
+	export type Activity = {
+		week: string;
+		statuses: string;
+		logins: string;
+		registrations: string;
+	};
+}

packages/megalodon/src/entities/announcement.ts

@@ -0,0 +1,34 @@
+/// <reference path="tag.ts" />
+/// <reference path="emoji.ts" />
+/// <reference path="reaction.ts" />
+
+namespace Entity {
+	export type Announcement = {
+		id: string;
+		content: string;
+		starts_at: string | null;
+		ends_at: string | null;
+		published: boolean;
+		all_day: boolean;
+		published_at: string;
+		updated_at: string;
+		read?: boolean;
+		mentions: Array<AnnouncementAccount>;
+		statuses: Array<AnnouncementStatus>;
+		tags: Array<Tag>;
+		emojis: Array<Emoji>;
+		reactions: Array<Reaction>;
+	};
+
+	export type AnnouncementAccount = {
+		id: string;
+		username: string;
+		url: string;
+		acct: string;
+	};
+
+	export type AnnouncementStatus = {
+		id: string;
+		url: string;
+	};
+}

packages/megalodon/src/entities/application.ts

@@ -0,0 +1,7 @@
+namespace Entity {
+	export type Application = {
+		name: string;
+		website?: string | null;
+		vapid_key?: string | null;
+	};
+}

packages/megalodon/src/entities/async_attachment.ts

@@ -0,0 +1,14 @@
+/// <reference path="attachment.ts" />
+namespace Entity {
+	export type AsyncAttachment = {
+		id: string;
+		type: "unknown" | "image" | "gifv" | "video" | "audio";
+		url: string | null;
+		remote_url: string | null;
+		preview_url: string;
+		text_url: string | null;
+		meta: Meta | null;
+		description: string | null;
+		blurhash: string | null;
+	};
+}

packages/megalodon/src/entities/attachment.ts

@@ -0,0 +1,49 @@
+namespace Entity {
+	export type Sub = {
+		// For Image, Gifv, and Video
+		width?: number;
+		height?: number;
+		size?: string;
+		aspect?: number;
+
+		// For Gifv and Video
+		frame_rate?: string;
+
+		// For Audio, Gifv, and Video
+		duration?: number;
+		bitrate?: number;
+	};
+
+	export type Focus = {
+		x: number;
+		y: number;
+	};
+
+	export type Meta = {
+		original?: Sub;
+		small?: Sub;
+		focus?: Focus;
+		length?: string;
+		duration?: number;
+		fps?: number;
+		size?: string;
+		width?: number;
+		height?: number;
+		aspect?: number;
+		audio_encode?: string;
+		audio_bitrate?: string;
+		audio_channel?: string;
+	};
+
+	export type Attachment = {
+		id: string;
+		type: "unknown" | "image" | "gifv" | "video" | "audio";
+		url: string;
+		remote_url: string | null;
+		preview_url: string | null;
+		text_url: string | null;
+		meta: Meta | null;
+		description: string | null;
+		blurhash: string | null;
+	};
+}

packages/megalodon/src/entities/card.ts

@@ -0,0 +1,16 @@
+namespace Entity {
+	export type Card = {
+		url: string;
+		title: string;
+		description: string;
+		type: "link" | "photo" | "video" | "rich";
+		image?: string;
+		author_name?: string;
+		author_url?: string;
+		provider_name?: string;
+		provider_url?: string;
+		html?: string;
+		width?: number;
+		height?: number;
+	};
+}

packages/megalodon/src/entities/context.ts

@@ -0,0 +1,8 @@
+/// <reference path="status.ts" />
+
+namespace Entity {
+	export type Context = {
+		ancestors: Array<Status>;
+		descendants: Array<Status>;
+	};
+}

packages/megalodon/src/entities/conversation.ts

@@ -0,0 +1,11 @@
+/// <reference path="account.ts" />
+/// <reference path="status.ts" />
+
+namespace Entity {
+	export type Conversation = {
+		id: string;
+		accounts: Array<Account>;
+		last_status: Status | null;
+		unread: boolean;
+	};
+}

packages/megalodon/src/entities/emoji.ts

@@ -0,0 +1,9 @@
+namespace Entity {
+	export type Emoji = {
+		shortcode: string;
+		static_url: string;
+		url: string;
+		visible_in_picker: boolean;
+		category: string;
+	};
+}

packages/megalodon/src/entities/featured_tag.ts

@@ -0,0 +1,8 @@
+namespace Entity {
+	export type FeaturedTag = {
+		id: string;
+		name: string;
+		statuses_count: number;
+		last_status_at: string;
+	};
+}

packages/megalodon/src/entities/field.ts

@@ -0,0 +1,7 @@
+namespace Entity {
+	export type Field = {
+		name: string;
+		value: string;
+		verified_at: string | null;
+	};
+}

packages/megalodon/src/entities/filter.ts

@@ -0,0 +1,12 @@
+namespace Entity {
+	export type Filter = {
+		id: string;
+		phrase: string;
+		context: Array<FilterContext>;
+		expires_at: string | null;
+		irreversible: boolean;
+		whole_word: boolean;
+	};
+
+	export type FilterContext = string;
+}

packages/megalodon/src/entities/history.ts

@@ -0,0 +1,7 @@
+namespace Entity {
+	export type History = {
+		day: string;
+		uses: number;
+		accounts: number;
+	};
+}

packages/megalodon/src/entities/identity_proof.ts

@@ -0,0 +1,9 @@
+namespace Entity {
+	export type IdentityProof = {
+		provider: string;
+		provider_username: string;
+		updated_at: string;
+		proof_url: string;
+		profile_url: string;
+	};
+}

packages/megalodon/src/entities/instance.ts

@@ -0,0 +1,41 @@
+/// <reference path="account.ts" />
+/// <reference path="urls.ts" />
+/// <reference path="stats.ts" />
+
+namespace Entity {
+	export type Instance = {
+		uri: string;
+		title: string;
+		description: string;
+		email: string;
+		version: string;
+		thumbnail: string | null;
+		urls: URLs;
+		stats: Stats;
+		languages: Array<string>;
+		contact_account: Account | null;
+		max_toot_chars?: number;
+		registrations?: boolean;
+		configuration?: {
+			statuses: {
+				max_characters: number;
+				max_media_attachments: number;
+				characters_reserved_per_url: number;
+			};
+			media_attachments: {
+				supported_mime_types: Array<string>;
+				image_size_limit: number;
+				image_matrix_limit: number;
+				video_size_limit: number;
+				video_frame_limit: number;
+				video_matrix_limit: number;
+			};
+			polls: {
+				max_options: number;
+				max_characters_per_option: number;
+				min_expiration: number;
+				max_expiration: number;
+			};
+		};
+	};
+}

packages/megalodon/src/entities/list.ts

@@ -0,0 +1,6 @@
+namespace Entity {
+	export type List = {
+		id: string;
+		title: string;
+	};
+}

packages/megalodon/src/entities/marker.ts

@@ -0,0 +1,15 @@
+namespace Entity {
+	export type Marker = {
+		home?: {
+			last_read_id: string;
+			version: number;
+			updated_at: string;
+		};
+		notifications?: {
+			last_read_id: string;
+			version: number;
+			updated_at: string;
+			unread_count?: number;
+		};
+	};
+}

packages/megalodon/src/entities/mention.ts

@@ -0,0 +1,8 @@
+namespace Entity {
+	export type Mention = {
+		id: string;
+		username: string;
+		url: string;
+		acct: string;
+	};
+}

packages/megalodon/src/entities/notification.ts

@@ -0,0 +1,15 @@
+/// <reference path="account.ts" />
+/// <reference path="status.ts" />
+
+namespace Entity {
+	export type Notification = {
+		account: Account;
+		created_at: string;
+		id: string;
+		status?: Status;
+		reaction?: Reaction;
+		type: NotificationType;
+	};
+
+	export type NotificationType = string;
+}

packages/megalodon/src/entities/poll.ts

@@ -0,0 +1,14 @@
+/// <reference path="poll_option.ts" />
+
+namespace Entity {
+	export type Poll = {
+		id: string;
+		expires_at: string | null;
+		expired: boolean;
+		multiple: boolean;
+		votes_count: number;
+		options: Array<PollOption>;
+		voted: boolean;
+		own_votes: Array<number>;
+	};
+}

packages/megalodon/src/entities/poll_option.ts

@@ -0,0 +1,6 @@
+namespace Entity {
+	export type PollOption = {
+		title: string;
+		votes_count: number | null;
+	};
+}

packages/megalodon/src/entities/preferences.ts

@@ -0,0 +1,9 @@
+namespace Entity {
+	export type Preferences = {
+		"posting:default:visibility": "public" | "unlisted" | "private" | "direct";
+		"posting:default:sensitive": boolean;
+		"posting:default:language": string | null;
+		"reading:expand:media": "default" | "show_all" | "hide_all";
+		"reading:expand:spoilers": boolean;
+	};
+}

packages/megalodon/src/entities/push_subscription.ts

@@ -0,0 +1,16 @@
+namespace Entity {
+	export type Alerts = {
+		follow: boolean;
+		favourite: boolean;
+		mention: boolean;
+		reblog: boolean;
+		poll: boolean;
+	};
+
+	export type PushSubscription = {
+		id: string;
+		endpoint: string;
+		server_key: string;
+		alerts: Alerts;
+	};
+}

packages/megalodon/src/entities/reaction.ts

@@ -0,0 +1,12 @@
+/// <reference path="account.ts" />
+
+namespace Entity {
+	export type Reaction = {
+		count: number;
+		me: boolean;
+		name: string;
+		url?: string;
+		static_url?: string;
+		accounts?: Array<Account>;
+	};
+}

packages/megalodon/src/entities/relationship.ts

@@ -0,0 +1,17 @@
+namespace Entity {
+	export type Relationship = {
+		id: string;
+		following: boolean;
+		followed_by: boolean;
+		delivery_following?: boolean;
+		blocking: boolean;
+		blocked_by: boolean;
+		muting: boolean;
+		muting_notifications: boolean;
+		requested: boolean;
+		domain_blocking: boolean;
+		showing_reblogs: boolean;
+		endorsed: boolean;
+		notifying: boolean;
+	};
+}

packages/megalodon/src/entities/report.ts

@@ -0,0 +1,9 @@
+namespace Entity {
+	export type Report = {
+		id: string;
+		action_taken: string;
+		comment: string;
+		account_id: string;
+		status_ids: Array<string>;
+	};
+}

packages/megalodon/src/entities/results.ts

@@ -0,0 +1,11 @@
+/// <reference path="account.ts" />
+/// <reference path="status.ts" />
+/// <reference path="tag.ts" />
+
+namespace Entity {
+	export type Results = {
+		accounts: Array<Account>;
+		statuses: Array<Status>;
+		hashtags: Array<Tag>;
+	};
+}

packages/megalodon/src/entities/scheduled_status.ts

@@ -0,0 +1,10 @@
+/// <reference path="attachment.ts" />
+/// <reference path="status_params.ts" />
+namespace Entity {
+	export type ScheduledStatus = {
+		id: string;
+		scheduled_at: string;
+		params: StatusParams;
+		media_attachments: Array<Attachment>;
+	};
+}

packages/megalodon/src/entities/source.ts

@@ -0,0 +1,10 @@
+/// <reference path="field.ts" />
+namespace Entity {
+	export type Source = {
+		privacy: string | null;
+		sensitive: boolean | null;
+		language: string | null;
+		note: string;
+		fields: Array<Field>;
+	};
+}

packages/megalodon/src/entities/stats.ts

@@ -0,0 +1,7 @@
+namespace Entity {
+	export type Stats = {
+		user_count: number;
+		status_count: number;
+		domain_count: number;
+	};
+}

packages/megalodon/src/entities/status.ts

@@ -0,0 +1,45 @@
+/// <reference path="account.ts" />
+/// <reference path="application.ts" />
+/// <reference path="mention.ts" />
+/// <reference path="tag.ts" />
+/// <reference path="attachment.ts" />
+/// <reference path="emoji.ts" />
+/// <reference path="card.ts" />
+/// <reference path="poll.ts" />
+/// <reference path="reaction.ts" />
+
+namespace Entity {
+	export type Status = {
+		id: string;
+		uri: string;
+		url: string;
+		account: Account;
+		in_reply_to_id: string | null;
+		in_reply_to_account_id: string | null;
+		reblog: Status | null;
+		content: string;
+		plain_content: string | null;
+		created_at: string;
+		emojis: Emoji[];
+		replies_count: number;
+		reblogs_count: number;
+		favourites_count: number;
+		reblogged: boolean | null;
+		favourited: boolean | null;
+		muted: boolean | null;
+		sensitive: boolean;
+		spoiler_text: string;
+		visibility: "public" | "unlisted" | "private" | "direct";
+		media_attachments: Array<Attachment>;
+		mentions: Array<Mention>;
+		tags: Array<Tag>;
+		card: Card | null;
+		poll: Poll | null;
+		application: Application | null;
+		language: string | null;
+		pinned: boolean | null;
+		reactions: Array<Reaction>;
+		quote: Status | null;
+		bookmarked: boolean;
+	};
+}

packages/megalodon/src/entities/status_edit.ts

@@ -0,0 +1,23 @@
+/// <reference path="account.ts" />
+/// <reference path="application.ts" />
+/// <reference path="mention.ts" />
+/// <reference path="tag.ts" />
+/// <reference path="attachment.ts" />
+/// <reference path="emoji.ts" />
+/// <reference path="card.ts" />
+/// <reference path="poll.ts" />
+/// <reference path="reaction.ts" />
+
+namespace Entity {
+	export type StatusEdit = {
+		account: Account;
+		content: string;
+		plain_content: string | null;
+		created_at: string;
+		emojis: Emoji[];
+		sensitive: boolean;
+		spoiler_text: string;
+		media_attachments: Array<Attachment>;
+		poll: Poll | null;
+	};
+}

packages/megalodon/src/entities/status_params.ts

@@ -0,0 +1,12 @@
+namespace Entity {
+	export type StatusParams = {
+		text: string;
+		in_reply_to_id: string | null;
+		media_ids: Array<string> | null;
+		sensitive: boolean | null;
+		spoiler_text: string | null;
+		visibility: "public" | "unlisted" | "private" | "direct";
+		scheduled_at: string | null;
+		application_id: string;
+	};
+}

packages/megalodon/src/entities/tag.ts

@@ -0,0 +1,10 @@
+/// <reference path="history.ts" />
+
+namespace Entity {
+	export type Tag = {
+		name: string;
+		url: string;
+		history: Array<History> | null;
+		following?: boolean;
+	};
+}

packages/megalodon/src/entities/token.ts

@@ -0,0 +1,8 @@
+namespace Entity {
+	export type Token = {
+		access_token: string;
+		token_type: string;
+		scope: string;
+		created_at: number;
+	};
+}

packages/megalodon/src/entities/urls.ts

@@ -0,0 +1,5 @@
+namespace Entity {
+	export type URLs = {
+		streaming_api: string;
+	};
+}

packages/megalodon/src/entity.ts

@@ -0,0 +1,38 @@
+/// <reference path="./entities/account.ts" />
+/// <reference path="./entities/activity.ts" />
+/// <reference path="./entities/announcement.ts" />
+/// <reference path="./entities/application.ts" />
+/// <reference path="./entities/async_attachment.ts" />
+/// <reference path="./entities/attachment.ts" />
+/// <reference path="./entities/card.ts" />
+/// <reference path="./entities/context.ts" />
+/// <reference path="./entities/conversation.ts" />
+/// <reference path="./entities/emoji.ts" />
+/// <reference path="./entities/featured_tag.ts" />
+/// <reference path="./entities/field.ts" />
+/// <reference path="./entities/filter.ts" />
+/// <reference path="./entities/history.ts" />
+/// <reference path="./entities/identity_proof.ts" />
+/// <reference path="./entities/instance.ts" />
+/// <reference path="./entities/list.ts" />
+/// <reference path="./entities/marker.ts" />
+/// <reference path="./entities/mention.ts" />
+/// <reference path="./entities/notification.ts" />
+/// <reference path="./entities/poll.ts" />
+/// <reference path="./entities/poll_option.ts" />
+/// <reference path="./entities/preferences.ts" />
+/// <reference path="./entities/push_subscription.ts" />
+/// <reference path="./entities/reaction.ts" />
+/// <reference path="./entities/relationship.ts" />
+/// <reference path="./entities/report.ts" />
+/// <reference path="./entities/results.ts" />
+/// <reference path="./entities/scheduled_status.ts" />
+/// <reference path="./entities/source.ts" />
+/// <reference path="./entities/stats.ts" />
+/// <reference path="./entities/status.ts" />
+/// <reference path="./entities/status_params.ts" />
+/// <reference path="./entities/tag.ts" />
+/// <reference path="./entities/token.ts" />
+/// <reference path="./entities/urls.ts" />
+
+export default Entity;

packages/megalodon/src/filter_context.ts

@@ -0,0 +1,11 @@
+import Entity from "./entity";
+
+namespace FilterContext {
+	export const Home: Entity.FilterContext = "home";
+	export const Notifications: Entity.FilterContext = "notifications";
+	export const Public: Entity.FilterContext = "public";
+	export const Thread: Entity.FilterContext = "thread";
+	export const Account: Entity.FilterContext = "account";
+}
+
+export default FilterContext;

packages/megalodon/src/index.ts

@@ -0,0 +1,32 @@
+import Response from "./response";
+import OAuth from "./oauth";
+import { isCancel, RequestCanceledError } from "./cancel";
+import { ProxyConfig } from "./proxy_config";
+import generator, {
+	detector,
+	MegalodonInterface,
+	WebSocketInterface,
+} from "./megalodon";
+import Misskey from "./misskey";
+import Entity from "./entity";
+import NotificationType from "./notification";
+import FilterContext from "./filter_context";
+import Converter from "./converter";
+
+export {
+	Response,
+	OAuth,
+	RequestCanceledError,
+	isCancel,
+	ProxyConfig,
+	detector,
+	MegalodonInterface,
+	WebSocketInterface,
+	NotificationType,
+	FilterContext,
+	Misskey,
+	Entity,
+	Converter,
+};
+
+export default generator;

packages/megalodon/src/misskey/api_client.ts

@@ -0,0 +1,727 @@
+import axios, { AxiosResponse, AxiosRequestConfig } from "axios";
+import dayjs from "dayjs";
+import FormData from "form-data";
+
+import { DEFAULT_UA } from "../default";
+import proxyAgent, { ProxyConfig } from "../proxy_config";
+import Response from "../response";
+import MisskeyEntity from "./entity";
+import MegalodonEntity from "../entity";
+import WebSocket from "./web_socket";
+import MisskeyNotificationType from "./notification";
+import NotificationType from "../notification";
+
+namespace MisskeyAPI {
+	export namespace Entity {
+		export type App = MisskeyEntity.App;
+		export type Announcement = MisskeyEntity.Announcement;
+		export type Blocking = MisskeyEntity.Blocking;
+		export type Choice = MisskeyEntity.Choice;
+		export type CreatedNote = MisskeyEntity.CreatedNote;
+		export type Emoji = MisskeyEntity.Emoji;
+		export type Favorite = MisskeyEntity.Favorite;
+		export type Field = MisskeyEntity.Field;
+		export type File = MisskeyEntity.File;
+		export type Follower = MisskeyEntity.Follower;
+		export type Following = MisskeyEntity.Following;
+		export type FollowRequest = MisskeyEntity.FollowRequest;
+		export type Hashtag = MisskeyEntity.Hashtag;
+		export type List = MisskeyEntity.List;
+		export type Meta = MisskeyEntity.Meta;
+		export type Mute = MisskeyEntity.Mute;
+		export type Note = MisskeyEntity.Note;
+		export type Notification = MisskeyEntity.Notification;
+		export type Poll = MisskeyEntity.Poll;
+		export type Reaction = MisskeyEntity.Reaction;
+		export type Relation = MisskeyEntity.Relation;
+		export type User = MisskeyEntity.User;
+		export type UserDetail = MisskeyEntity.UserDetail;
+		export type UserDetailMe = MisskeyEntity.UserDetailMe;
+		export type GetAll = MisskeyEntity.GetAll;
+		export type UserKey = MisskeyEntity.UserKey;
+		export type Session = MisskeyEntity.Session;
+		export type Stats = MisskeyEntity.Stats;
+		export type State = MisskeyEntity.State;
+		export type APIEmoji = { emojis: Emoji[] };
+	}
+
+	export class Converter {
+		private baseUrl: string;
+		private instanceHost: string;
+		private plcUrl: string;
+		private modelOfAcct = {
+			id: "1",
+			username: "none",
+			acct: "none",
+			display_name: "none",
+			locked: true,
+			bot: true,
+			discoverable: false,
+			group: false,
+			created_at: "1971-01-01T00:00:00.000Z",
+			note: "",
+			url: "plc",
+			avatar: "plc",
+			avatar_static: "plc",
+			header: "plc",
+			header_static: "plc",
+			followers_count: -1,
+			following_count: 0,
+			statuses_count: 0,
+			last_status_at: "1971-01-01T00:00:00.000Z",
+			noindex: true,
+			emojis: [],
+			fields: [],
+			moved: null,
+		};
+
+		constructor(baseUrl: string) {
+			this.baseUrl = baseUrl;
+			this.instanceHost = baseUrl.substring(baseUrl.indexOf("//") + 2);
+			this.plcUrl = `${baseUrl}/static-assets/transparent.png`;
+			this.modelOfAcct.url = this.plcUrl;
+			this.modelOfAcct.avatar = this.plcUrl;
+			this.modelOfAcct.avatar_static = this.plcUrl;
+			this.modelOfAcct.header = this.plcUrl;
+			this.modelOfAcct.header_static = this.plcUrl;
+		}
+
+		// FIXME: Properly render MFM instead of just escaping HTML characters.
+		escapeMFM = (text: string): string =>
+			text
+				.replace(/&/g, "&")
+				.replace(/</g, "&lt;")
+				.replace(/>/g, "&gt;")
+				.replace(/"/g, "&quot;")
+				.replace(/'/g, "&#39;")
+				.replace(/`/g, "&#x60;")
+				.replace(/\r?\n/g, "<br>");
+
+		emoji = (e: Entity.Emoji): MegalodonEntity.Emoji => {
+			return {
+				shortcode: e.name,
+				static_url: e.url,
+				url: e.url,
+				visible_in_picker: true,
+				category: e.category,
+			};
+		};
+
+		field = (f: Entity.Field): MegalodonEntity.Field => ({
+			name: f.name,
+			value: this.escapeMFM(f.value),
+			verified_at: null,
+		});
+
+		user = (u: Entity.User): MegalodonEntity.Account => {
+			let acct = u.username;
+			let acctUrl = `https://${u.host || this.instanceHost}/@${u.username}`;
+			if (u.host) {
+				acct = `${u.username}@${u.host}`;
+				acctUrl = `https://${u.host}/@${u.username}`;
+			}
+			return {
+				id: u.id,
+				username: u.username,
+				acct: acct,
+				display_name: u.name || u.username,
+				locked: false,
+				created_at: new Date().toISOString(),
+				followers_count: 0,
+				following_count: 0,
+				statuses_count: 0,
+				note: "",
+				url: acctUrl,
+				avatar: u.avatarUrl,
+				avatar_static: u.avatarUrl,
+				header: this.plcUrl,
+				header_static: this.plcUrl,
+				emojis: u.emojis.map((e) => this.emoji(e)),
+				moved: null,
+				fields: [],
+				bot: false,
+			};
+		};
+
+		userDetail = (
+			u: Entity.UserDetail,
+			host: string,
+		): MegalodonEntity.Account => {
+			let acct = u.username;
+			host = host.replace("https://", "");
+			let acctUrl = `https://${host || u.host || this.instanceHost}/@${
+				u.username
+			}`;
+			if (u.host) {
+				acct = `${u.username}@${u.host}`;
+				acctUrl = `https://${u.host}/@${u.username}`;
+			}
+			return {
+				id: u.id,
+				username: u.username,
+				acct: acct,
+				display_name: u.name || u.username,
+				locked: u.isLocked,
+				created_at: u.createdAt,
+				followers_count: u.followersCount,
+				following_count: u.followingCount,
+				statuses_count: u.notesCount,
+				note: u.description?.replace(/\n|\\n/g, "<br>") ?? "",
+				url: acctUrl,
+				avatar: u.avatarUrl,
+				avatar_static: u.avatarUrl,
+				header: u.bannerUrl ?? this.plcUrl,
+				header_static: u.bannerUrl ?? this.plcUrl,
+				emojis: u.emojis && u.emojis.length > 0 ? u.emojis.map((e) => this.emoji(e)) : [],
+				moved: null,
+				fields: u.fields.map((f) => this.field(f)),
+				bot: u.isBot,
+			};
+		};
+
+		userPreferences = (
+			u: MisskeyAPI.Entity.UserDetailMe,
+			v: "public" | "unlisted" | "private" | "direct",
+		): MegalodonEntity.Preferences => {
+			return {
+				"reading:expand:media": "default",
+				"reading:expand:spoilers": false,
+				"posting:default:language": u.lang,
+				"posting:default:sensitive": u.alwaysMarkNsfw,
+				"posting:default:visibility": v,
+			};
+		};
+
+		visibility = (
+			v: "public" | "home" | "followers" | "specified",
+		): "public" | "unlisted" | "private" | "direct" => {
+			switch (v) {
+				case "public":
+					return v;
+				case "home":
+					return "unlisted";
+				case "followers":
+					return "private";
+				case "specified":
+					return "direct";
+			}
+		};
+
+		encodeVisibility = (
+			v: "public" | "unlisted" | "private" | "direct",
+		): "public" | "home" | "followers" | "specified" => {
+			switch (v) {
+				case "public":
+					return v;
+				case "unlisted":
+					return "home";
+				case "private":
+					return "followers";
+				case "direct":
+					return "specified";
+			}
+		};
+
+		fileType = (
+			s: string,
+		): "unknown" | "image" | "gifv" | "video" | "audio" => {
+			if (s === "image/gif") {
+				return "gifv";
+			}
+			if (s.includes("image")) {
+				return "image";
+			}
+			if (s.includes("video")) {
+				return "video";
+			}
+			if (s.includes("audio")) {
+				return "audio";
+			}
+			return "unknown";
+		};
+
+		file = (f: Entity.File): MegalodonEntity.Attachment => {
+			return {
+				id: f.id,
+				type: this.fileType(f.type),
+				url: f.url,
+				remote_url: f.url,
+				preview_url: f.thumbnailUrl,
+				text_url: f.url,
+				meta: {
+					width: f.properties.width,
+					height: f.properties.height,
+				},
+				description: f.comment,
+				blurhash: f.blurhash,
+			};
+		};
+
+		follower = (f: Entity.Follower): MegalodonEntity.Account => {
+			return this.user(f.follower);
+		};
+
+		following = (f: Entity.Following): MegalodonEntity.Account => {
+			return this.user(f.followee);
+		};
+
+		relation = (r: Entity.Relation): MegalodonEntity.Relationship => {
+			return {
+				id: r.id,
+				following: r.isFollowing,
+				followed_by: r.isFollowed,
+				blocking: r.isBlocking,
+				blocked_by: r.isBlocked,
+				muting: r.isMuted,
+				muting_notifications: false,
+				requested: r.hasPendingFollowRequestFromYou,
+				domain_blocking: false,
+				showing_reblogs: true,
+				endorsed: false,
+				notifying: false,
+			};
+		};
+
+		choice = (c: Entity.Choice): MegalodonEntity.PollOption => {
+			return {
+				title: c.text,
+				votes_count: c.votes,
+			};
+		};
+
+		poll = (p: Entity.Poll, id: string): MegalodonEntity.Poll => {
+			const now = dayjs();
+			const expire = dayjs(p.expiresAt);
+			const count = p.choices.reduce((sum, choice) => sum + choice.votes, 0);
+			return {
+				id: id,
+				expires_at: p.expiresAt,
+				expired: now.isAfter(expire),
+				multiple: p.multiple,
+				votes_count: count,
+				options: p.choices.map((c) => this.choice(c)),
+				voted: p.choices.some((c) => c.isVoted),
+				own_votes: p.choices
+					.filter((c) => c.isVoted)
+					.map((c) => p.choices.indexOf(c)),
+			};
+		};
+
+		note = (n: Entity.Note, host: string): MegalodonEntity.Status => {
+			host = host.replace("https://", "");
+
+			return {
+				id: n.id,
+				uri: n.uri ? n.uri : `https://${host}/notes/${n.id}`,
+				url: n.uri ? n.uri : `https://${host}/notes/${n.id}`,
+				account: this.user(n.user),
+				in_reply_to_id: n.replyId,
+				in_reply_to_account_id: n.reply?.userId ?? null,
+				reblog: n.renote ? this.note(n.renote, host) : null,
+				content: n.text ? this.escapeMFM(n.text) : "",
+				plain_content: n.text ? n.text : null,
+				created_at: n.createdAt,
+				// Remove reaction emojis with names containing @ from the emojis list.
+				emojis: n.emojis
+					.filter((e) => e.name.indexOf("@") === -1)
+					.map((e) => this.emoji(e)),
+				replies_count: n.repliesCount,
+				reblogs_count: n.renoteCount,
+				favourites_count: this.getTotalReactions(n.reactions),
+				reblogged: false,
+				favourited: !!n.myReaction,
+				muted: false,
+				sensitive: n.files ? n.files.some((f) => f.isSensitive) : false,
+				spoiler_text: n.cw ? n.cw : "",
+				visibility: this.visibility(n.visibility),
+				media_attachments: n.files ? n.files.map((f) => this.file(f)) : [],
+				mentions: [],
+				tags: [],
+				card: null,
+				poll: n.poll ? this.poll(n.poll, n.id) : null,
+				application: null,
+				language: null,
+				pinned: null,
+				// Use emojis list to provide URLs for emoji reactions.
+				reactions: this.mapReactions(n.emojis, n.reactions, n.myReaction),
+				bookmarked: false,
+				quote: n.renote && n.text ? this.note(n.renote, host) : null,
+			};
+		};
+
+		mapReactions = (
+			emojis: Array<MisskeyEntity.Emoji>,
+			r: { [key: string]: number },
+			myReaction?: string,
+		): Array<MegalodonEntity.Reaction> => {
+			// Map of emoji shortcodes to image URLs.
+			const emojiUrls = new Map<string, string>(
+				emojis.map((e) => [e.name, e.url]),
+			);
+			return Object.keys(r).map((key) => {
+				// Strip colons from custom emoji reaction names to match emoji shortcodes.
+				const shortcode = key.replaceAll(":", "");
+				// If this is a custom emoji (vs. a Unicode emoji), find its image URL.
+				const url = emojiUrls.get(shortcode);
+				// Finally, remove trailing @. from local custom emoji reaction names.
+				const name = shortcode.replace("@.", "");
+				return {
+					count: r[key],
+					me: key === myReaction,
+					name,
+					url,
+					// We don't actually have a static version of the asset, but clients expect one anyway.
+					static_url: url,
+				};
+			});
+		};
+
+		getTotalReactions = (r: { [key: string]: number }): number => {
+			return Object.values(r).length > 0
+				? Object.values(r).reduce(
+						(previousValue, currentValue) => previousValue + currentValue,
+				  )
+				: 0;
+		};
+
+		reactions = (
+			r: Array<Entity.Reaction>,
+		): Array<MegalodonEntity.Reaction> => {
+			const result: Array<MegalodonEntity.Reaction> = [];
+			for (const e of r) {
+				const i = result.findIndex((res) => res.name === e.type);
+				if (i >= 0) {
+					result[i].count++;
+				} else {
+					result.push({
+						count: 1,
+						me: false,
+						name: e.type,
+					});
+				}
+			}
+			return result;
+		};
+
+		noteToConversation = (
+			n: Entity.Note,
+			host: string,
+		): MegalodonEntity.Conversation => {
+			const accounts: Array<MegalodonEntity.Account> = [this.user(n.user)];
+			if (n.reply) {
+				accounts.push(this.user(n.reply.user));
+			}
+			return {
+				id: n.id,
+				accounts: accounts,
+				last_status: this.note(n, host),
+				unread: false,
+			};
+		};
+
+		list = (l: Entity.List): MegalodonEntity.List => ({
+			id: l.id,
+			title: l.name,
+		});
+
+		encodeNotificationType = (
+			e: MegalodonEntity.NotificationType,
+		): MisskeyEntity.NotificationType => {
+			switch (e) {
+				case NotificationType.Follow:
+					return MisskeyNotificationType.Follow;
+				case NotificationType.Mention:
+					return MisskeyNotificationType.Reply;
+				case NotificationType.Favourite:
+				case NotificationType.Reaction:
+					return MisskeyNotificationType.Reaction;
+				case NotificationType.Reblog:
+					return MisskeyNotificationType.Renote;
+				case NotificationType.Poll:
+					return MisskeyNotificationType.PollEnded;
+				case NotificationType.FollowRequest:
+					return MisskeyNotificationType.ReceiveFollowRequest;
+				default:
+					return e;
+			}
+		};
+
+		decodeNotificationType = (
+			e: MisskeyEntity.NotificationType,
+		): MegalodonEntity.NotificationType => {
+			switch (e) {
+				case MisskeyNotificationType.Follow:
+					return NotificationType.Follow;
+				case MisskeyNotificationType.Mention:
+				case MisskeyNotificationType.Reply:
+					return NotificationType.Mention;
+				case MisskeyNotificationType.Renote:
+				case MisskeyNotificationType.Quote:
+					return NotificationType.Reblog;
+				case MisskeyNotificationType.Reaction:
+					return NotificationType.Reaction;
+				case MisskeyNotificationType.PollEnded:
+					return NotificationType.Poll;
+				case MisskeyNotificationType.ReceiveFollowRequest:
+					return NotificationType.FollowRequest;
+				case MisskeyNotificationType.FollowRequestAccepted:
+					return NotificationType.Follow;
+				default:
+					return e;
+			}
+		};
+
+		announcement = (a: Entity.Announcement): MegalodonEntity.Announcement => ({
+			id: a.id,
+			content: `<h1>${this.escapeMFM(a.title)}</h1>${this.escapeMFM(a.text)}`,
+			starts_at: null,
+			ends_at: null,
+			published: true,
+			all_day: false,
+			published_at: a.createdAt,
+			updated_at: a.updatedAt,
+			read: a.isRead,
+			mentions: [],
+			statuses: [],
+			tags: [],
+			emojis: [],
+			reactions: [],
+		});
+
+		notification = (
+			n: Entity.Notification,
+			host: string,
+		): MegalodonEntity.Notification => {
+			let notification = {
+				id: n.id,
+				account: n.user ? this.user(n.user) : this.modelOfAcct,
+				created_at: n.createdAt,
+				type: this.decodeNotificationType(n.type),
+			};
+			if (n.note) {
+				notification = Object.assign(notification, {
+					status: this.note(n.note, host),
+				});
+				if (notification.type === NotificationType.Poll) {
+					notification = Object.assign(notification, {
+						account: this.note(n.note, host).account,
+					});
+				}
+				if (n.reaction) {
+					notification = Object.assign(notification, {
+						reaction: this.mapReactions(n.note.emojis, { [n.reaction]: 1 })[0],
+					});
+				}
+			}
+			return notification;
+		};
+
+		stats = (s: Entity.Stats): MegalodonEntity.Stats => {
+			return {
+				user_count: s.usersCount,
+				status_count: s.notesCount,
+				domain_count: s.instances,
+			};
+		};
+
+		meta = (m: Entity.Meta, s: Entity.Stats): MegalodonEntity.Instance => {
+			const wss = m.uri.replace(/^https:\/\//, "wss://");
+			return {
+				uri: m.uri,
+				title: m.name,
+				description: m.description,
+				email: m.maintainerEmail,
+				version: m.version,
+				thumbnail: m.bannerUrl,
+				urls: {
+					streaming_api: `${wss}/streaming`,
+				},
+				stats: this.stats(s),
+				languages: m.langs,
+				contact_account: null,
+				max_toot_chars: m.maxNoteTextLength,
+				registrations: !m.disableRegistration,
+			};
+		};
+
+		hashtag = (h: Entity.Hashtag): MegalodonEntity.Tag => {
+			return {
+				name: h.tag,
+				url: h.tag,
+				history: null,
+				following: false,
+			};
+		};
+	}
+
+	export const DEFAULT_SCOPE = [
+		"read:account",
+		"write:account",
+		"read:blocks",
+		"write:blocks",
+		"read:drive",
+		"write:drive",
+		"read:favorites",
+		"write:favorites",
+		"read:following",
+		"write:following",
+		"read:mutes",
+		"write:mutes",
+		"write:notes",
+		"read:notifications",
+		"write:notifications",
+		"read:reactions",
+		"write:reactions",
+		"write:votes",
+	];
+
+	/**
+	 * Interface
+	 */
+	export interface Interface {
+		post<T = any>(
+			path: string,
+			params?: any,
+			headers?: { [key: string]: string },
+		): Promise<Response<T>>;
+		cancel(): void;
+		socket(
+			channel:
+				| "user"
+				| "localTimeline"
+				| "hybridTimeline"
+				| "globalTimeline"
+				| "conversation"
+				| "list",
+			listId?: string,
+		): WebSocket;
+	}
+
+	/**
+	 * Misskey API client.
+	 *
+	 * Usign axios for request, you will handle promises.
+	 */
+	export class Client implements Interface {
+		private accessToken: string | null;
+		private baseUrl: string;
+		private userAgent: string;
+		private abortController: AbortController;
+		private proxyConfig: ProxyConfig | false = false;
+		private converter: Converter;
+
+		/**
+		 * @param baseUrl hostname or base URL
+		 * @param accessToken access token from OAuth2 authorization
+		 * @param userAgent UserAgent is specified in header on request.
+		 * @param proxyConfig Proxy setting, or set false if don't use proxy.
+		 * @param converter Converter instance.
+		 */
+		constructor(
+			baseUrl: string,
+			accessToken: string | null,
+			userAgent: string = DEFAULT_UA,
+			proxyConfig: ProxyConfig | false = false,
+			converter: Converter,
+		) {
+			this.accessToken = accessToken;
+			this.baseUrl = baseUrl;
+			this.userAgent = userAgent;
+			this.proxyConfig = proxyConfig;
+			this.abortController = new AbortController();
+			this.converter = converter;
+			axios.defaults.signal = this.abortController.signal;
+		}
+
+		/**
+		 * POST request to mastodon REST API.
+		 * @param path relative path from baseUrl
+		 * @param params Form data
+		 * @param headers Request header object
+		 */
+		public async post<T>(
+			path: string,
+			params: any = {},
+			headers: { [key: string]: string } = {},
+		): Promise<Response<T>> {
+			let options: AxiosRequestConfig = {
+				headers: headers,
+				maxContentLength: Infinity,
+				maxBodyLength: Infinity,
+			};
+			if (this.proxyConfig) {
+				options = Object.assign(options, {
+					httpAgent: proxyAgent(this.proxyConfig),
+					httpsAgent: proxyAgent(this.proxyConfig),
+				});
+			}
+			let bodyParams = params;
+			if (this.accessToken) {
+				if (params instanceof FormData) {
+					bodyParams.append("i", this.accessToken);
+				} else {
+					bodyParams = Object.assign(params, {
+						i: this.accessToken,
+					});
+				}
+			}
+
+			return axios
+				.post<T>(this.baseUrl + path, bodyParams, options)
+				.then((resp: AxiosResponse<T>) => {
+					const res: Response<T> = {
+						data: resp.data,
+						status: resp.status,
+						statusText: resp.statusText,
+						headers: resp.headers,
+					};
+					return res;
+				});
+		}
+
+		/**
+		 * Cancel all requests in this instance.
+		 * @returns void
+		 */
+		public cancel(): void {
+			return this.abortController.abort();
+		}
+
+		/**
+		 * Get connection and receive websocket connection for Misskey API.
+		 *
+		 * @param channel Channel name is user, localTimeline, hybridTimeline, globalTimeline, conversation or list.
+		 * @param listId This parameter is required only list channel.
+		 */
+		public socket(
+			channel:
+				| "user"
+				| "localTimeline"
+				| "hybridTimeline"
+				| "globalTimeline"
+				| "conversation"
+				| "list",
+			listId?: string,
+		): WebSocket {
+			if (!this.accessToken) {
+				throw new Error("accessToken is required");
+			}
+			const url = `${this.baseUrl}/streaming`;
+			const streaming = new WebSocket(
+				url,
+				channel,
+				this.accessToken,
+				listId,
+				this.userAgent,
+				this.proxyConfig,
+				this.converter,
+			);
+			process.nextTick(() => {
+				streaming.start();
+			});
+			return streaming;
+		}
+	}
+}
+
+export default MisskeyAPI;

packages/megalodon/src/misskey/entities/GetAll.ts

@@ -0,0 +1,6 @@
+namespace MisskeyEntity {
+	export type GetAll = {
+		tutorial: number;
+		defaultNoteVisibility: "public" | "home" | "followers" | "specified";
+	};
+}

packages/megalodon/src/misskey/entities/announcement.ts

@@ -0,0 +1,10 @@
+namespace MisskeyEntity {
+	export type Announcement = {
+		id: string;
+		createdAt: string;
+		updatedAt: string;
+		text: string;
+		title: string;
+		isRead?: boolean;
+	};
+}

packages/megalodon/src/misskey/entities/app.ts

@@ -0,0 +1,9 @@
+namespace MisskeyEntity {
+	export type App = {
+		id: string;
+		name: string;
+		callbackUrl: string;
+		permission: Array<string>;
+		secret: string;
+	};
+}

packages/megalodon/src/misskey/entities/blocking.ts

@@ -0,0 +1,10 @@
+/// <reference path="userDetail.ts" />
+
+namespace MisskeyEntity {
+	export type Blocking = {
+		id: string;
+		createdAt: string;
+		blockeeId: string;
+		blockee: UserDetail;
+	};
+}

packages/megalodon/src/misskey/entities/createdNote.ts

@@ -0,0 +1,7 @@
+/// <reference path="note.ts" />
+
+namespace MisskeyEntity {
+	export type CreatedNote = {
+		createdNote: Note;
+	};
+}

packages/megalodon/src/misskey/entities/emoji.ts

@@ -0,0 +1,9 @@
+namespace MisskeyEntity {
+	export type Emoji = {
+		name: string;
+		host: string | null;
+		url: string;
+		aliases: Array<string>;
+		category: string;
+	};
+}

packages/megalodon/src/misskey/entities/favorite.ts

@@ -0,0 +1,10 @@
+/// <reference path="note.ts" />
+
+namespace MisskeyEntity {
+	export type Favorite = {
+		id: string;
+		createdAt: string;
+		noteId: string;
+		note: Note;
+	};
+}

packages/megalodon/src/misskey/entities/field.ts

@@ -0,0 +1,7 @@
+namespace MisskeyEntity {
+	export type Field = {
+		name: string;
+		value: string;
+		verified?: string;
+	};
+}

packages/megalodon/src/misskey/entities/file.ts

@@ -0,0 +1,20 @@
+namespace MisskeyEntity {
+	export type File = {
+		id: string;
+		createdAt: string;
+		name: string;
+		type: string;
+		md5: string;
+		size: number;
+		isSensitive: boolean;
+		properties: {
+			width: number;
+			height: number;
+			avgColor: string;
+		};
+		url: string;
+		thumbnailUrl: string;
+		comment: string;
+		blurhash: string;
+	};
+}

packages/megalodon/src/misskey/entities/followRequest.ts

@@ -0,0 +1,9 @@
+/// <reference path="user.ts" />
+
+namespace MisskeyEntity {
+	export type FollowRequest = {
+		id: string;
+		follower: User;
+		followee: User;
+	};
+}

packages/megalodon/src/misskey/entities/follower.ts

@@ -0,0 +1,11 @@
+/// <reference path="userDetail.ts" />
+
+namespace MisskeyEntity {
+	export type Follower = {
+		id: string;
+		createdAt: string;
+		followeeId: string;
+		followerId: string;
+		follower: UserDetail;
+	};
+}

packages/megalodon/src/misskey/entities/following.ts

@@ -0,0 +1,11 @@
+/// <reference path="userDetail.ts" />
+
+namespace MisskeyEntity {
+	export type Following = {
+		id: string;
+		createdAt: string;
+		followeeId: string;
+		followerId: string;
+		followee: UserDetail;
+	};
+}

packages/megalodon/src/misskey/entities/hashtag.ts

@@ -0,0 +1,7 @@
+namespace MisskeyEntity {
+	export type Hashtag = {
+		tag: string;
+		chart: Array<number>;
+		usersCount: number;
+	};
+}

packages/megalodon/src/misskey/entities/list.ts

@@ -0,0 +1,8 @@
+namespace MisskeyEntity {
+	export type List = {
+		id: string;
+		createdAt: string;
+		name: string;
+		userIds: Array<string>;
+	};
+}

packages/megalodon/src/misskey/entities/meta.ts

@@ -0,0 +1,18 @@
+/// <reference path="emoji.ts" />
+
+namespace MisskeyEntity {
+	export type Meta = {
+		maintainerName: string;
+		maintainerEmail: string;
+		name: string;
+		version: string;
+		uri: string;
+		description: string;
+		langs: Array<string>;
+		disableRegistration: boolean;
+		disableLocalTimeline: boolean;
+		bannerUrl: string;
+		maxNoteTextLength: 3000;
+		emojis: Array<Emoji>;
+	};
+}

packages/megalodon/src/misskey/entities/mute.ts

@@ -0,0 +1,10 @@
+/// <reference path="userDetail.ts" />
+
+namespace MisskeyEntity {
+	export type Mute = {
+		id: string;
+		createdAt: string;
+		muteeId: string;
+		mutee: UserDetail;
+	};
+}

packages/megalodon/src/misskey/entities/note.ts

@@ -0,0 +1,32 @@
+/// <reference path="user.ts" />
+/// <reference path="emoji.ts" />
+/// <reference path="file.ts" />
+/// <reference path="poll.ts" />
+
+namespace MisskeyEntity {
+	export type Note = {
+		id: string;
+		createdAt: string;
+		userId: string;
+		user: User;
+		text: string | null;
+		cw: string | null;
+		visibility: "public" | "home" | "followers" | "specified";
+		renoteCount: number;
+		repliesCount: number;
+		reactions: { [key: string]: number };
+		emojis: Array<Emoji>;
+		fileIds: Array<string>;
+		files: Array<File>;
+		replyId: string | null;
+		renoteId: string | null;
+		uri?: string;
+		reply?: Note;
+		renote?: Note;
+		viaMobile?: boolean;
+		tags?: Array<string>;
+		poll?: Poll;
+		mentions?: Array<string>;
+		myReaction?: string;
+	};
+}

packages/megalodon/src/misskey/entities/notification.ts

@@ -0,0 +1,17 @@
+/// <reference path="user.ts" />
+/// <reference path="note.ts" />
+
+namespace MisskeyEntity {
+	export type Notification = {
+		id: string;
+		createdAt: string;
+		// https://github.com/syuilo/misskey/blob/056942391aee135eb6c77aaa63f6ed5741d701a6/src/models/entities/notification.ts#L50-L62
+		type: NotificationType;
+		userId: string;
+		user: User;
+		note?: Note;
+		reaction?: string;
+	};
+
+	export type NotificationType = string;
+}

packages/megalodon/src/misskey/entities/poll.ts

@@ -0,0 +1,13 @@
+namespace MisskeyEntity {
+	export type Choice = {
+		text: string;
+		votes: number;
+		isVoted: boolean;
+	};
+
+	export type Poll = {
+		multiple: boolean;
+		expiresAt: string;
+		choices: Array<Choice>;
+	};
+}

packages/megalodon/src/misskey/entities/reaction.ts

@@ -0,0 +1,11 @@
+/// <reference path="user.ts" />
+
+namespace MisskeyEntity {
+	export type Reaction = {
+		id: string;
+		createdAt: string;
+		user: User;
+		url?: string;
+		type: string;
+	};
+}

packages/megalodon/src/misskey/entities/relation.ts

@@ -0,0 +1,12 @@
+namespace MisskeyEntity {
+	export type Relation = {
+		id: string;
+		isFollowing: boolean;
+		hasPendingFollowRequestFromYou: boolean;
+		hasPendingFollowRequestToYou: boolean;
+		isFollowed: boolean;
+		isBlocking: boolean;
+		isBlocked: boolean;
+		isMuted: boolean;
+	};
+}

packages/megalodon/src/misskey/entities/session.ts

@@ -0,0 +1,6 @@
+namespace MisskeyEntity {
+	export type Session = {
+		token: string;
+		url: string;
+	};
+}

packages/megalodon/src/misskey/entities/state.ts

@@ -0,0 +1,7 @@
+namespace MisskeyEntity {
+	export type State = {
+		isFavorited: boolean;
+		isMutedThread: boolean;
+		isWatching: boolean;
+	};
+}

packages/megalodon/src/misskey/entities/stats.ts

@@ -0,0 +1,9 @@
+namespace MisskeyEntity {
+	export type Stats = {
+		notesCount: number;
+		originalNotesCount: number;
+		usersCount: number;
+		originalUsersCount: number;
+		instances: number;
+	};
+}

packages/megalodon/src/misskey/entities/user.ts

@@ -0,0 +1,13 @@
+/// <reference path="emoji.ts" />
+
+namespace MisskeyEntity {
+	export type User = {
+		id: string;
+		name: string;
+		username: string;
+		host: string | null;
+		avatarUrl: string;
+		avatarColor: string;
+		emojis: Array<Emoji>;
+	};
+}

packages/megalodon/src/misskey/entities/userDetail.ts

@@ -0,0 +1,34 @@
+/// <reference path="emoji.ts" />
+/// <reference path="field.ts" />
+/// <reference path="note.ts" />
+
+namespace MisskeyEntity {
+	export type UserDetail = {
+		id: string;
+		name: string;
+		username: string;
+		host: string | null;
+		avatarUrl: string;
+		avatarColor: string;
+		isAdmin: boolean;
+		isModerator: boolean;
+		isBot: boolean;
+		isCat: boolean;
+		emojis: Array<Emoji>;
+		createdAt: string;
+		bannerUrl: string;
+		bannerColor: string;
+		isLocked: boolean;
+		isSilenced: boolean;
+		isSuspended: boolean;
+		description: string;
+		followersCount: number;
+		followingCount: number;
+		notesCount: number;
+		avatarId: string;
+		bannerId: string;
+		pinnedNoteIds?: Array<string>;
+		pinnedNotes?: Array<Note>;
+		fields: Array<Field>;
+	};
+}

packages/megalodon/src/misskey/entities/userDetailMe.ts

@@ -0,0 +1,36 @@
+/// <reference path="emoji.ts" />
+/// <reference path="field.ts" />
+/// <reference path="note.ts" />
+
+namespace MisskeyEntity {
+	export type UserDetailMe = {
+		id: string;
+		name: string;
+		username: string;
+		host: string | null;
+		avatarUrl: string;
+		avatarColor: string;
+		isAdmin: boolean;
+		isModerator: boolean;
+		isBot: boolean;
+		isCat: boolean;
+		emojis: Array<Emoji>;
+		createdAt: string;
+		bannerUrl: string;
+		bannerColor: string;
+		isLocked: boolean;
+		isSilenced: boolean;
+		isSuspended: boolean;
+		description: string;
+		followersCount: number;
+		followingCount: number;
+		notesCount: number;
+		avatarId: string;
+		bannerId: string;
+		pinnedNoteIds?: Array<string>;
+		pinnedNotes?: Array<Note>;
+		fields: Array<Field>;
+		alwaysMarkNsfw: boolean;
+		lang: string | null;
+	};
+}

packages/megalodon/src/misskey/entities/userkey.ts

@@ -0,0 +1,8 @@
+/// <reference path="user.ts" />
+
+namespace MisskeyEntity {
+	export type UserKey = {
+		accessToken: string;
+		user: User;
+	};
+}

packages/megalodon/src/misskey/entity.ts

@@ -0,0 +1,28 @@
+/// <reference path="entities/app.ts" />
+/// <reference path="entities/announcement.ts" />
+/// <reference path="entities/blocking.ts" />
+/// <reference path="entities/createdNote.ts" />
+/// <reference path="entities/emoji.ts" />
+/// <reference path="entities/favorite.ts" />
+/// <reference path="entities/field.ts" />
+/// <reference path="entities/file.ts" />
+/// <reference path="entities/follower.ts" />
+/// <reference path="entities/following.ts" />
+/// <reference path="entities/followRequest.ts" />
+/// <reference path="entities/hashtag.ts" />
+/// <reference path="entities/list.ts" />
+/// <reference path="entities/meta.ts" />
+/// <reference path="entities/mute.ts" />
+/// <reference path="entities/note.ts" />
+/// <reference path="entities/notification.ts" />
+/// <reference path="entities/poll.ts" />
+/// <reference path="entities/reaction.ts" />
+/// <reference path="entities/relation.ts" />
+/// <reference path="entities/user.ts" />
+/// <reference path="entities/userDetail.ts" />
+/// <reference path="entities/userDetailMe.ts" />
+/// <reference path="entities/userkey.ts" />
+/// <reference path="entities/session.ts" />
+/// <reference path="entities/stats.ts" />
+
+export default MisskeyEntity;

packages/megalodon/src/misskey/notification.ts

@@ -0,0 +1,18 @@
+import MisskeyEntity from "./entity";
+
+namespace MisskeyNotificationType {
+	export const Follow: MisskeyEntity.NotificationType = "follow";
+	export const Mention: MisskeyEntity.NotificationType = "mention";
+	export const Reply: MisskeyEntity.NotificationType = "reply";
+	export const Renote: MisskeyEntity.NotificationType = "renote";
+	export const Quote: MisskeyEntity.NotificationType = "quote";
+	export const Reaction: MisskeyEntity.NotificationType = "favourite";
+	export const PollEnded: MisskeyEntity.NotificationType = "pollEnded";
+	export const ReceiveFollowRequest: MisskeyEntity.NotificationType =
+		"receiveFollowRequest";
+	export const FollowRequestAccepted: MisskeyEntity.NotificationType =
+		"followRequestAccepted";
+	export const GroupInvited: MisskeyEntity.NotificationType = "groupInvited";
+}
+
+export default MisskeyNotificationType;

packages/megalodon/src/misskey/web_socket.ts

@@ -0,0 +1,458 @@
+import WS from "ws";
+import dayjs, { Dayjs } from "dayjs";
+import { v4 as uuid } from "uuid";
+import { EventEmitter } from "events";
+import { WebSocketInterface } from "../megalodon";
+import proxyAgent, { ProxyConfig } from "../proxy_config";
+import MisskeyAPI from "./api_client";
+
+/**
+ * WebSocket
+ * Misskey is not support http streaming. It supports websocket instead of streaming.
+ * So this class connect to Misskey server with WebSocket.
+ */
+export default class WebSocket
+	extends EventEmitter
+	implements WebSocketInterface
+{
+	public url: string;
+	public channel:
+		| "user"
+		| "localTimeline"
+		| "hybridTimeline"
+		| "globalTimeline"
+		| "conversation"
+		| "list";
+	public parser: any;
+	public headers: { [key: string]: string };
+	public proxyConfig: ProxyConfig | false = false;
+	public listId: string | null = null;
+	private _converter: MisskeyAPI.Converter;
+	private _accessToken: string;
+	private _reconnectInterval: number;
+	private _reconnectMaxAttempts: number;
+	private _reconnectCurrentAttempts: number;
+	private _connectionClosed: boolean;
+	private _client: WS | null = null;
+	private _channelID: string;
+	private _pongReceivedTimestamp: Dayjs;
+	private _heartbeatInterval = 60000;
+	private _pongWaiting = false;
+
+	/**
+	 * @param url Full url of websocket: e.g. wss://misskey.io/streaming
+	 * @param channel Channel name is user, localTimeline, hybridTimeline, globalTimeline, conversation or list.
+	 * @param accessToken The access token.
+	 * @param listId This parameter is required when you specify list as channel.
+	 */
+	constructor(
+		url: string,
+		channel:
+			| "user"
+			| "localTimeline"
+			| "hybridTimeline"
+			| "globalTimeline"
+			| "conversation"
+			| "list",
+		accessToken: string,
+		listId: string | undefined,
+		userAgent: string,
+		proxyConfig: ProxyConfig | false = false,
+		converter: MisskeyAPI.Converter,
+	) {
+		super();
+		this.url = url;
+		this.parser = new Parser();
+		this.channel = channel;
+		this.headers = {
+			"User-Agent": userAgent,
+		};
+		if (listId === undefined) {
+			this.listId = null;
+		} else {
+			this.listId = listId;
+		}
+		this.proxyConfig = proxyConfig;
+		this._accessToken = accessToken;
+		this._reconnectInterval = 10000;
+		this._reconnectMaxAttempts = Infinity;
+		this._reconnectCurrentAttempts = 0;
+		this._connectionClosed = false;
+		this._channelID = uuid();
+		this._pongReceivedTimestamp = dayjs();
+		this._converter = converter;
+	}
+
+	/**
+	 * Start websocket connection.
+	 */
+	public start() {
+		this._connectionClosed = false;
+		this._resetRetryParams();
+		this._startWebSocketConnection();
+	}
+
+	private baseUrlToHost(baseUrl: string): string {
+		return baseUrl.replace("https://", "");
+	}
+
+	/**
+	 * Reset connection and start new websocket connection.
+	 */
+	private _startWebSocketConnection() {
+		this._resetConnection();
+		this._setupParser();
+		this._client = this._connect();
+		this._bindSocket(this._client);
+	}
+
+	/**
+	 * Stop current connection.
+	 */
+	public stop() {
+		this._connectionClosed = true;
+		this._resetConnection();
+		this._resetRetryParams();
+	}
+
+	/**
+	 * Clean up current connection, and listeners.
+	 */
+	private _resetConnection() {
+		if (this._client) {
+			this._client.close(1000);
+			this._client.removeAllListeners();
+			this._client = null;
+		}
+
+		if (this.parser) {
+			this.parser.removeAllListeners();
+		}
+	}
+
+	/**
+	 * Resets the parameters used in reconnect.
+	 */
+	private _resetRetryParams() {
+		this._reconnectCurrentAttempts = 0;
+	}
+
+	/**
+	 * Connect to the endpoint.
+	 */
+	private _connect(): WS {
+		let options: WS.ClientOptions = {
+			headers: this.headers,
+		};
+		if (this.proxyConfig) {
+			options = Object.assign(options, {
+				agent: proxyAgent(this.proxyConfig),
+			});
+		}
+		const cli: WS = new WS(`${this.url}?i=${this._accessToken}`, options);
+		return cli;
+	}
+
+	/**
+	 * Connect specified channels in websocket.
+	 */
+	private _channel() {
+		if (!this._client) {
+			return;
+		}
+		switch (this.channel) {
+			case "conversation":
+				this._client.send(
+					JSON.stringify({
+						type: "connect",
+						body: {
+							channel: "main",
+							id: this._channelID,
+						},
+					}),
+				);
+				break;
+			case "user":
+				this._client.send(
+					JSON.stringify({
+						type: "connect",
+						body: {
+							channel: "main",
+							id: this._channelID,
+						},
+					}),
+				);
+				this._client.send(
+					JSON.stringify({
+						type: "connect",
+						body: {
+							channel: "homeTimeline",
+							id: this._channelID,
+						},
+					}),
+				);
+				break;
+			case "list":
+				this._client.send(
+					JSON.stringify({
+						type: "connect",
+						body: {
+							channel: "userList",
+							id: this._channelID,
+							params: {
+								listId: this.listId,
+							},
+						},
+					}),
+				);
+				break;
+			default:
+				this._client.send(
+					JSON.stringify({
+						type: "connect",
+						body: {
+							channel: this.channel,
+							id: this._channelID,
+						},
+					}),
+				);
+				break;
+		}
+	}
+
+	/**
+	 * Reconnects to the same endpoint.
+	 */
+
+	private _reconnect() {
+		setTimeout(() => {
+			// Skip reconnect when client is connecting.
+			// https://github.com/websockets/ws/blob/7.2.1/lib/websocket.js#L365
+			if (this._client && this._client.readyState === WS.CONNECTING) {
+				return;
+			}
+
+			if (this._reconnectCurrentAttempts < this._reconnectMaxAttempts) {
+				this._reconnectCurrentAttempts++;
+				this._clearBinding();
+				if (this._client) {
+					// In reconnect, we want to close the connection immediately,
+					// because recoonect is necessary when some problems occur.
+					this._client.terminate();
+				}
+				// Call connect methods
+				console.log("Reconnecting");
+				this._client = this._connect();
+				this._bindSocket(this._client);
+			}
+		}, this._reconnectInterval);
+	}
+
+	/**
+	 * Clear binding event for websocket client.
+	 */
+	private _clearBinding() {
+		if (this._client) {
+			this._client.removeAllListeners("close");
+			this._client.removeAllListeners("pong");
+			this._client.removeAllListeners("open");
+			this._client.removeAllListeners("message");
+			this._client.removeAllListeners("error");
+		}
+	}
+
+	/**
+	 * Bind event for web socket client.
+	 * @param client A WebSocket instance.
+	 */
+	private _bindSocket(client: WS) {
+		client.on("close", (code: number, _reason: Buffer) => {
+			if (code === 1000) {
+				this.emit("close", {});
+			} else {
+				console.log(`Closed connection with ${code}`);
+				if (!this._connectionClosed) {
+					this._reconnect();
+				}
+			}
+		});
+		client.on("pong", () => {
+			this._pongWaiting = false;
+			this.emit("pong", {});
+			this._pongReceivedTimestamp = dayjs();
+			// It is required to anonymous function since get this scope in checkAlive.
+			setTimeout(
+				() => this._checkAlive(this._pongReceivedTimestamp),
+				this._heartbeatInterval,
+			);
+		});
+		client.on("open", () => {
+			this.emit("connect", {});
+			this._channel();
+			// Call first ping event.
+			setTimeout(() => {
+				client.ping("");
+			}, 10000);
+		});
+		client.on("message", (data: WS.Data, isBinary: boolean) => {
+			this.parser.parse(data, isBinary, this._channelID);
+		});
+		client.on("error", (err: Error) => {
+			this.emit("error", err);
+		});
+	}
+
+	/**
+	 * Set up parser when receive message.
+	 */
+	private _setupParser() {
+		this.parser.on("update", (note: MisskeyAPI.Entity.Note) => {
+			this.emit(
+				"update",
+				this._converter.note(note, this.baseUrlToHost(this.url)),
+			);
+		});
+		this.parser.on(
+			"notification",
+			(notification: MisskeyAPI.Entity.Notification) => {
+				this.emit(
+					"notification",
+					this._converter.notification(
+						notification,
+						this.baseUrlToHost(this.url),
+					),
+				);
+			},
+		);
+		this.parser.on("conversation", (note: MisskeyAPI.Entity.Note) => {
+			this.emit(
+				"conversation",
+				this._converter.noteToConversation(note, this.baseUrlToHost(this.url)),
+			);
+		});
+		this.parser.on("error", (err: Error) => {
+			this.emit("parser-error", err);
+		});
+	}
+
+	/**
+	 * Call ping and wait to pong.
+	 */
+	private _checkAlive(timestamp: Dayjs) {
+		const now: Dayjs = dayjs();
+		// Block multiple calling, if multiple pong event occur.
+		// It the duration is less than interval, through ping.
+		if (
+			now.diff(timestamp) > this._heartbeatInterval - 1000 &&
+			!this._connectionClosed
+		) {
+			// Skip ping when client is connecting.
+			// https://github.com/websockets/ws/blob/7.2.1/lib/websocket.js#L289
+			if (this._client && this._client.readyState !== WS.CONNECTING) {
+				this._pongWaiting = true;
+				this._client.ping("");
+				setTimeout(() => {
+					if (this._pongWaiting) {
+						this._pongWaiting = false;
+						this._reconnect();
+					}
+				}, 10000);
+			}
+		}
+	}
+}
+
+/**
+ * Parser
+ * This class provides parser for websocket message.
+ */
+export class Parser extends EventEmitter {
+	/**
+	 * @param message Message body of websocket.
+	 * @param channelID Parse only messages which has same channelID.
+	 */
+	public parse(data: WS.Data, isBinary: boolean, channelID: string) {
+		const message = isBinary ? data : data.toString();
+		if (typeof message !== "string") {
+			this.emit("heartbeat", {});
+			return;
+		}
+
+		if (message === "") {
+			this.emit("heartbeat", {});
+			return;
+		}
+
+		let obj: {
+			type: string;
+			body: {
+				id: string;
+				type: string;
+				body: any;
+			};
+		};
+		let body: {
+			id: string;
+			type: string;
+			body: any;
+		};
+
+		try {
+			obj = JSON.parse(message);
+			if (obj.type !== "channel") {
+				return;
+			}
+			if (!obj.body) {
+				return;
+			}
+			body = obj.body;
+			if (body.id !== channelID) {
+				return;
+			}
+		} catch (err) {
+			this.emit(
+				"error",
+				new Error(
+					`Error parsing websocket reply: ${message}, error message: ${err}`,
+				),
+			);
+			return;
+		}
+
+		switch (body.type) {
+			case "note":
+				this.emit("update", body.body as MisskeyAPI.Entity.Note);
+				break;
+			case "notification":
+				this.emit("notification", body.body as MisskeyAPI.Entity.Notification);
+				break;
+			case "mention": {
+				const note = body.body as MisskeyAPI.Entity.Note;
+				if (note.visibility === "specified") {
+					this.emit("conversation", note);
+				}
+				break;
+			}
+			// When renote and followed event, the same notification will be received.
+			case "renote":
+			case "followed":
+			case "follow":
+			case "unfollow":
+			case "receiveFollowRequest":
+			case "meUpdated":
+			case "readAllNotifications":
+			case "readAllUnreadSpecifiedNotes":
+			case "readAllAntennas":
+			case "readAllUnreadMentions":
+			case "unreadNotification":
+				// Ignore these events
+				break;
+			default:
+				this.emit(
+					"error",
+					new Error(`Unknown event has received: ${JSON.stringify(body)}`),
+				);
+				break;
+		}
+	}
+}

packages/megalodon/src/notification.ts

@@ -0,0 +1,14 @@
+import Entity from "./entity";
+
+namespace NotificationType {
+	export const Follow: Entity.NotificationType = "follow";
+	export const Favourite: Entity.NotificationType = "favourite";
+	export const Reblog: Entity.NotificationType = "reblog";
+	export const Mention: Entity.NotificationType = "mention";
+	export const Reaction: Entity.NotificationType = "reaction";
+	export const FollowRequest: Entity.NotificationType = "follow_request";
+	export const Status: Entity.NotificationType = "status";
+	export const Poll: Entity.NotificationType = "poll";
+}
+
+export default NotificationType;

packages/megalodon/src/oauth.ts

@@ -0,0 +1,123 @@
+/**
+ * OAuth
+ * Response data when oauth request.
+ **/
+namespace OAuth {
+	export type AppDataFromServer = {
+		id: string;
+		name: string;
+		website: string | null;
+		redirect_uri: string;
+		client_id: string;
+		client_secret: string;
+	};
+
+	export type TokenDataFromServer = {
+		access_token: string;
+		token_type: string;
+		scope: string;
+		created_at: number;
+		expires_in: number | null;
+		refresh_token: string | null;
+	};
+
+	export class AppData {
+		public url: string | null;
+		public session_token: string | null;
+		constructor(
+			public id: string,
+			public name: string,
+			public website: string | null,
+			public redirect_uri: string,
+			public client_id: string,
+			public client_secret: string,
+		) {
+			this.url = null;
+			this.session_token = null;
+		}
+
+		/**
+		 * Serialize raw application data from server
+		 * @param raw from server
+		 */
+		static from(raw: AppDataFromServer) {
+			return new this(
+				raw.id,
+				raw.name,
+				raw.website,
+				raw.redirect_uri,
+				raw.client_id,
+				raw.client_secret,
+			);
+		}
+
+		get redirectUri() {
+			return this.redirect_uri;
+		}
+		get clientId() {
+			return this.client_id;
+		}
+		get clientSecret() {
+			return this.client_secret;
+		}
+	}
+
+	export class TokenData {
+		public _scope: string;
+		constructor(
+			public access_token: string,
+			public token_type: string,
+			scope: string,
+			public created_at: number,
+			public expires_in: number | null = null,
+			public refresh_token: string | null = null,
+		) {
+			this._scope = scope;
+		}
+
+		/**
+		 * Serialize raw token data from server
+		 * @param raw from server
+		 */
+		static from(raw: TokenDataFromServer) {
+			return new this(
+				raw.access_token,
+				raw.token_type,
+				raw.scope,
+				raw.created_at,
+				raw.expires_in,
+				raw.refresh_token,
+			);
+		}
+
+		/**
+		 * OAuth Aceess Token
+		 */
+		get accessToken() {
+			return this.access_token;
+		}
+		get tokenType() {
+			return this.token_type;
+		}
+		get scope() {
+			return this._scope;
+		}
+		/**
+		 * Application ID
+		 */
+		get createdAt() {
+			return this.created_at;
+		}
+		get expiresIn() {
+			return this.expires_in;
+		}
+		/**
+		 * OAuth Refresh Token
+		 */
+		get refreshToken() {
+			return this.refresh_token;
+		}
+	}
+}
+
+export default OAuth;

packages/megalodon/src/parser.ts

@@ -0,0 +1,94 @@
+import { EventEmitter } from "events";
+import Entity from "./entity";
+
+/**
+ * Parser
+ * Parse response data in streaming.
+ **/
+export class Parser extends EventEmitter {
+	private message: string;
+
+	constructor() {
+		super();
+		this.message = "";
+	}
+
+	public parse(chunk: string) {
+		// skip heartbeats
+		if (chunk === ":thump\n") {
+			this.emit("heartbeat", {});
+			return;
+		}
+
+		this.message += chunk;
+		chunk = this.message;
+
+		const size: number = chunk.length;
+		let start = 0;
+		let offset = 0;
+		let curr: string | undefined;
+		let next: string | undefined;
+
+		while (offset < size) {
+			curr = chunk[offset];
+			next = chunk[offset + 1];
+
+			if (curr === "\n" && next === "\n") {
+				const piece: string = chunk.slice(start, offset);
+
+				offset += 2;
+				start = offset;
+
+				if (!piece.length) continue; // empty object
+
+				const root: Array<string> = piece.split("\n");
+
+				// should never happen, as long as mastodon doesn't change API messages
+				if (root.length !== 2) continue;
+
+				// remove event and data markers
+				const event: string = root[0].substr(7);
+				const data: string = root[1].substr(6);
+
+				let jsonObj = {};
+				try {
+					jsonObj = JSON.parse(data);
+				} catch (err) {
+					// delete event does not have json object
+					if (event !== "delete") {
+						this.emit(
+							"error",
+							new Error(
+								`Error parsing API reply: '${piece}', error message: '${err}'`,
+							),
+						);
+						continue;
+					}
+				}
+				switch (event) {
+					case "update":
+						this.emit("update", jsonObj as Entity.Status);
+						break;
+					case "notification":
+						this.emit("notification", jsonObj as Entity.Notification);
+						break;
+					case "conversation":
+						this.emit("conversation", jsonObj as Entity.Conversation);
+						break;
+					case "delete":
+						// When delete, data is an ID of the deleted status
+						this.emit("delete", data);
+						break;
+					default:
+						this.emit(
+							"error",
+							new Error(`Unknown event has received: ${event}`),
+						);
+						continue;
+				}
+			}
+			offset++;
+		}
+		this.message = chunk.slice(start, size);
+	}
+}

packages/megalodon/src/proxy_config.ts

@@ -0,0 +1,92 @@
+import { HttpsProxyAgent, HttpsProxyAgentOptions } from "https-proxy-agent";
+import { SocksProxyAgent, SocksProxyAgentOptions } from "socks-proxy-agent";
+
+export type ProxyConfig = {
+	host: string;
+	port: number;
+	auth?: {
+		username: string;
+		password: string;
+	};
+	protocol:
+		| "http"
+		| "https"
+		| "socks4"
+		| "socks4a"
+		| "socks5"
+		| "socks5h"
+		| "socks";
+};
+
+class ProxyProtocolError extends Error {}
+
+const proxyAgent = (
+	proxyConfig: ProxyConfig,
+): HttpsProxyAgent | SocksProxyAgent => {
+	switch (proxyConfig.protocol) {
+		case "http": {
+			let options: HttpsProxyAgentOptions = {
+				host: proxyConfig.host,
+				port: proxyConfig.port,
+				secureProxy: false,
+			};
+			if (proxyConfig.auth) {
+				options = Object.assign(options, {
+					auth: `${proxyConfig.auth.username}:${proxyConfig.auth.password}`,
+				});
+			}
+			const httpsAgent = new HttpsProxyAgent(options);
+			return httpsAgent;
+		}
+		case "https": {
+			let options: HttpsProxyAgentOptions = {
+				host: proxyConfig.host,
+				port: proxyConfig.port,
+				secureProxy: true,
+			};
+			if (proxyConfig.auth) {
+				options = Object.assign(options, {
+					auth: `${proxyConfig.auth.username}:${proxyConfig.auth.password}`,
+				});
+			}
+			const httpsAgent = new HttpsProxyAgent(options);
+			return httpsAgent;
+		}
+		case "socks4":
+		case "socks4a": {
+			let options: SocksProxyAgentOptions = {
+				type: 4,
+				hostname: proxyConfig.host,
+				port: proxyConfig.port,
+			};
+			if (proxyConfig.auth) {
+				options = Object.assign(options, {
+					userId: proxyConfig.auth.username,
+					password: proxyConfig.auth.password,
+				});
+			}
+			const socksAgent = new SocksProxyAgent(options);
+			return socksAgent;
+		}
+		case "socks5":
+		case "socks5h":
+		case "socks": {
+			let options: SocksProxyAgentOptions = {
+				type: 5,
+				hostname: proxyConfig.host,
+				port: proxyConfig.port,
+			};
+			if (proxyConfig.auth) {
+				options = Object.assign(options, {
+					userId: proxyConfig.auth.username,
+					password: proxyConfig.auth.password,
+				});
+			}
+			const socksAgent = new SocksProxyAgent(options);
+			return socksAgent;
+		}
+		default:
+			throw new ProxyProtocolError("protocol is not accepted");
+	}
+};
+export default proxyAgent;

packages/megalodon/src/response.ts

@@ -0,0 +1,8 @@
+type Response<T = any> = {
+	data: T;
+	status: number;
+	statusText: string;
+	headers: any;
+};
+
+export default Response;