Merge pull request '[PR]: Overhaul mastodon client API support (megalodon)' (#10411) from e2net/calckey:mastodon-client-api-overhaul into develop

Reviewed-on: https://codeberg.org/calckey/calckey/pulls/10411

.gitignore

@@ -48,6 +48,9 @@ packages/backend/assets/sounds/None.mp3
 
 !packages/backend/src/db
 
+packages/megalodon/lib
+packages/megalodon/.idea
+
 # blender backups
 *.blend1
 *.blend2

package.json

@@ -44,6 +44,7 @@
 		"seedrandom": "^3.0.5"
 	},
 	"devDependencies": {
+		"@types/node": "18.11.18",
 		"@types/gulp": "4.0.10",
 		"@types/gulp-rename": "2.0.1",
 		"chalk": "4.1.2",

packages/backend/native-utils/src/mastodon_api.rs

@@ -13,7 +13,6 @@ pub enum IdConvertType {
 
 #[napi]
 pub fn convert_id(in_id: String, id_convert_type: IdConvertType) -> napi::Result<String> {
-    println!("converting id: {}", in_id);
     use IdConvertType::*;
     match id_convert_type {
         MastodonId => {

packages/backend/package.json

@@ -28,7 +28,7 @@
 		"@bull-board/api": "5.2.0",
 		"@bull-board/koa": "5.2.0",
 		"@bull-board/ui": "5.2.0",
-		"@calckey/megalodon": "5.2.0",
+		"megalodon": "workspace:*",
 		"@discordapp/twemoji": "14.1.2",
 		"@elastic/elasticsearch": "7.17.0",
 		"@koa/cors": "3.4.3",

packages/backend/src/server/api/mastodon/ApiMastodonCompatibleService.ts

@@ -1,5 +1,5 @@
 import Router from "@koa/router";
-import megalodon, { MegalodonInterface } from "@calckey/megalodon";
+import megalodon, { MegalodonInterface } from "megalodon";
 import { apiAuthMastodon } from "./endpoints/auth.js";
 import { apiAccountMastodon } from "./endpoints/account.js";
 import { apiStatusMastodon } from "./endpoints/status.js";
@@ -18,11 +18,7 @@ export function getClient(
 	const accessTokenArr = authorization?.split(" ") ?? [null];
 	const accessToken = accessTokenArr[accessTokenArr.length - 1];
 	const generator = (megalodon as any).default;
-	const client = generator(
-		"misskey",
-		BASE_URL,
-		accessToken,
-	) as MegalodonInterface;
+	const client = generator(BASE_URL, accessToken) as MegalodonInterface;
 	return client;
 }
 

packages/backend/src/server/api/mastodon/converters.ts

@@ -1,4 +1,4 @@
-import { Entity } from "@calckey/megalodon";
+import { Entity } from "megalodon";
 import { convertId, IdType } from "../index.js";
 
 function simpleConvert(data: any) {
@@ -21,6 +21,9 @@ export function convertFilter(filter: Entity.Filter) {
 export function convertList(list: Entity.List) {
 	return simpleConvert(list);
 }
+export function convertFeaturedTag(tag: Entity.FeaturedTag) {
+	return simpleConvert(tag);
+}
 
 export function convertNotification(notification: Entity.Notification) {
 	notification.account = convertAccount(notification.account);

packages/backend/src/server/api/mastodon/endpoints/account.ts

@@ -7,6 +7,7 @@ import { argsToBools, convertTimelinesArgsId, limitToInt } from "./timeline.js";
 import { convertId, IdType } from "../../index.js";
 import {
 	convertAccount,
+	convertFeaturedTag,
 	convertList,
 	convertRelationship,
 	convertStatus,
@@ -42,8 +43,8 @@ export function apiAccountMastodon(router: Router): void {
 			acct.url = `${BASE_URL}/@${acct.url}`;
 			acct.note = acct.note || "";
 			acct.avatar_static = acct.avatar;
-			acct.header = acct.header || "https://http.cat/404";
-			acct.header_static = acct.header || "https://http.cat/404";
+			acct.header = acct.header || "/static-assets/transparent.png";
+			acct.header_static = acct.header || "/static-assets/transparent.png";
 			acct.source = {
 				note: acct.note,
 				fields: acct.fields,
@@ -164,6 +165,25 @@ export function apiAccountMastodon(router: Router): void {
 			}
 		},
 	);
+	router.get<{ Params: { id: string } }>(
+		"/v1/accounts/:id/featured_tags",
+		async (ctx) => {
+			const BASE_URL = `${ctx.protocol}://${ctx.hostname}`;
+			const accessTokens = ctx.headers.authorization;
+			const client = getClient(BASE_URL, accessTokens);
+			try {
+				const data = await client.getAccountFeaturedTags(
+					convertId(ctx.params.id, IdType.CalckeyId),
+				);
+				ctx.body = data.data.map((tag) => convertFeaturedTag(tag));
+			} catch (e: any) {
+				console.error(e);
+				console.error(e.response.data);
+				ctx.status = 401;
+				ctx.body = e.response.data;
+			}
+		},
+	);
 	router.get<{ Params: { id: string } }>(
 		"/v1/accounts/:id/followers",
 		async (ctx) => {
@@ -342,6 +362,34 @@ export function apiAccountMastodon(router: Router): void {
 			}
 		},
 	);
+	router.get("/v1/featured_tags", async (ctx) => {
+		const BASE_URL = `${ctx.protocol}://${ctx.hostname}`;
+		const accessTokens = ctx.headers.authorization;
+		const client = getClient(BASE_URL, accessTokens);
+		try {
+			const data = await client.getFeaturedTags();
+			ctx.body = data.data.map((tag) => convertFeaturedTag(tag));
+		} catch (e: any) {
+			console.error(e);
+			console.error(e.response.data);
+			ctx.status = 401;
+			ctx.body = e.response.data;
+		}
+	});
+	router.get("/v1/followed_tags", async (ctx) => {
+		const BASE_URL = `${ctx.protocol}://${ctx.hostname}`;
+		const accessTokens = ctx.headers.authorization;
+		const client = getClient(BASE_URL, accessTokens);
+		try {
+			const data = await client.getFollowedTags();
+			ctx.body = data.data;
+		} catch (e: any) {
+			console.error(e);
+			console.error(e.response.data);
+			ctx.status = 401;
+			ctx.body = e.response.data;
+		}
+	});
 	router.get("/v1/bookmarks", async (ctx) => {
 		const BASE_URL = `${ctx.protocol}://${ctx.hostname}`;
 		const accessTokens = ctx.headers.authorization;

packages/backend/src/server/api/mastodon/endpoints/auth.ts

@@ -1,4 +1,4 @@
-import megalodon, { MegalodonInterface } from "@calckey/megalodon";
+import megalodon, { MegalodonInterface } from "megalodon";
 import Router from "@koa/router";
 import { koaBody } from "koa-body";
 import { getClient } from "../ApiMastodonCompatibleService.js";

packages/backend/src/server/api/mastodon/endpoints/filter.ts

@@ -1,4 +1,4 @@
-import megalodon, { MegalodonInterface } from "@calckey/megalodon";
+import megalodon, { MegalodonInterface } from "megalodon";
 import Router from "@koa/router";
 import { getClient } from "../ApiMastodonCompatibleService.js";
 import { IdType, convertId } from "../../index.js";

packages/backend/src/server/api/mastodon/endpoints/meta.ts

@@ -1,4 +1,4 @@
-import { Entity } from "@calckey/megalodon";
+import { Entity } from "megalodon";
 import { fetchMeta } from "@/misc/fetch-meta.js";
 import { Users, Notes } from "@/models/index.js";
 import { IsNull, MoreThan } from "typeorm";
@@ -24,7 +24,7 @@ export async function getInstance(response: Entity.Instance) {
 			status_count: await totalStatuses,
 			domain_count: response.stats.domain_count,
 		},
-		thumbnail: response.thumbnail || "https://http.cat/404",
+		thumbnail: response.thumbnail || "/static-assets/transparent.png",
 		languages: meta.langs,
 		registrations: !meta.disableRegistration || response.registrations,
 		approval_required: !response.registrations,
@@ -96,8 +96,8 @@ export async function getInstance(response: Entity.Instance) {
 			url: `${response.uri}/`,
 			avatar: `${response.uri}/static-assets/badges/info.png`,
 			avatar_static: `${response.uri}/static-assets/badges/info.png`,
-			header: "https://http.cat/404",
-			header_static: "https://http.cat/404",
+			header: "/static-assets/transparent.png",
+			header_static: "/static-assets/transparent.png",
 			followers_count: -1,
 			following_count: 0,
 			statuses_count: 0,

packages/backend/src/server/api/mastodon/endpoints/notifications.ts

@@ -1,9 +1,9 @@
-import megalodon, { MegalodonInterface } from "@calckey/megalodon";
+import megalodon, { MegalodonInterface } from "megalodon";
 import Router from "@koa/router";
 import { koaBody } from "koa-body";
 import { convertId, IdType } from "../../index.js";
 import { getClient } from "../ApiMastodonCompatibleService.js";
-import { convertTimelinesArgsId, toTextWithReaction } from "./timeline.js";
+import { convertTimelinesArgsId } from "./timeline.js";
 import { convertNotification } from "../converters.js";
 function toLimitToInt(q: any) {
 	if (q.limit) if (typeof q.limit === "string") q.limit = parseInt(q.limit, 10);
@@ -25,10 +25,6 @@ export function apiNotificationsMastodon(router: Router): void {
 				n = convertNotification(n);
 				if (n.type !== "follow" && n.type !== "follow_request") {
 					if (n.type === "reaction") n.type = "favourite";
-					n.status = toTextWithReaction(
-						n.status ? [n.status] : [],
-						ctx.hostname,
-					)[0];
 					return n;
 				} else {
 					return n;
@@ -52,11 +48,13 @@ export function apiNotificationsMastodon(router: Router): void {
 				convertId(ctx.params.id, IdType.CalckeyId),
 			);
 			const data = convertNotification(dataRaw.data);
-			if (data.type !== "follow" && data.type !== "follow_request") {
-				if (data.type === "reaction") data.type = "favourite";
-				ctx.body = toTextWithReaction([data as any], ctx.request.hostname)[0];
-			} else {
 			ctx.body = data;
+			if (
+				data.type !== "follow" &&
+				data.type !== "follow_request" &&
+				data.type === "reaction"
+			) {
+				data.type = "favourite";
 			}
 		} catch (e: any) {
 			console.error(e);

packages/backend/src/server/api/mastodon/endpoints/search.ts

@@ -1,8 +1,8 @@
-import megalodon, { MegalodonInterface } from "@calckey/megalodon";
+import megalodon, { MegalodonInterface } from "megalodon";
 import Router from "@koa/router";
 import { getClient } from "../ApiMastodonCompatibleService.js";
 import axios from "axios";
-import { Converter } from "@calckey/megalodon";
+import { Converter } from "megalodon";
 import { convertTimelinesArgsId, limitToInt } from "./timeline.js";
 import { convertAccount, convertStatus } from "../converters.js";
 
@@ -103,7 +103,7 @@ async function getHighlight(
 			i: accessToken,
 		});
 		const data: MisskeyEntity.Note[] = api.data;
-		return data.map((note) => Converter.note(note, domain));
+		return data.map((note) => new Converter(BASE_URL).note(note, domain));
 	} catch (e: any) {
 		console.log(e);
 		console.log(e.response.data);
@@ -131,7 +131,7 @@ async function getFeaturedUser(
 		return data.map((u) => {
 			return {
 				source: "past_interactions",
-				account: Converter.userDetail(u, host),
+				account: new Converter(BASE_URL).userDetail(u, host),
 			};
 		});
 	} catch (e: any) {

packages/backend/src/server/api/mastodon/endpoints/status.ts

@@ -59,6 +59,11 @@ export function apiStatusMastodon(router: Router): void {
 			}
 			if (!body.media_ids) body.media_ids = undefined;
 			if (body.media_ids && !body.media_ids.length) body.media_ids = undefined;
+			if (body.media_ids) {
+				body.media_ids = (body.media_ids as string[]).map((p) =>
+					convertId(p, IdType.CalckeyId),
+				);
+			}
 			const { sensitive } = body;
 			body.sensitive =
 				typeof sensitive === "string" ? sensitive === "true" : sensitive;
@@ -153,6 +158,24 @@ export function apiStatusMastodon(router: Router): void {
 			}
 		},
 	);
+	router.get<{ Params: { id: string } }>(
+		"/v1/statuses/:id/history",
+		async (ctx) => {
+			const BASE_URL = `${ctx.protocol}://${ctx.hostname}`;
+			const accessTokens = ctx.headers.authorization;
+			const client = getClient(BASE_URL, accessTokens);
+			try {
+				const data = await client.getStatusHistory(
+					convertId(ctx.params.id, IdType.CalckeyId),
+				);
+				ctx.body = data.data.map((account) => convertAccount(account));
+			} catch (e: any) {
+				console.error(e);
+				ctx.status = 401;
+				ctx.body = e.response.data;
+			}
+		},
+	);
 	router.get<{ Params: { id: string } }>(
 		"/v1/statuses/:id/reblogged_by",
 		async (ctx) => {
@@ -431,8 +454,8 @@ export function statusModel(
 	const now = new Date().toISOString();
 	return {
 		id: "9atm5frjhb",
-		uri: "https://http.cat/404", // ""
-		url: "https://http.cat/404", // "",
+		uri: "/static-assets/transparent.png", // ""
+		url: "/static-assets/transparent.png", // "",
 		account: {
 			id: "9arzuvv0sw",
 			username: "Reactions",
@@ -444,11 +467,11 @@ export function statusModel(
 			following_count: 0,
 			statuses_count: 0,
 			note: "",
-			url: "https://http.cat/404",
+			url: "/static-assets/transparent.png",
 			avatar: "/static-assets/badges/info.png",
 			avatar_static: "/static-assets/badges/info.png",
-			header: "https://http.cat/404", // ""
-			header_static: "https://http.cat/404", // ""
+			header: "/static-assets/transparent.png", // ""
+			header_static: "/static-assets/transparent.png", // ""
 			emojis: [],
 			fields: [],
 			moved: null,

packages/backend/src/server/api/mastodon/endpoints/timeline.ts

@@ -1,8 +1,5 @@
 import Router from "@koa/router";
-import megalodon, { Entity, MegalodonInterface } from "@calckey/megalodon";
 import { getClient } from "../ApiMastodonCompatibleService.js";
-import { statusModel } from "./status.js";
-import Autolinker from "autolinker";
 import { ParsedUrlQuery } from "querystring";
 import { convertAccount, convertList, convertStatus } from "../converters.js";
 import { convertId, IdType } from "../../index.js";
@@ -41,66 +38,6 @@ export function convertTimelinesArgsId(q: ParsedUrlQuery) {
 	return q;
 }
 
-export function toTextWithReaction(status: Entity.Status[], host: string) {
-	return status.map((t) => {
-		if (!t) return statusModel(null, null, [], "no content");
-		t.quote = null as any;
-		if (!t.emoji_reactions) return t;
-		if (t.reblog) t.reblog = toTextWithReaction([t.reblog], host)[0];
-		const reactions = t.emoji_reactions.map((r) => {
-			const emojiNotation = r.url ? `:${r.name.replace("@.", "")}:` : r.name;
-			return `${emojiNotation} (${r.count}${r.me ? `* ` : ""})`;
-		});
-		const reaction = t.emoji_reactions as Entity.Reaction[];
-		const emoji = t.emojis || [];
-		for (const r of reaction) {
-			if (!r.url) continue;
-			emoji.push({
-				shortcode: r.name,
-				url: r.url,
-				static_url: r.url,
-				visible_in_picker: true,
-				category: "",
-			});
-		}
-		const isMe = reaction.findIndex((r) => r.me) > -1;
-		const total = reaction.reduce((sum, reaction) => sum + reaction.count, 0);
-		t.favourited = isMe;
-		t.favourites_count = total;
-		t.emojis = emoji;
-		t.content = `<p>${autoLinker(t.content, host)}</p><p>${reactions.join(
-			", ",
-		)}</p>`;
-		return t;
-	});
-}
-export function autoLinker(input: string, host: string) {
-	return Autolinker.link(input, {
-		hashtag: "twitter",
-		mention: "twitter",
-		email: false,
-		stripPrefix: false,
-		replaceFn: function (match) {
-			switch (match.type) {
-				case "url":
-					return true;
-				case "mention":
-					console.log("Mention: ", match.getMention());
-					console.log("Mention Service Name: ", match.getServiceName());
-					return `<a href="https://${host}/@${encodeURIComponent(
-						match.getMention(),
-					)}" target="_blank">@${match.getMention()}</a>`;
-				case "hashtag":
-					console.log("Hashtag: ", match.getHashtag());
-					return `<a href="https://${host}/tags/${encodeURIComponent(
-						match.getHashtag(),
-					)}" target="_blank">#${match.getHashtag()}</a>`;
-			}
-			return false;
-		},
-	});
-}
-
 export function apiTimelineMastodon(router: Router): void {
 	router.get("/v1/timelines/public", async (ctx, reply) => {
 		const BASE_URL = `${ctx.protocol}://${ctx.hostname}`;
@@ -115,8 +52,7 @@ export function apiTimelineMastodon(router: Router): void {
 				: await client.getPublicTimeline(
 						convertTimelinesArgsId(argsToBools(limitToInt(query))),
 				  );
-			let resp = data.data.map((status) => convertStatus(status));
-			ctx.body = toTextWithReaction(resp, ctx.hostname);
+			ctx.body = data.data.map((status) => convertStatus(status));
 		} catch (e: any) {
 			console.error(e);
 			console.error(e.response.data);
@@ -135,8 +71,7 @@ export function apiTimelineMastodon(router: Router): void {
 					ctx.params.hashtag,
 					convertTimelinesArgsId(argsToBools(limitToInt(ctx.query))),
 				);
-				let resp = data.data.map((status) => convertStatus(status));
-				ctx.body = toTextWithReaction(resp, ctx.hostname);
+				ctx.body = data.data.map((status) => convertStatus(status));
 			} catch (e: any) {
 				console.error(e);
 				console.error(e.response.data);
@@ -153,8 +88,7 @@ export function apiTimelineMastodon(router: Router): void {
 			const data = await client.getHomeTimeline(
 				convertTimelinesArgsId(limitToInt(ctx.query)),
 			);
-			let resp = data.data.map((status) => convertStatus(status));
-			ctx.body = toTextWithReaction(resp, ctx.hostname);
+			ctx.body = data.data.map((status) => convertStatus(status));
 		} catch (e: any) {
 			console.error(e);
 			console.error(e.response.data);
@@ -173,8 +107,7 @@ export function apiTimelineMastodon(router: Router): void {
 					convertId(ctx.params.listId, IdType.CalckeyId),
 					convertTimelinesArgsId(limitToInt(ctx.query)),
 				);
-				let resp = data.data.map((status) => convertStatus(status));
-				ctx.body = toTextWithReaction(resp, ctx.hostname);
+				ctx.body = data.data.map((status) => convertStatus(status));
 			} catch (e: any) {
 				console.error(e);
 				console.error(e.response.data);

packages/backend/src/server/api/stream/index.ts

@@ -25,9 +25,8 @@ import { readNotification } from "../common/read-notification.js";
 import channels from "./channels/index.js";
 import type Channel from "./channel.js";
 import type { StreamEventEmitter, StreamMessages } from "./types.js";
-import { Converter } from "@calckey/megalodon";
+import { Converter } from "megalodon";
 import { getClient } from "../mastodon/ApiMastodonCompatibleService.js";
-import { toTextWithReaction } from "../mastodon/endpoints/timeline.js";
 
 /**
  * Main stream connection
@@ -400,12 +399,7 @@ export default class Connection {
 					JSON.stringify({
 						stream: [payload.id],
 						event: "update",
-						payload: JSON.stringify(
-							toTextWithReaction(
-								[Converter.note(payload.body, this.host)],
-								this.host,
-							)[0],
-						),
+						payload: JSON.stringify(Converter.note(payload.body, this.host)),
 					}),
 				);
 				this.onSubscribeNote({
@@ -415,7 +409,7 @@ export default class Connection {
 				// reaction
 				const client = getClient(this.host, this.accessToken);
 				client.getStatus(payload.id).then((data) => {
-					const newPost = toTextWithReaction([data.data], this.host);
+					const newPost = [data.data];
 					const targetPost = newPost[0];
 					for (const stream of this.currentSubscribe) {
 						this.wsConnection.send(
@@ -442,10 +436,6 @@ export default class Connection {
 				if (payload.id === "user") {
 					const body = Converter.notification(payload.body, this.host);
 					if (body.type === "reaction") body.type = "favourite";
-					body.status = toTextWithReaction(
-						body.status ? [body.status] : [],
-						"",
-					)[0];
 					this.wsConnection.send(
 						JSON.stringify({
 							stream: ["user"],

packages/backend/src/server/index.ts

@@ -22,7 +22,7 @@ import { createTemp } from "@/misc/create-temp.js";
 import { publishMainStream } from "@/services/stream.js";
 import * as Acct from "@/misc/acct.js";
 import { envOption } from "@/env.js";
-import megalodon, { MegalodonInterface } from "@calckey/megalodon";
+import megalodon, { MegalodonInterface } from "megalodon";
 import activityPub from "./activitypub.js";
 import nodeinfo from "./nodeinfo.js";
 import wellKnown from "./well-known.js";
@@ -166,7 +166,7 @@ mastoRouter.post("/oauth/token", async (ctx) => {
 	let client_id: any = body.client_id;
 	const BASE_URL = `${ctx.request.protocol}://${ctx.request.hostname}`;
 	const generator = (megalodon as any).default;
-	const client = generator("misskey", BASE_URL, null) as MegalodonInterface;
+	const client = generator(BASE_URL, null) as MegalodonInterface;
 	let m = null;
 	let token = null;
 	if (body.code) {

packages/megalodon/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "megalodon",
+  "private": true,
+  "main": "./lib/src/index.js",
+  "typings": "./lib/src/index.d.ts",
+  "scripts": {
+    "build": "tsc -p ./",
+    "lint": "eslint --ext .js,.ts src",
+    "doc": "typedoc --out ../docs ./src",
+    "test": "NODE_ENV=test jest -u --maxWorkers=3"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "ts",
+      "js"
+    ],
+    "moduleNameMapper": {
+      "^@/(.+)": "<rootDir>/src/$1",
+      "^~/(.+)": "<rootDir>/$1"
+    },
+    "testMatch": [
+      "**/test/**/*.spec.ts"
+    ],
+    "preset": "ts-jest/presets/default",
+    "transform": {
+      "^.+\\.(ts|tsx)$": "ts-jest"
+    },
+    "globals": {
+      "ts-jest": {
+        "tsconfig": "tsconfig.json"
+      }
+    },
+    "testEnvironment": "node"
+  },
+  "dependencies": {
+    "@types/oauth": "^0.9.0",
+    "@types/ws": "^8.5.4",
+    "axios": "1.2.2",
+    "dayjs": "^1.11.7",
+    "form-data": "^4.0.0",
+    "https-proxy-agent": "^5.0.1",
+    "oauth": "^0.10.0",
+    "object-assign-deep": "^0.4.0",
+    "parse-link-header": "^2.0.0",
+    "socks-proxy-agent": "^7.0.0",
+    "typescript": "4.9.4",
+    "uuid": "^9.0.0",
+    "ws": "8.12.0",
+    "async-lock": "1.4.0"
+  },
+  "devDependencies": {
+    "@types/core-js": "^2.5.0",
+    "@types/form-data": "^2.5.0",
+    "@types/jest": "^29.4.0",
+    "@types/object-assign-deep": "^0.4.0",
+    "@types/parse-link-header": "^2.0.0",
+    "@types/uuid": "^9.0.0",
+		"@types/node": "18.11.18",
+    "@typescript-eslint/eslint-plugin": "^5.49.0",
+    "@typescript-eslint/parser": "^5.49.0",
+    "@types/async-lock": "1.4.0",
+    "eslint": "^8.32.0",
+    "eslint-config-prettier": "^8.6.0",
+    "eslint-config-standard": "^16.0.3",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-node": "^11.0.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "eslint-plugin-promise": "^6.1.1",
+    "eslint-plugin-standard": "^5.0.0",
+    "jest": "^29.4.0",
+    "jest-worker": "^29.4.0",
+    "lodash": "^4.17.14",
+    "prettier": "^2.8.3",
+    "ts-jest": "^29.0.5",
+    "typedoc": "^0.23.24"
+  },
+  "directories": {
+    "lib": "lib",
+    "test": "test"
+  }
+}

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
+    emoji?: string
+    type: NotificationType
+  }
+
+  export type NotificationType = string
+}

packages/megalodon/src/entities/poll.ts

@@ -0,0 +1,13 @@
+/// <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
+  }
+}

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,11 @@
+/// <reference path="account.ts" />
+
+namespace Entity {
+  export type Reaction = {
+    count: number
+    me: boolean
+    name: string
+    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
+    emoji_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,28 @@
+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,638 @@
+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 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, // FIXME
+        header_static: this.plcUrl, // FIXME
+        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,
+        locked: u.isLocked,
+        created_at: u.createdAt,
+        followers_count: u.followersCount,
+        following_count: u.followingCount,
+        statuses_count: u.notesCount,
+        note: u.description,
+        url: acctUrl,
+        avatar: u.avatarUrl,
+        avatar_static: u.avatarUrl,
+        header: u.bannerUrl ?? this.plcUrl,
+        header_static: u.bannerUrl ?? this.plcUrl,
+        emojis: 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, g: MisskeyAPI.Entity.GetAll): MegalodonEntity.Preferences => {
+      return {
+        "reading:expand:media": "default",
+        "reading:expand:spoilers": false,
+        "posting:default:language": u.lang,
+        "posting:default:sensitive": u.alwaysMarkNsfw,
+        "posting:default:visibility": this.visibility(g.defaultNoteVisibility)
+      }
+    }
+
+    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): MegalodonEntity.Poll => {
+      const now = dayjs()
+      const expire = dayjs(p.expiresAt)
+      const count = p.choices.reduce((sum, choice) => sum + choice.votes, 0)
+      return {
+        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)
+      }
+    }
+
+    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,
+        emojis: n.emojis.map(e => this.emoji(e)),
+        replies_count: n.repliesCount,
+        reblogs_count: n.renoteCount,
+        favourites_count: this.getTotalReactions(n.reactions), // FIXME: instead get # of default reaction emoji 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) : null,
+        application: null,
+        language: null,
+        pinned: null,
+        emoji_reactions: this.mapReactions(n.reactions, n.myReaction),
+        bookmarked: false,
+        quote: n.renote && n.text ? this.note(n.renote, host) : null
+      }
+    }
+
+    mapReactions = (r: { [key: string]: number }, myReaction?: string): Array<MegalodonEntity.Reaction> => {
+      return Object.keys(r).map(key => {
+        if (myReaction && key === myReaction) {
+          return {
+            count: r[key],
+            me: true,
+            name: key
+          }
+        }
+        return {
+          count: r[key],
+          me: false,
+          name: key
+        }
+      })
+    }
+
+    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.EmojiReaction:
+          return MisskeyNotificationType.Reaction
+        case NotificationType.Reblog:
+          return MisskeyNotificationType.Renote
+        case NotificationType.PollVote:
+          return MisskeyNotificationType.PollVote
+        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.EmojiReaction
+        case MisskeyNotificationType.PollVote:
+          return NotificationType.PollVote
+        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 (n.reaction) {
+        notification = Object.assign(notification, {
+          emoji: n.reaction
+        })
+      }
+      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,6 @@
+namespace MisskeyEntity {
+  export type Field = {
+    name: string
+    value: 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: 300
+    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/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,16 @@
+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 PollVote: MisskeyEntity.NotificationType = 'pollVote'
+  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,414 @@
+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: number = 60000
+  private _pongWaiting: boolean = 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,15 @@
+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 EmojiReaction: Entity.NotificationType = 'emoji_reaction'
+  export const FollowRequest: Entity.NotificationType = 'follow_request'
+  export const Status: Entity.NotificationType = 'status'
+  export const PollVote: Entity.NotificationType = 'poll_vote'
+  export const PollExpired: Entity.NotificationType = 'poll_expired'
+}
+
+export default NotificationType

packages/megalodon/src/oauth.ts

@@ -0,0 +1,109 @@
+/**
+ * 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,86 @@
+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: number = 0
+    let offset: number = 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,83 @@
+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