Merge branch 'master' of github.com:syuilo/misskey

136 files changed, 9974 insertions, 0 deletions

diff --git a/src/server/api/api-handler.ts b/src/server/api/api-handler.ts
new file mode 100644
index 0000000000..e716dcdc01
--- /dev/null
+++ b/src/server/api/api-handler.ts
@@ -0,0 +1,47 @@
+import * as Koa from 'koa';
+
+import { Endpoint } from './endpoints';
+import authenticate from './authenticate';
+import call from './call';
+import { IUser } from '../../models/user';
+import { IApp } from '../../models/app';
+
+export default async (endpoint: Endpoint, ctx: Koa.Context) => {
+	const body = ctx.is('multipart/form-data') ? (ctx.req as any).body : ctx.request.body;
+
+	const reply = (x?: any, y?: any) => {
+		if (x === undefined) {
+			ctx.status = 204;
+		} else if (typeof x === 'number') {
+			ctx.status = x;
+			ctx.body = {
+				error: x === 500 ? 'INTERNAL_ERROR' : y
+			};
+		} else {
+			ctx.body = x;
+		}
+	};
+
+	let user: IUser;
+	let app: IApp;
+
+	// Authentication
+	try {
+		[user, app] = await authenticate(body['i']);
+	} catch (e) {
+		reply(403, 'AUTHENTICATION_FAILED');
+		return;
+	}
+
+	let res;
+
+	// API invoking
+	try {
+		res = await call(endpoint, user, app, body, (ctx.req as any).file);
+	} catch (e) {
+		reply(400, e);
+		return;
+	}
+
+	reply(res);
+};
diff --git a/src/server/api/authenticate.ts b/src/server/api/authenticate.ts
new file mode 100644
index 0000000000..836fb7cfe8
--- /dev/null
+++ b/src/server/api/authenticate.ts
@@ -0,0 +1,39 @@
+import App, { IApp } from '../../models/app';
+import { default as User, IUser } from '../../models/user';
+import AccessToken from '../../models/access-token';
+import isNativeToken from './common/is-native-token';
+
+export default (token: string) => new Promise<[IUser, IApp]>(async (resolve, reject) => {
+	if (token == null) {
+		resolve([null, null]);
+		return;
+	}
+
+	if (isNativeToken(token)) {
+		// Fetch user
+		const user: IUser = await User
+			.findOne({ token });
+
+		if (user === null) {
+			return reject('user not found');
+		}
+
+		resolve([user, null]);
+	} else {
+		const accessToken = await AccessToken.findOne({
+			hash: token.toLowerCase()
+		});
+
+		if (accessToken === null) {
+			return reject('invalid signature');
+		}
+
+		const app = await App
+			.findOne({ _id: accessToken.appId });
+
+		const user = await User
+			.findOne({ _id: accessToken.userId });
+
+		resolve([user, app]);
+	}
+});
diff --git a/src/server/api/bot/core.ts b/src/server/api/bot/core.ts
new file mode 100644
index 0000000000..d41af48057
--- /dev/null
+++ b/src/server/api/bot/core.ts
@@ -0,0 +1,439 @@
+import * as EventEmitter from 'events';
+import * as bcrypt from 'bcryptjs';
+
+import User, { IUser, init as initUser, ILocalUser } from '../../../models/user';
+
+import getNoteSummary from '../../../renderers/get-note-summary';
+import getUserName from '../../../renderers/get-user-name';
+import getUserSummary from '../../../renderers/get-user-summary';
+import parseAcct from '../../../acct/parse';
+import getNotificationSummary from '../../../renderers/get-notification-summary';
+
+const hmm = [
+	'？',
+	'ふぅ～む...？',
+	'ちょっと何言ってるかわからないです',
+	'「ヘルプ」と言うと利用可能な操作が確認できますよ'
+];
+
+/**
+ * Botの頭脳
+ */
+export default class BotCore extends EventEmitter {
+	public user: IUser = null;
+
+	private context: Context = null;
+
+	constructor(user?: IUser) {
+		super();
+
+		this.user = user;
+	}
+
+	public clearContext() {
+		this.setContext(null);
+	}
+
+	public setContext(context: Context) {
+		this.context = context;
+		this.emit('updated');
+
+		if (context) {
+			context.on('updated', () => {
+				this.emit('updated');
+			});
+		}
+	}
+
+	public export() {
+		return {
+			user: this.user,
+			context: this.context ? this.context.export() : null
+		};
+	}
+
+	protected _import(data) {
+		this.user = data.user ? initUser(data.user) : null;
+		this.setContext(data.context ? Context.import(this, data.context) : null);
+	}
+
+	public static import(data) {
+		const bot = new BotCore();
+		bot._import(data);
+		return bot;
+	}
+
+	public async q(query: string): Promise<string> {
+		if (this.context != null) {
+			return await this.context.q(query);
+		}
+
+		if (/^@[a-zA-Z0-9_]+$/.test(query)) {
+			return await this.showUserCommand(query);
+		}
+
+		switch (query) {
+			case 'ping':
+				return 'PONG';
+
+			case 'help':
+			case 'ヘルプ':
+				return '利用可能なコマンド一覧です:\n' +
+					'help: これです\n' +
+					'me: アカウント情報を見ます\n' +
+					'login, signin: サインインします\n' +
+					'logout, signout: サインアウトします\n' +
+					'note: 投稿します\n' +
+					'tl: タイムラインを見ます\n' +
+					'no: 通知を見ます\n' +
+					'@<ユーザー名>: ユーザーを表示します\n' +
+					'\n' +
+					'タイムラインや通知を見た後、「次」というとさらに遡ることができます。';
+
+			case 'me':
+				return this.user ? `${getUserName(this.user)}としてサインインしています。\n\n${getUserSummary(this.user)}` : 'サインインしていません';
+
+			case 'login':
+			case 'signin':
+			case 'ログイン':
+			case 'サインイン':
+				if (this.user != null) return '既にサインインしていますよ！';
+				this.setContext(new SigninContext(this));
+				return await this.context.greet();
+
+			case 'logout':
+			case 'signout':
+			case 'ログアウト':
+			case 'サインアウト':
+				if (this.user == null) return '今はサインインしてないですよ！';
+				this.signout();
+				return 'ご利用ありがとうございました <3';
+
+			case 'note':
+			case '投稿':
+				if (this.user == null) return 'まずサインインしてください。';
+				this.setContext(new NoteContext(this));
+				return await this.context.greet();
+
+			case 'tl':
+			case 'タイムライン':
+				if (this.user == null) return 'まずサインインしてください。';
+				this.setContext(new TlContext(this));
+				return await this.context.greet();
+
+			case 'no':
+			case 'notifications':
+			case '通知':
+				if (this.user == null) return 'まずサインインしてください。';
+				this.setContext(new NotificationsContext(this));
+				return await this.context.greet();
+
+			case 'guessing-game':
+			case '数当てゲーム':
+				this.setContext(new GuessingGameContext(this));
+				return await this.context.greet();
+
+			default:
+				return hmm[Math.floor(Math.random() * hmm.length)];
+		}
+	}
+
+	public signin(user: IUser) {
+		this.user = user;
+		this.emit('signin', user);
+		this.emit('updated');
+	}
+
+	public signout() {
+		const user = this.user;
+		this.user = null;
+		this.emit('signout', user);
+		this.emit('updated');
+	}
+
+	public async refreshUser() {
+		this.user = await User.findOne({
+			_id: this.user._id
+		}, {
+			fields: {
+				data: false
+			}
+		});
+
+		this.emit('updated');
+	}
+
+	public async showUserCommand(q: string): Promise<string> {
+		try {
+			const user = await require('../endpoints/users/show')(parseAcct(q.substr(1)), this.user);
+
+			const text = getUserSummary(user);
+
+			return text;
+		} catch (e) {
+			return `問題が発生したようです...: ${e}`;
+		}
+	}
+}
+
+abstract class Context extends EventEmitter {
+	protected bot: BotCore;
+
+	public abstract async greet(): Promise<string>;
+	public abstract async q(query: string): Promise<string>;
+	public abstract export(): any;
+
+	constructor(bot: BotCore) {
+		super();
+		this.bot = bot;
+	}
+
+	public static import(bot: BotCore, data: any) {
+		if (data.type == 'guessing-game') return GuessingGameContext.import(bot, data.content);
+		if (data.type == 'note') return NoteContext.import(bot, data.content);
+		if (data.type == 'tl') return TlContext.import(bot, data.content);
+		if (data.type == 'notifications') return NotificationsContext.import(bot, data.content);
+		if (data.type == 'signin') return SigninContext.import(bot, data.content);
+		return null;
+	}
+}
+
+class SigninContext extends Context {
+	private temporaryUser: ILocalUser = null;
+
+	public async greet(): Promise<string> {
+		return 'まずユーザー名を教えてください:';
+	}
+
+	public async q(query: string): Promise<string> {
+		if (this.temporaryUser == null) {
+			// Fetch user
+			const user = await User.findOne({
+				usernameLower: query.toLowerCase(),
+				host: null
+			}, {
+				fields: {
+					data: false
+				}
+			}) as ILocalUser;
+
+			if (user === null) {
+				return `${query}というユーザーは存在しませんでした... もう一度教えてください:`;
+			} else {
+				this.temporaryUser = user;
+				this.emit('updated');
+				return `パスワードを教えてください:`;
+			}
+		} else {
+			// Compare password
+			const same = await bcrypt.compare(query, this.temporaryUser.password);
+
+			if (same) {
+				this.bot.signin(this.temporaryUser);
+				this.bot.clearContext();
+				return `${getUserName(this.temporaryUser)}さん、おかえりなさい！`;
+			} else {
+				return `パスワードが違います... もう一度教えてください:`;
+			}
+		}
+	}
+
+	public export() {
+		return {
+			type: 'signin',
+			content: {
+				temporaryUser: this.temporaryUser
+			}
+		};
+	}
+
+	public static import(bot: BotCore, data: any) {
+		const context = new SigninContext(bot);
+		context.temporaryUser = data.temporaryUser;
+		return context;
+	}
+}
+
+class NoteContext extends Context {
+	public async greet(): Promise<string> {
+		return '内容:';
+	}
+
+	public async q(query: string): Promise<string> {
+		await require('../endpoints/notes/create')({
+			text: query
+		}, this.bot.user);
+		this.bot.clearContext();
+		return '投稿しましたよ！';
+	}
+
+	public export() {
+		return {
+			type: 'note'
+		};
+	}
+
+	public static import(bot: BotCore, data: any) {
+		const context = new NoteContext(bot);
+		return context;
+	}
+}
+
+class TlContext extends Context {
+	private next: string = null;
+
+	public async greet(): Promise<string> {
+		return await this.getTl();
+	}
+
+	public async q(query: string): Promise<string> {
+		if (query == '次') {
+			return await this.getTl();
+		} else {
+			this.bot.clearContext();
+			return await this.bot.q(query);
+		}
+	}
+
+	private async getTl() {
+		const tl = await require('../endpoints/notes/timeline')({
+			limit: 5,
+			untilId: this.next ? this.next : undefined
+		}, this.bot.user);
+
+		if (tl.length > 0) {
+			this.next = tl[tl.length - 1].id;
+			this.emit('updated');
+
+			const text = tl
+				.map(note => `${getUserName(note.user)}\n「${getNoteSummary(note)}」`)
+				.join('\n-----\n');
+
+			return text;
+		} else {
+			return 'タイムラインに表示するものがありません...';
+		}
+	}
+
+	public export() {
+		return {
+			type: 'tl',
+			content: {
+				next: this.next,
+			}
+		};
+	}
+
+	public static import(bot: BotCore, data: any) {
+		const context = new TlContext(bot);
+		context.next = data.next;
+		return context;
+	}
+}
+
+class NotificationsContext extends Context {
+	private next: string = null;
+
+	public async greet(): Promise<string> {
+		return await this.getNotifications();
+	}
+
+	public async q(query: string): Promise<string> {
+		if (query == '次') {
+			return await this.getNotifications();
+		} else {
+			this.bot.clearContext();
+			return await this.bot.q(query);
+		}
+	}
+
+	private async getNotifications() {
+		const notifications = await require('../endpoints/i/notifications')({
+			limit: 5,
+			untilId: this.next ? this.next : undefined
+		}, this.bot.user);
+
+		if (notifications.length > 0) {
+			this.next = notifications[notifications.length - 1].id;
+			this.emit('updated');
+
+			const text = notifications
+				.map(notification => getNotificationSummary(notification))
+				.join('\n-----\n');
+
+			return text;
+		} else {
+			return '通知はありません';
+		}
+	}
+
+	public export() {
+		return {
+			type: 'notifications',
+			content: {
+				next: this.next,
+			}
+		};
+	}
+
+	public static import(bot: BotCore, data: any) {
+		const context = new NotificationsContext(bot);
+		context.next = data.next;
+		return context;
+	}
+}
+
+class GuessingGameContext extends Context {
+	private secret: number;
+	private history: number[] = [];
+
+	public async greet(): Promise<string> {
+		this.secret = Math.floor(Math.random() * 100);
+		this.emit('updated');
+		return '0~100の秘密の数を当ててみてください:';
+	}
+
+	public async q(query: string): Promise<string> {
+		if (query == 'やめる') {
+			this.bot.clearContext();
+			return 'やめました。';
+		}
+
+		const guess = parseInt(query, 10);
+
+		if (isNaN(guess)) {
+			return '整数で推測してください。「やめる」と言うとゲームをやめます。';
+		}
+
+		const firsttime = this.history.indexOf(guess) === -1;
+
+		this.history.push(guess);
+		this.emit('updated');
+
+		if (this.secret < guess) {
+			return firsttime ? `${guess}よりも小さいですね` : `もう一度言いますが${guess}より小さいですよ`;
+		} else if (this.secret > guess) {
+			return firsttime ? `${guess}よりも大きいですね` : `もう一度言いますが${guess}より大きいですよ`;
+		} else {
+			this.bot.clearContext();
+			return `正解です🎉 (${this.history.length}回目で当てました)`;
+		}
+	}
+
+	public export() {
+		return {
+			type: 'guessing-game',
+			content: {
+				secret: this.secret,
+				history: this.history
+			}
+		};
+	}
+
+	public static import(bot: BotCore, data: any) {
+		const context = new GuessingGameContext(bot);
+		context.secret = data.secret;
+		context.history = data.history;
+		return context;
+	}
+}
diff --git a/src/server/api/bot/interfaces/line.ts b/src/server/api/bot/interfaces/line.ts
new file mode 100644
index 0000000000..733315391d
--- /dev/null
+++ b/src/server/api/bot/interfaces/line.ts
@@ -0,0 +1,238 @@
+import * as EventEmitter from 'events';
+import * as Router from 'koa-router';
+import * as request from 'request';
+import * as crypto from 'crypto';
+import User from '../../../../models/user';
+import config from '../../../../config';
+import BotCore from '../core';
+import _redis from '../../../../db/redis';
+import prominence = require('prominence');
+import getAcct from '../../../../acct/render';
+import parseAcct from '../../../../acct/parse';
+import getNoteSummary from '../../../../renderers/get-note-summary';
+import getUserName from '../../../../renderers/get-user-name';
+
+const redis = prominence(_redis);
+
+// SEE: https://developers.line.me/media/messaging-api/messages/sticker_list.pdf
+const stickers = [
+	'297',
+	'298',
+	'299',
+	'300',
+	'301',
+	'302',
+	'303',
+	'304',
+	'305',
+	'306',
+	'307'
+];
+
+class LineBot extends BotCore {
+	private replyToken: string;
+
+	private reply(messages: any[]) {
+		request.post({
+			url: 'https://api.line.me/v2/bot/message/reply',
+			headers: {
+				'Authorization': `Bearer ${config.line_bot.channel_access_token}`
+			},
+			json: {
+				replyToken: this.replyToken,
+				messages: messages
+			}
+		}, (err, res, body) => {
+			if (err) {
+				console.error(err);
+				return;
+			}
+		});
+	}
+
+	public async react(ev: any): Promise<void> {
+		this.replyToken = ev.replyToken;
+
+		switch (ev.type) {
+			// メッセージ
+			case 'message':
+				switch (ev.message.type) {
+					// テキスト
+					case 'text':
+						const res = await this.q(ev.message.text);
+						if (res == null) return;
+						// 返信
+						this.reply([{
+							type: 'text',
+							text: res
+						}]);
+						break;
+
+					// スタンプ
+					case 'sticker':
+						// スタンプで返信
+						this.reply([{
+							type: 'sticker',
+							packageId: '4',
+							stickerId: stickers[Math.floor(Math.random() * stickers.length)]
+						}]);
+						break;
+				}
+				break;
+
+			// noteback
+			case 'noteback':
+				const data = ev.noteback.data;
+				const cmd = data.split('|')[0];
+				const arg = data.split('|')[1];
+				switch (cmd) {
+					case 'showtl':
+						this.showUserTimelineNoteback(arg);
+						break;
+				}
+				break;
+		}
+	}
+
+	public static import(data) {
+		const bot = new LineBot();
+		bot._import(data);
+		return bot;
+	}
+
+	public async showUserCommand(q: string) {
+		const user = await require('../../endpoints/users/show')(parseAcct(q.substr(1)), this.user);
+
+		const acct = getAcct(user);
+		const actions = [];
+
+		actions.push({
+			type: 'noteback',
+			label: 'タイムラインを見る',
+			data: `showtl|${user.id}`
+		});
+
+		if (user.twitter) {
+			actions.push({
+				type: 'uri',
+				label: 'Twitterアカウントを見る',
+				uri: `https://twitter.com/${user.twitter.screenName}`
+			});
+		}
+
+		actions.push({
+			type: 'uri',
+			label: 'Webで見る',
+			uri: `${config.url}/@${acct}`
+		});
+
+		this.reply([{
+			type: 'template',
+			altText: await super.showUserCommand(q),
+			template: {
+				type: 'buttons',
+				thumbnailImageUrl: `${user.avatarUrl}?thumbnail&size=1024`,
+				title: `${getUserName(user)} (@${acct})`,
+				text: user.description || '(no description)',
+				actions: actions
+			}
+		}]);
+
+		return null;
+	}
+
+	public async showUserTimelineNoteback(userId: string) {
+		const tl = await require('../../endpoints/users/notes')({
+			userId: userId,
+			limit: 5
+		}, this.user);
+
+		const text = `${getUserName(tl[0].user)}さんのタイムラインはこちらです:\n\n` + tl
+			.map(note => getNoteSummary(note))
+			.join('\n-----\n');
+
+		this.reply([{
+			type: 'text',
+			text: text
+		}]);
+	}
+}
+
+const handler = new EventEmitter();
+
+handler.on('event', async (ev) => {
+
+	const sourceId = ev.source.userId;
+	const sessionId = `line-bot-sessions:${sourceId}`;
+
+	const session = await redis.get(sessionId);
+	let bot: LineBot;
+
+	if (session == null) {
+		const user = await User.findOne({
+			host: null,
+			'line': {
+				userId: sourceId
+			}
+		});
+
+		bot = new LineBot(user);
+
+		bot.on('signin', user => {
+			User.update(user._id, {
+				$set: {
+					'line': {
+						userId: sourceId
+					}
+				}
+			});
+		});
+
+		bot.on('signout', user => {
+			User.update(user._id, {
+				$set: {
+					'line': {
+						userId: null
+					}
+				}
+			});
+		});
+
+		redis.set(sessionId, JSON.stringify(bot.export()));
+	} else {
+		bot = LineBot.import(JSON.parse(session));
+	}
+
+	bot.on('updated', () => {
+		redis.set(sessionId, JSON.stringify(bot.export()));
+	});
+
+	if (session != null) bot.refreshUser();
+
+	bot.react(ev);
+});
+
+// Init router
+const router = new Router();
+
+if (config.line_bot) {
+	router.post('/hooks/line', ctx => {
+		const sig1 = ctx.headers['x-line-signature'];
+
+		const hash = crypto.createHmac('SHA256', config.line_bot.channel_secret)
+			.update(ctx.request.rawBody);
+
+		const sig2 = hash.digest('base64');
+
+		// シグネチャ比較
+		if (sig1 === sig2) {
+			ctx.request.body.events.forEach(ev => {
+				handler.emit('event', ev);
+			});
+		} else {
+			ctx.status = 400;
+		}
+	});
+}
+
+module.exports = router;
diff --git a/src/server/api/call.ts b/src/server/api/call.ts
new file mode 100644
index 0000000000..fd3cea7743
--- /dev/null
+++ b/src/server/api/call.ts
@@ -0,0 +1,51 @@
+import endpoints, { Endpoint } from './endpoints';
+import limitter from './limitter';
+import { IUser } from '../../models/user';
+import { IApp } from '../../models/app';
+
+export default (endpoint: string | Endpoint, user: IUser, app: IApp, data: any, file?: any) => new Promise<any>(async (ok, rej) => {
+	const isSecure = user != null && app == null;
+
+	const ep = typeof endpoint == 'string' ? endpoints.find(e => e.name == endpoint) : endpoint;
+
+	if (ep.secure && !isSecure) {
+		return rej('ACCESS_DENIED');
+	}
+
+	if (ep.withCredential && user == null) {
+		return rej('SIGNIN_REQUIRED');
+	}
+
+	if (app && ep.kind) {
+		if (!app.permission.some(p => p === ep.kind)) {
+			return rej('PERMISSION_DENIED');
+		}
+	}
+
+	if (ep.withCredential && ep.limit) {
+		try {
+			await limitter(ep, user); // Rate limit
+		} catch (e) {
+			// drop request if limit exceeded
+			return rej('RATE_LIMIT_EXCEEDED');
+		}
+	}
+
+	let exec = require(`${__dirname}/endpoints/${ep.name}`);
+
+	if (ep.withFile && file) {
+		exec = exec.bind(null, file);
+	}
+
+	let res;
+
+	// API invoking
+	try {
+		res = await exec(data, user, app);
+	} catch (e) {
+		rej(e);
+		return;
+	}
+
+	ok(res);
+});
diff --git a/src/server/api/common/generate-native-user-token.ts b/src/server/api/common/generate-native-user-token.ts
new file mode 100644
index 0000000000..2082b89a5a
--- /dev/null
+++ b/src/server/api/common/generate-native-user-token.ts
@@ -0,0 +1,3 @@
+import rndstr from 'rndstr';
+
+export default () => `!${rndstr('a-zA-Z0-9', 32)}`;
diff --git a/src/server/api/common/get-friends.ts b/src/server/api/common/get-friends.ts
new file mode 100644
index 0000000000..50ba71ea96
--- /dev/null
+++ b/src/server/api/common/get-friends.ts
@@ -0,0 +1,47 @@
+import * as mongodb from 'mongodb';
+import Following from '../../../models/following';
+
+export const getFriendIds = async (me: mongodb.ObjectID, includeMe = true) => {
+	// Fetch relation to other users who the I follows
+	// SELECT followee
+	const followings = await Following
+		.find({
+			followerId: me
+		}, {
+			fields: {
+				followeeId: true
+			}
+		});
+
+	// ID list of other users who the I follows
+	const myfollowingIds = followings.map(following => following.followeeId);
+
+	if (includeMe) {
+		myfollowingIds.push(me);
+	}
+
+	return myfollowingIds;
+};
+
+export const getFriends = async (me: mongodb.ObjectID, includeMe = true) => {
+	// Fetch relation to other users who the I follows
+	const followings = await Following
+		.find({
+			followerId: me
+		});
+
+	// ID list of other users who the I follows
+	const myfollowings = followings.map(following => ({
+		id: following.followeeId,
+		stalk: following.stalk
+	}));
+
+	if (includeMe) {
+		myfollowings.push({
+			id: me,
+			stalk: true
+		});
+	}
+
+	return myfollowings;
+};
diff --git a/src/server/api/common/get-host-lower.ts b/src/server/api/common/get-host-lower.ts
new file mode 100644
index 0000000000..550c233001
--- /dev/null
+++ b/src/server/api/common/get-host-lower.ts
@@ -0,0 +1,5 @@
+import { toUnicode } from 'punycode';
+
+export default host => {
+	return toUnicode(host).toLowerCase();
+};
diff --git a/src/server/api/common/is-native-token.ts b/src/server/api/common/is-native-token.ts
new file mode 100644
index 0000000000..0769a4812e
--- /dev/null
+++ b/src/server/api/common/is-native-token.ts
@@ -0,0 +1 @@
+export default (token: string) => token[0] == '!';
diff --git a/src/server/api/common/read-messaging-message.ts b/src/server/api/common/read-messaging-message.ts
new file mode 100644
index 0000000000..c52f9363b5
--- /dev/null
+++ b/src/server/api/common/read-messaging-message.ts
@@ -0,0 +1,66 @@
+import * as mongo from 'mongodb';
+import Message from '../../../models/messaging-message';
+import { IMessagingMessage as IMessage } from '../../../models/messaging-message';
+import publishUserStream from '../../../publishers/stream';
+import { publishMessagingStream } from '../../../publishers/stream';
+import { publishMessagingIndexStream } from '../../../publishers/stream';
+
+/**
+ * Mark as read message(s)
+ */
+export default (
+	user: string | mongo.ObjectID,
+	otherparty: string | mongo.ObjectID,
+	message: string | string[] | IMessage | IMessage[] | mongo.ObjectID | mongo.ObjectID[]
+) => new Promise<any>(async (resolve, reject) => {
+
+	const userId = mongo.ObjectID.prototype.isPrototypeOf(user)
+		? user
+		: new mongo.ObjectID(user);
+
+	const otherpartyId = mongo.ObjectID.prototype.isPrototypeOf(otherparty)
+		? otherparty
+		: new mongo.ObjectID(otherparty);
+
+	const ids: mongo.ObjectID[] = Array.isArray(message)
+		? mongo.ObjectID.prototype.isPrototypeOf(message[0])
+			? (message as mongo.ObjectID[])
+			: typeof message[0] === 'string'
+				? (message as string[]).map(m => new mongo.ObjectID(m))
+				: (message as IMessage[]).map(m => m._id)
+		: mongo.ObjectID.prototype.isPrototypeOf(message)
+			? [(message as mongo.ObjectID)]
+			: typeof message === 'string'
+				? [new mongo.ObjectID(message)]
+				: [(message as IMessage)._id];
+
+	// Update documents
+	await Message.update({
+		_id: { $in: ids },
+		userId: otherpartyId,
+		recipientId: userId,
+		isRead: false
+	}, {
+		$set: {
+			isRead: true
+		}
+	}, {
+		multi: true
+	});
+
+	// Publish event
+	publishMessagingStream(otherpartyId, userId, 'read', ids.map(id => id.toString()));
+	publishMessagingIndexStream(userId, 'read', ids.map(id => id.toString()));
+
+	// Calc count of my unread messages
+	const count = await Message
+		.count({
+			recipientId: userId,
+			isRead: false
+		});
+
+	if (count == 0) {
+		// 全ての(いままで未読だった)自分宛てのメッセージを(これで)読みましたよというイベントを発行
+		publishUserStream(userId, 'read_all_messaging_messages');
+	}
+});
diff --git a/src/server/api/common/read-notification.ts b/src/server/api/common/read-notification.ts
new file mode 100644
index 0000000000..9bd41519fb
--- /dev/null
+++ b/src/server/api/common/read-notification.ts
@@ -0,0 +1,52 @@
+import * as mongo from 'mongodb';
+import { default as Notification, INotification } from '../../../models/notification';
+import publishUserStream from '../../../publishers/stream';
+
+/**
+ * Mark as read notification(s)
+ */
+export default (
+	user: string | mongo.ObjectID,
+	message: string | string[] | INotification | INotification[] | mongo.ObjectID | mongo.ObjectID[]
+) => new Promise<any>(async (resolve, reject) => {
+
+	const userId = mongo.ObjectID.prototype.isPrototypeOf(user)
+		? user
+		: new mongo.ObjectID(user);
+
+	const ids: mongo.ObjectID[] = Array.isArray(message)
+		? mongo.ObjectID.prototype.isPrototypeOf(message[0])
+			? (message as mongo.ObjectID[])
+			: typeof message[0] === 'string'
+				? (message as string[]).map(m => new mongo.ObjectID(m))
+				: (message as INotification[]).map(m => m._id)
+		: mongo.ObjectID.prototype.isPrototypeOf(message)
+			? [(message as mongo.ObjectID)]
+			: typeof message === 'string'
+				? [new mongo.ObjectID(message)]
+				: [(message as INotification)._id];
+
+	// Update documents
+	await Notification.update({
+		_id: { $in: ids },
+		isRead: false
+	}, {
+		$set: {
+			isRead: true
+		}
+	}, {
+		multi: true
+	});
+
+	// Calc count of my unread notifications
+	const count = await Notification
+		.count({
+			notifieeId: userId,
+			isRead: false
+		});
+
+	if (count == 0) {
+		// 全ての(いままで未読だった)通知を(これで)読みましたよというイベントを発行
+		publishUserStream(userId, 'read_all_notifications');
+	}
+});
diff --git a/src/server/api/common/signin.ts b/src/server/api/common/signin.ts
new file mode 100644
index 0000000000..44e1336f27
--- /dev/null
+++ b/src/server/api/common/signin.ts
@@ -0,0 +1,22 @@
+import * as Koa from 'koa';
+
+import config from '../../../config';
+import { ILocalUser } from '../../../models/user';
+
+export default function(ctx: Koa.Context, user: ILocalUser, redirect = false) {
+	const expires = 1000 * 60 * 60 * 24 * 365; // One Year
+	ctx.cookies.set('i', user.token, {
+		path: '/',
+		domain: config.hostname,
+		secure: config.url.startsWith('https'),
+		httpOnly: false,
+		expires: new Date(Date.now() + expires),
+		maxAge: expires
+	});
+
+	if (redirect) {
+		ctx.redirect(config.url);
+	} else {
+		ctx.status = 204;
+	}
+}
diff --git a/src/server/api/endpoints.ts b/src/server/api/endpoints.ts
new file mode 100644
index 0000000000..734b8273f1
--- /dev/null
+++ b/src/server/api/endpoints.ts
@@ -0,0 +1,653 @@
+const ms = require('ms');
+
+/**
+ * エンドポイントを表します。
+ */
+export type Endpoint = {
+
+	/**
+	 * エンドポイント名
+	 */
+	name: string;
+
+	/**
+	 * このエンドポイントにリクエストするのにユーザー情報が必須か否か
+	 * 省略した場合は false として解釈されます。
+	 */
+	withCredential?: boolean;
+
+	/**
+	 * エンドポイントのリミテーションに関するやつ
+	 * 省略した場合はリミテーションは無いものとして解釈されます。
+	 * また、withCredential が false の場合はリミテーションを行うことはできません。
+	 */
+	limit?: {
+
+		/**
+		 * 複数のエンドポイントでリミットを共有したい場合に指定するキー
+		 */
+		key?: string;
+
+		/**
+		 * リミットを適用する期間(ms)
+		 * このプロパティを設定する場合、max プロパティも設定する必要があります。
+		 */
+		duration?: number;
+
+		/**
+		 * durationで指定した期間内にいくつまでリクエストできるのか
+		 * このプロパティを設定する場合、duration プロパティも設定する必要があります。
+		 */
+		max?: number;
+
+		/**
+		 * 最低でもどれくらいの間隔を開けてリクエストしなければならないか(ms)
+		 */
+		minInterval?: number;
+	};
+
+	/**
+	 * ファイルの添付を必要とするか否か
+	 * 省略した場合は false として解釈されます。
+	 */
+	withFile?: boolean;
+
+	/**
+	 * サードパーティアプリからはリクエストすることができないか否か
+	 * 省略した場合は false として解釈されます。
+	 */
+	secure?: boolean;
+
+	/**
+	 * エンドポイントの種類
+	 * パーミッションの実現に利用されます。
+	 */
+	kind?: string;
+};
+
+const endpoints: Endpoint[] = [
+	{
+		name: 'meta'
+	},
+	{
+		name: 'stats'
+	},
+	{
+		name: 'username/available'
+	},
+	{
+		name: 'my/apps',
+		withCredential: true
+	},
+	{
+		name: 'app/create',
+		withCredential: true,
+		limit: {
+			duration: ms('1day'),
+			max: 3
+		}
+	},
+	{
+		name: 'app/show'
+	},
+	{
+		name: 'app/name_id/available'
+	},
+	{
+		name: 'auth/session/generate'
+	},
+	{
+		name: 'auth/session/show'
+	},
+	{
+		name: 'auth/session/userkey'
+	},
+	{
+		name: 'auth/accept',
+		withCredential: true,
+		secure: true
+	},
+	{
+		name: 'auth/deny',
+		withCredential: true,
+		secure: true
+	},
+	{
+		name: 'aggregation/notes',
+	},
+	{
+		name: 'aggregation/users',
+	},
+	{
+		name: 'aggregation/users/activity',
+	},
+	{
+		name: 'aggregation/users/note',
+	},
+	{
+		name: 'aggregation/users/followers'
+	},
+	{
+		name: 'aggregation/users/following'
+	},
+	{
+		name: 'aggregation/users/reaction'
+	},
+	{
+		name: 'aggregation/notes/renote'
+	},
+	{
+		name: 'aggregation/notes/reply'
+	},
+	{
+		name: 'aggregation/notes/reaction'
+	},
+	{
+		name: 'aggregation/notes/reactions'
+	},
+
+	{
+		name: 'sw/register',
+		withCredential: true
+	},
+
+	{
+		name: 'i',
+		withCredential: true
+	},
+	{
+		name: 'i/2fa/register',
+		withCredential: true,
+		secure: true
+	},
+	{
+		name: 'i/2fa/unregister',
+		withCredential: true,
+		secure: true
+	},
+	{
+		name: 'i/2fa/done',
+		withCredential: true,
+		secure: true
+	},
+	{
+		name: 'i/update',
+		withCredential: true,
+		limit: {
+			duration: ms('1day'),
+			max: 50
+		},
+		kind: 'account-write'
+	},
+	{
+		name: 'i/update_home',
+		withCredential: true,
+		secure: true
+	},
+	{
+		name: 'i/update_mobile_home',
+		withCredential: true,
+		secure: true
+	},
+	{
+		name: 'i/change_password',
+		withCredential: true,
+		secure: true
+	},
+	{
+		name: 'i/regenerate_token',
+		withCredential: true,
+		secure: true
+	},
+	{
+		name: 'i/update_client_setting',
+		withCredential: true,
+		secure: true
+	},
+	{
+		name: 'i/pin',
+		kind: 'account-write'
+	},
+	{
+		name: 'i/appdata/get',
+		withCredential: true
+	},
+	{
+		name: 'i/appdata/set',
+		withCredential: true
+	},
+	{
+		name: 'i/signin_history',
+		withCredential: true,
+		kind: 'account-read'
+	},
+	{
+		name: 'i/authorized_apps',
+		withCredential: true,
+		secure: true
+	},
+
+	{
+		name: 'i/notifications',
+		withCredential: true,
+		kind: 'notification-read'
+	},
+
+	{
+		name: 'i/favorites',
+		withCredential: true,
+		kind: 'favorites-read'
+	},
+
+	{
+		name: 'othello/match',
+		withCredential: true
+	},
+
+	{
+		name: 'othello/match/cancel',
+		withCredential: true
+	},
+
+	{
+		name: 'othello/invitations',
+		withCredential: true
+	},
+
+	{
+		name: 'othello/games',
+		withCredential: true
+	},
+
+	{
+		name: 'othello/games/show'
+	},
+
+	{
+		name: 'mute/create',
+		withCredential: true,
+		kind: 'account/write'
+	},
+	{
+		name: 'mute/delete',
+		withCredential: true,
+		kind: 'account/write'
+	},
+	{
+		name: 'mute/list',
+		withCredential: true,
+		kind: 'account/read'
+	},
+
+	{
+		name: 'notifications/get_unread_count',
+		withCredential: true,
+		kind: 'notification-read'
+	},
+	{
+		name: 'notifications/delete',
+		withCredential: true,
+		kind: 'notification-write'
+	},
+	{
+		name: 'notifications/delete_all',
+		withCredential: true,
+		kind: 'notification-write'
+	},
+	{
+		name: 'notifications/mark_as_read_all',
+		withCredential: true,
+		kind: 'notification-write'
+	},
+
+	{
+		name: 'drive',
+		withCredential: true,
+		kind: 'drive-read'
+	},
+	{
+		name: 'drive/stream',
+		withCredential: true,
+		kind: 'drive-read'
+	},
+	{
+		name: 'drive/files',
+		withCredential: true,
+		kind: 'drive-read'
+	},
+	{
+		name: 'drive/files/create',
+		withCredential: true,
+		limit: {
+			duration: ms('1hour'),
+			max: 100
+		},
+		withFile: true,
+		kind: 'drive-write'
+	},
+	{
+		name: 'drive/files/upload_from_url',
+		withCredential: true,
+		limit: {
+			duration: ms('1hour'),
+			max: 10
+		},
+		kind: 'drive-write'
+	},
+	{
+		name: 'drive/files/show',
+		withCredential: true,
+		kind: 'drive-read'
+	},
+	{
+		name: 'drive/files/find',
+		withCredential: true,
+		kind: 'drive-read'
+	},
+	{
+		name: 'drive/files/delete',
+		withCredential: true,
+		kind: 'drive-write'
+	},
+	{
+		name: 'drive/files/update',
+		withCredential: true,
+		kind: 'drive-write'
+	},
+	{
+		name: 'drive/folders',
+		withCredential: true,
+		kind: 'drive-read'
+	},
+	{
+		name: 'drive/folders/create',
+		withCredential: true,
+		limit: {
+			duration: ms('1hour'),
+			max: 50
+		},
+		kind: 'drive-write'
+	},
+	{
+		name: 'drive/folders/show',
+		withCredential: true,
+		kind: 'drive-read'
+	},
+	{
+		name: 'drive/folders/find',
+		withCredential: true,
+		kind: 'drive-read'
+	},
+	{
+		name: 'drive/folders/update',
+		withCredential: true,
+		kind: 'drive-write'
+	},
+
+	{
+		name: 'users'
+	},
+	{
+		name: 'users/show'
+	},
+	{
+		name: 'users/search'
+	},
+	{
+		name: 'users/search_by_username'
+	},
+	{
+		name: 'users/notes'
+	},
+	{
+		name: 'users/following'
+	},
+	{
+		name: 'users/followers'
+	},
+	{
+		name: 'users/recommendation',
+		withCredential: true,
+		kind: 'account-read'
+	},
+	{
+		name: 'users/get_frequently_replied_users'
+	},
+
+	{
+		name: 'users/lists/show',
+		withCredential: true,
+		kind: 'account-read'
+	},
+	{
+		name: 'users/lists/create',
+		withCredential: true,
+		kind: 'account-write'
+	},
+	{
+		name: 'users/lists/push',
+		withCredential: true,
+		kind: 'account-write'
+	},
+	{
+		name: 'users/lists/list',
+		withCredential: true,
+		kind: 'account-read'
+	},
+
+	{
+		name: 'following/create',
+		withCredential: true,
+		limit: {
+			duration: ms('1hour'),
+			max: 100
+		},
+		kind: 'following-write'
+	},
+	{
+		name: 'following/delete',
+		withCredential: true,
+		limit: {
+			duration: ms('1hour'),
+			max: 100
+		},
+		kind: 'following-write'
+	},
+	{
+		name: 'following/stalk',
+		withCredential: true,
+		limit: {
+			duration: ms('1hour'),
+			max: 100
+		},
+		kind: 'following-write'
+	},
+	{
+		name: 'following/unstalk',
+		withCredential: true,
+		limit: {
+			duration: ms('1hour'),
+			max: 100
+		},
+		kind: 'following-write'
+	},
+
+	{
+		name: 'notes'
+	},
+	{
+		name: 'notes/show'
+	},
+	{
+		name: 'notes/replies'
+	},
+	{
+		name: 'notes/context'
+	},
+	{
+		name: 'notes/create',
+		withCredential: true,
+		limit: {
+			duration: ms('1hour'),
+			max: 120,
+			minInterval: ms('1second')
+		},
+		kind: 'note-write'
+	},
+	{
+		name: 'notes/renotes'
+	},
+	{
+		name: 'notes/search'
+	},
+	{
+		name: 'notes/timeline',
+		withCredential: true,
+		limit: {
+			duration: ms('10minutes'),
+			max: 100
+		}
+	},
+	{
+		name: 'notes/local-timeline',
+		withCredential: true,
+		limit: {
+			duration: ms('10minutes'),
+			max: 100
+		}
+	},
+	{
+		name: 'notes/global-timeline',
+		withCredential: true,
+		limit: {
+			duration: ms('10minutes'),
+			max: 100
+		}
+	},
+	{
+		name: 'notes/user-list-timeline',
+		withCredential: true,
+		limit: {
+			duration: ms('10minutes'),
+			max: 100
+		}
+	},
+	{
+		name: 'notes/mentions',
+		withCredential: true,
+		limit: {
+			duration: ms('10minutes'),
+			max: 100
+		}
+	},
+	{
+		name: 'notes/trend',
+		withCredential: true
+	},
+	{
+		name: 'notes/categorize',
+		withCredential: true
+	},
+	{
+		name: 'notes/reactions',
+		withCredential: true
+	},
+	{
+		name: 'notes/reactions/create',
+		withCredential: true,
+		limit: {
+			duration: ms('1hour'),
+			max: 100
+		},
+		kind: 'reaction-write'
+	},
+	{
+		name: 'notes/reactions/delete',
+		withCredential: true,
+		limit: {
+			duration: ms('1hour'),
+			max: 100
+		},
+		kind: 'reaction-write'
+	},
+	{
+		name: 'notes/favorites/create',
+		withCredential: true,
+		limit: {
+			duration: ms('1hour'),
+			max: 100
+		},
+		kind: 'favorite-write'
+	},
+	{
+		name: 'notes/favorites/delete',
+		withCredential: true,
+		limit: {
+			duration: ms('1hour'),
+			max: 100
+		},
+		kind: 'favorite-write'
+	},
+	{
+		name: 'notes/polls/vote',
+		withCredential: true,
+		limit: {
+			duration: ms('1hour'),
+			max: 100
+		},
+		kind: 'vote-write'
+	},
+	{
+		name: 'notes/polls/recommendation',
+		withCredential: true
+	},
+
+	{
+		name: 'messaging/history',
+		withCredential: true,
+		kind: 'messaging-read'
+	},
+	{
+		name: 'messaging/unread',
+		withCredential: true,
+		kind: 'messaging-read'
+	},
+	{
+		name: 'messaging/messages',
+		withCredential: true,
+		kind: 'messaging-read'
+	},
+	{
+		name: 'messaging/messages/create',
+		withCredential: true,
+		kind: 'messaging-write'
+	},
+	{
+		name: 'channels/create',
+		withCredential: true,
+		limit: {
+			duration: ms('1hour'),
+			max: 3,
+			minInterval: ms('10seconds')
+		}
+	},
+	{
+		name: 'channels/show'
+	},
+	{
+		name: 'channels/notes'
+	},
+	{
+		name: 'channels/watch',
+		withCredential: true
+	},
+	{
+		name: 'channels/unwatch',
+		withCredential: true
+	},
+	{
+		name: 'channels'
+	},
+];
+
+export default endpoints;
diff --git a/src/server/api/endpoints/aggregation/posts.ts b/src/server/api/endpoints/aggregation/posts.ts
new file mode 100644
index 0000000000..d348cadae9
--- /dev/null
+++ b/src/server/api/endpoints/aggregation/posts.ts
@@ -0,0 +1,87 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy';
+import Note from '../../../../models/note';
+
+/**
+ * Aggregate notes
+ */
+module.exports = params => new Promise(async (res, rej) => {
+	// Get 'limit' parameter
+	const [limit = 365, limitErr] = $.num.optional().range(1, 365).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	const datas = await Note
+		.aggregate([
+			{ $project: {
+				renoteId: '$renoteId',
+				replyId: '$replyId',
+				createdAt: { $add: ['$createdAt', 9 * 60 * 60 * 1000] } // Convert into JST
+			}},
+			{ $project: {
+				date: {
+					year: { $year: '$createdAt' },
+					month: { $month: '$createdAt' },
+					day: { $dayOfMonth: '$createdAt' }
+				},
+				type: {
+					$cond: {
+						if: { $ne: ['$renoteId', null] },
+						then: 'renote',
+						else: {
+							$cond: {
+								if: { $ne: ['$replyId', null] },
+								then: 'reply',
+								else: 'note'
+							}
+						}
+					}
+				}}
+			},
+			{ $group: { _id: {
+				date: '$date',
+				type: '$type'
+			}, count: { $sum: 1 } } },
+			{ $group: {
+				_id: '$_id.date',
+				data: { $addToSet: {
+					type: '$_id.type',
+					count: '$count'
+				}}
+			} }
+		]);
+
+	datas.forEach(data => {
+		data.date = data._id;
+		delete data._id;
+
+		data.notes = (data.data.filter(x => x.type == 'note')[0] || { count: 0 }).count;
+		data.renotes = (data.data.filter(x => x.type == 'renote')[0] || { count: 0 }).count;
+		data.replies = (data.data.filter(x => x.type == 'reply')[0] || { count: 0 }).count;
+
+		delete data.data;
+	});
+
+	const graph = [];
+
+	for (let i = 0; i < limit; i++) {
+		const day = new Date(new Date().setDate(new Date().getDate() - i));
+
+		const data = datas.filter(d =>
+			d.date.year == day.getFullYear() && d.date.month == day.getMonth() + 1 && d.date.day == day.getDate()
+		)[0];
+
+		if (data) {
+			graph.push(data);
+		} else {
+			graph.push({
+				notes: 0,
+				renotes: 0,
+				replies: 0
+			});
+		}
+	}
+
+	res(graph);
+});
diff --git a/src/server/api/endpoints/aggregation/users.ts b/src/server/api/endpoints/aggregation/users.ts
new file mode 100644
index 0000000000..b116c1454b
--- /dev/null
+++ b/src/server/api/endpoints/aggregation/users.ts
@@ -0,0 +1,58 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy';
+import User from '../../../../models/user';
+
+/**
+ * Aggregate users
+ */
+module.exports = params => new Promise(async (res, rej) => {
+	// Get 'limit' parameter
+	const [limit = 365, limitErr] = $.num.optional().range(1, 365).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	const users = await User
+		.find({}, {
+			sort: {
+				_id: -1
+			},
+			fields: {
+				_id: false,
+				createdAt: true,
+				deletedAt: true
+			}
+		});
+
+	const graph = [];
+
+	for (let i = 0; i < limit; i++) {
+		let dayStart = new Date(new Date().setDate(new Date().getDate() - i));
+		dayStart = new Date(dayStart.setMilliseconds(0));
+		dayStart = new Date(dayStart.setSeconds(0));
+		dayStart = new Date(dayStart.setMinutes(0));
+		dayStart = new Date(dayStart.setHours(0));
+
+		let dayEnd = new Date(new Date().setDate(new Date().getDate() - i));
+		dayEnd = new Date(dayEnd.setMilliseconds(999));
+		dayEnd = new Date(dayEnd.setSeconds(59));
+		dayEnd = new Date(dayEnd.setMinutes(59));
+		dayEnd = new Date(dayEnd.setHours(23));
+		// day = day.getTime();
+
+		const total = users.filter(u =>
+			u.createdAt < dayEnd && (u.deletedAt == null || u.deletedAt > dayEnd)
+		).length;
+
+		const created = users.filter(u =>
+			u.createdAt < dayEnd && u.createdAt > dayStart
+		).length;
+
+		graph.push({
+			total: total,
+			created: created
+		});
+	}
+
+	res(graph);
+});
diff --git a/src/server/api/endpoints/aggregation/users/activity.ts b/src/server/api/endpoints/aggregation/users/activity.ts
new file mode 100644
index 0000000000..9109487ac6
--- /dev/null
+++ b/src/server/api/endpoints/aggregation/users/activity.ts
@@ -0,0 +1,113 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../../cafy-id';
+import User from '../../../../../models/user';
+import Note from '../../../../../models/note';
+
+// TODO: likeやfollowも集計
+
+/**
+ * Aggregate activity of a user
+ */
+module.exports = (params) => new Promise(async (res, rej) => {
+	// Get 'limit' parameter
+	const [limit = 365, limitErr] = $.num.optional().range(1, 365).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Get 'userId' parameter
+	const [userId, userIdErr] = $.type(ID).get(params.userId);
+	if (userIdErr) return rej('invalid userId param');
+
+	// Lookup user
+	const user = await User.findOne({
+		_id: userId
+	}, {
+		fields: {
+			_id: true
+		}
+	});
+
+	if (user === null) {
+		return rej('user not found');
+	}
+
+	const datas = await Note
+		.aggregate([
+			{ $match: { userId: user._id } },
+			{ $project: {
+				renoteId: '$renoteId',
+				replyId: '$replyId',
+				createdAt: { $add: ['$createdAt', 9 * 60 * 60 * 1000] } // Convert into JST
+			}},
+			{ $project: {
+				date: {
+					year: { $year: '$createdAt' },
+					month: { $month: '$createdAt' },
+					day: { $dayOfMonth: '$createdAt' }
+				},
+				type: {
+					$cond: {
+						if: { $ne: ['$renoteId', null] },
+						then: 'renote',
+						else: {
+							$cond: {
+								if: { $ne: ['$replyId', null] },
+								then: 'reply',
+								else: 'note'
+							}
+						}
+					}
+				}}
+			},
+			{ $group: { _id: {
+				date: '$date',
+				type: '$type'
+			}, count: { $sum: 1 } } },
+			{ $group: {
+				_id: '$_id.date',
+				data: { $addToSet: {
+					type: '$_id.type',
+					count: '$count'
+				}}
+			} }
+		]);
+
+	datas.forEach(data => {
+		data.date = data._id;
+		delete data._id;
+
+		data.notes = (data.data.filter(x => x.type == 'note')[0] || { count: 0 }).count;
+		data.renotes = (data.data.filter(x => x.type == 'renote')[0] || { count: 0 }).count;
+		data.replies = (data.data.filter(x => x.type == 'reply')[0] || { count: 0 }).count;
+
+		delete data.data;
+	});
+
+	const graph = [];
+
+	for (let i = 0; i < limit; i++) {
+		const day = new Date(new Date().setDate(new Date().getDate() - i));
+
+		const data = datas.filter(d =>
+			d.date.year == day.getFullYear() && d.date.month == day.getMonth() + 1 && d.date.day == day.getDate()
+		)[0];
+
+		if (data) {
+			graph.push(data);
+		} else {
+			graph.push({
+				date: {
+					year: day.getFullYear(),
+					month: day.getMonth() + 1, // In JavaScript, month is zero-based.
+					day: day.getDate()
+				},
+				notes: 0,
+				renotes: 0,
+				replies: 0
+			});
+		}
+	}
+
+	res(graph);
+});
diff --git a/src/server/api/endpoints/aggregation/users/followers.ts b/src/server/api/endpoints/aggregation/users/followers.ts
new file mode 100644
index 0000000000..dfcaf8462f
--- /dev/null
+++ b/src/server/api/endpoints/aggregation/users/followers.ts
@@ -0,0 +1,61 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../../cafy-id';
+import User from '../../../../../models/user';
+import FollowedLog from '../../../../../models/followed-log';
+
+/**
+ * Aggregate followers of a user
+ */
+module.exports = (params) => new Promise(async (res, rej) => {
+	// Get 'userId' parameter
+	const [userId, userIdErr] = $.type(ID).get(params.userId);
+	if (userIdErr) return rej('invalid userId param');
+
+	// Lookup user
+	const user = await User.findOne({
+		_id: userId
+	}, {
+		fields: {
+			_id: true
+		}
+	});
+
+	if (user === null) {
+		return rej('user not found');
+	}
+
+	const today = new Date();
+	const graph = [];
+
+	today.setMinutes(0);
+	today.setSeconds(0);
+	today.setMilliseconds(0);
+
+	let cursorDate = new Date(today.getTime());
+	let cursorTime = cursorDate.setDate(new Date(today.getTime()).getDate() + 1);
+
+	for (let i = 0; i < 30; i++) {
+		graph.push(FollowedLog.findOne({
+			createdAt: { $lt: new Date(cursorTime / 1000) },
+			userId: user._id
+		}, {
+			sort: { createdAt: -1 },
+		}).then(log => {
+			cursorDate = new Date(today.getTime());
+			cursorTime = cursorDate.setDate(today.getDate() - i);
+
+			return {
+				date: {
+					year: cursorDate.getFullYear(),
+					month: cursorDate.getMonth() + 1, // In JavaScript, month is zero-based.
+					day: cursorDate.getDate()
+				},
+				count: log ? log.count : 0
+			};
+		}));
+	}
+
+	res(await Promise.all(graph));
+});
diff --git a/src/server/api/endpoints/aggregation/users/following.ts b/src/server/api/endpoints/aggregation/users/following.ts
new file mode 100644
index 0000000000..5f826fd71c
--- /dev/null
+++ b/src/server/api/endpoints/aggregation/users/following.ts
@@ -0,0 +1,61 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../../cafy-id';
+import User from '../../../../../models/user';
+import FollowingLog from '../../../../../models/following-log';
+
+/**
+ * Aggregate following of a user
+ */
+module.exports = (params) => new Promise(async (res, rej) => {
+	// Get 'userId' parameter
+	const [userId, userIdErr] = $.type(ID).get(params.userId);
+	if (userIdErr) return rej('invalid userId param');
+
+	// Lookup user
+	const user = await User.findOne({
+		_id: userId
+	}, {
+		fields: {
+			_id: true
+		}
+	});
+
+	if (user === null) {
+		return rej('user not found');
+	}
+
+	const today = new Date();
+	const graph = [];
+
+	today.setMinutes(0);
+	today.setSeconds(0);
+	today.setMilliseconds(0);
+
+	let cursorDate = new Date(today.getTime());
+	let cursorTime = cursorDate.setDate(new Date(today.getTime()).getDate() + 1);
+
+	for (let i = 0; i < 30; i++) {
+		graph.push(FollowingLog.findOne({
+			createdAt: { $lt: new Date(cursorTime / 1000) },
+			userId: user._id
+		}, {
+			sort: { createdAt: -1 },
+		}).then(log => {
+			cursorDate = new Date(today.getTime());
+			cursorTime = cursorDate.setDate(today.getDate() - i);
+
+			return {
+				date: {
+					year: cursorDate.getFullYear(),
+					month: cursorDate.getMonth() + 1, // In JavaScript, month is zero-based.
+					day: cursorDate.getDate()
+				},
+				count: log ? log.count : 0
+			};
+		}));
+	}
+
+	res(await Promise.all(graph));
+});
diff --git a/src/server/api/endpoints/aggregation/users/post.ts b/src/server/api/endpoints/aggregation/users/post.ts
new file mode 100644
index 0000000000..11f9ef14cd
--- /dev/null
+++ b/src/server/api/endpoints/aggregation/users/post.ts
@@ -0,0 +1,107 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../../cafy-id';
+import User from '../../../../../models/user';
+import Note from '../../../../../models/note';
+
+/**
+ * Aggregate note of a user
+ */
+module.exports = (params) => new Promise(async (res, rej) => {
+	// Get 'userId' parameter
+	const [userId, userIdErr] = $.type(ID).get(params.userId);
+	if (userIdErr) return rej('invalid userId param');
+
+	// Lookup user
+	const user = await User.findOne({
+		_id: userId
+	}, {
+		fields: {
+			_id: true
+		}
+	});
+
+	if (user === null) {
+		return rej('user not found');
+	}
+
+	const datas = await Note
+		.aggregate([
+			{ $match: { userId: user._id } },
+			{ $project: {
+				renoteId: '$renoteId',
+				replyId: '$replyId',
+				createdAt: { $add: ['$createdAt', 9 * 60 * 60 * 1000] } // Convert into JST
+			}},
+			{ $project: {
+				date: {
+					year: { $year: '$createdAt' },
+					month: { $month: '$createdAt' },
+					day: { $dayOfMonth: '$createdAt' }
+				},
+				type: {
+					$cond: {
+						if: { $ne: ['$renoteId', null] },
+						then: 'renote',
+						else: {
+							$cond: {
+								if: { $ne: ['$replyId', null] },
+								then: 'reply',
+								else: 'note'
+							}
+						}
+					}
+				}}
+			},
+			{ $group: { _id: {
+				date: '$date',
+				type: '$type'
+			}, count: { $sum: 1 } } },
+			{ $group: {
+				_id: '$_id.date',
+				data: { $addToSet: {
+					type: '$_id.type',
+					count: '$count'
+				}}
+			} }
+		]);
+
+	datas.forEach(data => {
+		data.date = data._id;
+		delete data._id;
+
+		data.notes = (data.data.filter(x => x.type == 'note')[0] || { count: 0 }).count;
+		data.renotes = (data.data.filter(x => x.type == 'renote')[0] || { count: 0 }).count;
+		data.replies = (data.data.filter(x => x.type == 'reply')[0] || { count: 0 }).count;
+
+		delete data.data;
+	});
+
+	const graph = [];
+
+	for (let i = 0; i < 30; i++) {
+		const day = new Date(new Date().setDate(new Date().getDate() - i));
+
+		const data = datas.filter(d =>
+			d.date.year == day.getFullYear() && d.date.month == day.getMonth() + 1 && d.date.day == day.getDate()
+		)[0];
+
+		if (data) {
+			graph.push(data);
+		} else {
+			graph.push({
+				date: {
+					year: day.getFullYear(),
+					month: day.getMonth() + 1, // In JavaScript, month is zero-based.
+					day: day.getDate()
+				},
+				notes: 0,
+				renotes: 0,
+				replies: 0
+			});
+		}
+	}
+
+	res(graph);
+});
diff --git a/src/server/api/endpoints/aggregation/users/reaction.ts b/src/server/api/endpoints/aggregation/users/reaction.ts
new file mode 100644
index 0000000000..2de2840258
--- /dev/null
+++ b/src/server/api/endpoints/aggregation/users/reaction.ts
@@ -0,0 +1,80 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../../cafy-id';
+import User from '../../../../../models/user';
+import Reaction from '../../../../../models/note-reaction';
+
+/**
+ * Aggregate reaction of a user
+ *
+ * @param {any} params
+ * @return {Promise<any>}
+ */
+module.exports = (params) => new Promise(async (res, rej) => {
+	// Get 'userId' parameter
+	const [userId, userIdErr] = $.type(ID).get(params.userId);
+	if (userIdErr) return rej('invalid userId param');
+
+	// Lookup user
+	const user = await User.findOne({
+		_id: userId
+	}, {
+		fields: {
+			_id: true
+		}
+	});
+
+	if (user === null) {
+		return rej('user not found');
+	}
+
+	const datas = await Reaction
+		.aggregate([
+			{ $match: { userId: user._id } },
+			{ $project: {
+				createdAt: { $add: ['$createdAt', 9 * 60 * 60 * 1000] } // Convert into JST
+			}},
+			{ $project: {
+				date: {
+					year: { $year: '$createdAt' },
+					month: { $month: '$createdAt' },
+					day: { $dayOfMonth: '$createdAt' }
+				}
+			}},
+			{ $group: {
+				_id: '$date',
+				count: { $sum: 1 }
+			}}
+		]);
+
+	datas.forEach(data => {
+		data.date = data._id;
+		delete data._id;
+	});
+
+	const graph = [];
+
+	for (let i = 0; i < 30; i++) {
+		const day = new Date(new Date().setDate(new Date().getDate() - i));
+
+		const data = datas.filter(d =>
+			d.date.year == day.getFullYear() && d.date.month == day.getMonth() + 1 && d.date.day == day.getDate()
+		)[0];
+
+		if (data) {
+			graph.push(data);
+		} else {
+			graph.push({
+				date: {
+					year: day.getFullYear(),
+					month: day.getMonth() + 1, // In JavaScript, month is zero-based.
+					day: day.getDate()
+				},
+				count: 0
+			});
+		}
+	}
+
+	res(graph);
+});
diff --git a/src/server/api/endpoints/app/create.ts b/src/server/api/endpoints/app/create.ts
new file mode 100644
index 0000000000..553bd2381a
--- /dev/null
+++ b/src/server/api/endpoints/app/create.ts
@@ -0,0 +1,108 @@
+/**
+ * Module dependencies
+ */
+import rndstr from 'rndstr';
+import $ from 'cafy';
+import App, { isValidNameId, pack } from '../../../../models/app';
+
+/**
+ * @swagger
+ * /app/create:
+ *   note:
+ *     summary: Create an application
+ *     parameters:
+ *       - $ref: "#/parameters/AccessToken"
+ *       -
+ *         name: nameId
+ *         description: Application unique name
+ *         in: formData
+ *         required: true
+ *         type: string
+ *       -
+ *         name: name
+ *         description: Application name
+ *         in: formData
+ *         required: true
+ *         type: string
+ *       -
+ *         name: description
+ *         description: Application description
+ *         in: formData
+ *         required: true
+ *         type: string
+ *       -
+ *         name: permission
+ *         description: Permissions that application has
+ *         in: formData
+ *         required: true
+ *         type: array
+ *         items:
+ *           type: string
+ *           collectionFormat: csv
+ *       -
+ *         name: callbackUrl
+ *         description: URL called back after authentication
+ *         in: formData
+ *         required: false
+ *         type: string
+ *
+ *     responses:
+ *       200:
+ *         description: Created application's information
+ *         schema:
+ *           $ref: "#/definitions/Application"
+ *
+ *       default:
+ *         description: Failed
+ *         schema:
+ *           $ref: "#/definitions/Error"
+ */
+
+/**
+ * Create an app
+ *
+ * @param {any} params
+ * @param {any} user
+ * @return {Promise<any>}
+ */
+module.exports = async (params, user) => new Promise(async (res, rej) => {
+	// Get 'nameId' parameter
+	const [nameId, nameIdErr] = $.str.pipe(isValidNameId).get(params.nameId);
+	if (nameIdErr) return rej('invalid nameId param');
+
+	// Get 'name' parameter
+	const [name, nameErr] = $.str.get(params.name);
+	if (nameErr) return rej('invalid name param');
+
+	// Get 'description' parameter
+	const [description, descriptionErr] = $.str.get(params.description);
+	if (descriptionErr) return rej('invalid description param');
+
+	// Get 'permission' parameter
+	const [permission, permissionErr] = $.arr($.str).unique().get(params.permission);
+	if (permissionErr) return rej('invalid permission param');
+
+	// Get 'callbackUrl' parameter
+	// TODO: Check it is valid url
+	const [callbackUrl = null, callbackUrlErr] = $.str.optional().nullable().get(params.callbackUrl);
+	if (callbackUrlErr) return rej('invalid callbackUrl param');
+
+	// Generate secret
+	const secret = rndstr('a-zA-Z0-9', 32);
+
+	// Create account
+	const app = await App.insert({
+		createdAt: new Date(),
+		userId: user._id,
+		name: name,
+		nameId: nameId,
+		nameIdLower: nameId.toLowerCase(),
+		description: description,
+		permission: permission,
+		callbackUrl: callbackUrl,
+		secret: secret
+	});
+
+	// Response
+	res(await pack(app));
+});
diff --git a/src/server/api/endpoints/app/name_id/available.ts b/src/server/api/endpoints/app/name_id/available.ts
new file mode 100644
index 0000000000..135bb7d2b4
--- /dev/null
+++ b/src/server/api/endpoints/app/name_id/available.ts
@@ -0,0 +1,60 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy';
+import App from '../../../../../models/app';
+import { isValidNameId } from '../../../../../models/app';
+
+/**
+ * @swagger
+ * /app/nameId/available:
+ *   note:
+ *     summary: Check available nameId on creation an application
+ *     parameters:
+ *       -
+ *         name: nameId
+ *         description: Application unique name
+ *         in: formData
+ *         required: true
+ *         type: string
+ *
+ *     responses:
+ *       200:
+ *         description: Success
+ *         schema:
+ *           type: object
+ *           properties:
+ *             available:
+ *               description: Whether nameId is available
+ *               type: boolean
+ *
+ *       default:
+ *         description: Failed
+ *         schema:
+ *           $ref: "#/definitions/Error"
+ */
+
+/**
+ * Check available nameId of app
+ *
+ * @param {any} params
+ * @return {Promise<any>}
+ */
+module.exports = async (params) => new Promise(async (res, rej) => {
+	// Get 'nameId' parameter
+	const [nameId, nameIdErr] = $.str.pipe(isValidNameId).get(params.nameId);
+	if (nameIdErr) return rej('invalid nameId param');
+
+	// Get exist
+	const exist = await App
+		.count({
+			nameIdLower: nameId.toLowerCase()
+		}, {
+			limit: 1
+		});
+
+	// Reply
+	res({
+		available: exist === 0
+	});
+});
diff --git a/src/server/api/endpoints/app/show.ts b/src/server/api/endpoints/app/show.ts
new file mode 100644
index 0000000000..8d742ab182
--- /dev/null
+++ b/src/server/api/endpoints/app/show.ts
@@ -0,0 +1,68 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import App, { pack } from '../../../../models/app';
+
+/**
+ * @swagger
+ * /app/show:
+ *   note:
+ *     summary: Show an application's information
+ *     description: Require appId or nameId
+ *     parameters:
+ *       -
+ *         name: appId
+ *         description: Application ID
+ *         in: formData
+ *         type: string
+ *       -
+ *         name: nameId
+ *         description: Application unique name
+ *         in: formData
+ *         type: string
+ *
+ *     responses:
+ *       200:
+ *         description: Success
+ *         schema:
+ *           $ref: "#/definitions/Application"
+ *
+ *       default:
+ *         description: Failed
+ *         schema:
+ *           $ref: "#/definitions/Error"
+ */
+
+/**
+ * Show an app
+ */
+module.exports = (params, user, app) => new Promise(async (res, rej) => {
+	const isSecure = user != null && app == null;
+
+	// Get 'appId' parameter
+	const [appId, appIdErr] = $.type(ID).optional().get(params.appId);
+	if (appIdErr) return rej('invalid appId param');
+
+	// Get 'nameId' parameter
+	const [nameId, nameIdErr] = $.str.optional().get(params.nameId);
+	if (nameIdErr) return rej('invalid nameId param');
+
+	if (appId === undefined && nameId === undefined) {
+		return rej('appId or nameId is required');
+	}
+
+	// Lookup app
+	const ap = appId !== undefined
+		? await App.findOne({ _id: appId })
+		: await App.findOne({ nameIdLower: nameId.toLowerCase() });
+
+	if (ap === null) {
+		return rej('app not found');
+	}
+
+	// Send response
+	res(await pack(ap, user, {
+		includeSecret: isSecure && ap.userId.equals(user._id)
+	}));
+});
diff --git a/src/server/api/endpoints/auth/accept.ts b/src/server/api/endpoints/auth/accept.ts
new file mode 100644
index 0000000000..695fbb0803
--- /dev/null
+++ b/src/server/api/endpoints/auth/accept.ts
@@ -0,0 +1,93 @@
+/**
+ * Module dependencies
+ */
+import rndstr from 'rndstr';
+const crypto = require('crypto');
+import $ from 'cafy';
+import App from '../../../../models/app';
+import AuthSess from '../../../../models/auth-session';
+import AccessToken from '../../../../models/access-token';
+
+/**
+ * @swagger
+ * /auth/accept:
+ *   note:
+ *     summary: Accept a session
+ *     parameters:
+ *       - $ref: "#/parameters/NativeToken"
+ *       -
+ *         name: token
+ *         description: Session Token
+ *         in: formData
+ *         required: true
+ *         type: string
+ *     responses:
+ *       204:
+ *         description: OK
+ *
+ *       default:
+ *         description: Failed
+ *         schema:
+ *           $ref: "#/definitions/Error"
+ */
+
+/**
+ * Accept
+ *
+ * @param {any} params
+ * @param {any} user
+ * @return {Promise<any>}
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'token' parameter
+	const [token, tokenErr] = $.str.get(params.token);
+	if (tokenErr) return rej('invalid token param');
+
+	// Fetch token
+	const session = await AuthSess
+		.findOne({ token: token });
+
+	if (session === null) {
+		return rej('session not found');
+	}
+
+	// Generate access token
+	const accessToken = rndstr('a-zA-Z0-9', 32);
+
+	// Fetch exist access token
+	const exist = await AccessToken.findOne({
+		appId: session.appId,
+		userId: user._id,
+	});
+
+	if (exist === null) {
+		// Lookup app
+		const app = await App.findOne({
+			_id: session.appId
+		});
+
+		// Generate Hash
+		const sha256 = crypto.createHash('sha256');
+		sha256.update(accessToken + app.secret);
+		const hash = sha256.digest('hex');
+
+		// Insert access token doc
+		await AccessToken.insert({
+			createdAt: new Date(),
+			appId: session.appId,
+			userId: user._id,
+			token: accessToken,
+			hash: hash
+		});
+	}
+
+	// Update session
+	await AuthSess.update(session._id, {
+		$set: {
+			userId: user._id
+		}
+	});
+
+	// Response
+	res();
+});
diff --git a/src/server/api/endpoints/auth/session/generate.ts b/src/server/api/endpoints/auth/session/generate.ts
new file mode 100644
index 0000000000..d649a8d902
--- /dev/null
+++ b/src/server/api/endpoints/auth/session/generate.ts
@@ -0,0 +1,76 @@
+/**
+ * Module dependencies
+ */
+import * as uuid from 'uuid';
+import $ from 'cafy';
+import App from '../../../../../models/app';
+import AuthSess from '../../../../../models/auth-session';
+import config from '../../../../../config';
+
+/**
+ * @swagger
+ * /auth/session/generate:
+ *   note:
+ *     summary: Generate a session
+ *     parameters:
+ *       -
+ *         name: appSecret
+ *         description: App Secret
+ *         in: formData
+ *         required: true
+ *         type: string
+ *
+ *     responses:
+ *       200:
+ *         description: OK
+ *         schema:
+ *           type: object
+ *           properties:
+ *             token:
+ *               type: string
+ *               description: Session Token
+ *             url:
+ *               type: string
+ *               description: Authentication form's URL
+ *       default:
+ *         description: Failed
+ *         schema:
+ *           $ref: "#/definitions/Error"
+ */
+
+/**
+ * Generate a session
+ *
+ * @param {any} params
+ * @return {Promise<any>}
+ */
+module.exports = (params) => new Promise(async (res, rej) => {
+	// Get 'appSecret' parameter
+	const [appSecret, appSecretErr] = $.str.get(params.appSecret);
+	if (appSecretErr) return rej('invalid appSecret param');
+
+	// Lookup app
+	const app = await App.findOne({
+		secret: appSecret
+	});
+
+	if (app == null) {
+		return rej('app not found');
+	}
+
+	// Generate token
+	const token = uuid.v4();
+
+	// Create session token document
+	const doc = await AuthSess.insert({
+		createdAt: new Date(),
+		appId: app._id,
+		token: token
+	});
+
+	// Response
+	res({
+		token: doc.token,
+		url: `${config.auth_url}/${doc.token}`
+	});
+});
diff --git a/src/server/api/endpoints/auth/session/show.ts b/src/server/api/endpoints/auth/session/show.ts
new file mode 100644
index 0000000000..434cc264a0
--- /dev/null
+++ b/src/server/api/endpoints/auth/session/show.ts
@@ -0,0 +1,70 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy';
+import AuthSess, { pack } from '../../../../../models/auth-session';
+
+/**
+ * @swagger
+ * /auth/session/show:
+ *   note:
+ *     summary: Show a session information
+ *     parameters:
+ *       -
+ *         name: token
+ *         description: Session Token
+ *         in: formData
+ *         required: true
+ *         type: string
+ *
+ *     responses:
+ *       200:
+ *         description: OK
+ *         schema:
+ *           type: object
+ *           properties:
+ *             createdAt:
+ *               type: string
+ *               format: date-time
+ *               description: Date and time of the session creation
+ *             appId:
+ *               type: string
+ *               description: Application ID
+ *             token:
+ *               type: string
+ *               description: Session Token
+ *             userId:
+ *               type: string
+ *               description: ID of user who create the session
+ *             app:
+ *               $ref: "#/definitions/Application"
+ *       default:
+ *         description: Failed
+ *         schema:
+ *           $ref: "#/definitions/Error"
+ */
+
+/**
+ * Show a session
+ *
+ * @param {any} params
+ * @param {any} user
+ * @return {Promise<any>}
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'token' parameter
+	const [token, tokenErr] = $.str.get(params.token);
+	if (tokenErr) return rej('invalid token param');
+
+	// Lookup session
+	const session = await AuthSess.findOne({
+		token: token
+	});
+
+	if (session == null) {
+		return rej('session not found');
+	}
+
+	// Response
+	res(await pack(session, user));
+});
diff --git a/src/server/api/endpoints/auth/session/userkey.ts b/src/server/api/endpoints/auth/session/userkey.ts
new file mode 100644
index 0000000000..3026b477f1
--- /dev/null
+++ b/src/server/api/endpoints/auth/session/userkey.ts
@@ -0,0 +1,109 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy';
+import App from '../../../../../models/app';
+import AuthSess from '../../../../../models/auth-session';
+import AccessToken from '../../../../../models/access-token';
+import { pack } from '../../../../../models/user';
+
+/**
+ * @swagger
+ * /auth/session/userkey:
+ *   note:
+ *     summary: Get an access token(userkey)
+ *     parameters:
+ *       -
+ *         name: appSecret
+ *         description: App Secret
+ *         in: formData
+ *         required: true
+ *         type: string
+ *       -
+ *         name: token
+ *         description: Session Token
+ *         in: formData
+ *         required: true
+ *         type: string
+ *
+ *     responses:
+ *       200:
+ *         description: OK
+ *         schema:
+ *           type: object
+ *           properties:
+ *             userkey:
+ *               type: string
+ *               description: Access Token
+ *             user:
+ *               $ref: "#/definitions/User"
+ *       default:
+ *         description: Failed
+ *         schema:
+ *           $ref: "#/definitions/Error"
+ */
+
+/**
+ * Generate a session
+ *
+ * @param {any} params
+ * @return {Promise<any>}
+ */
+module.exports = (params) => new Promise(async (res, rej) => {
+	// Get 'appSecret' parameter
+	const [appSecret, appSecretErr] = $.str.get(params.appSecret);
+	if (appSecretErr) return rej('invalid appSecret param');
+
+	// Lookup app
+	const app = await App.findOne({
+		secret: appSecret
+	});
+
+	if (app == null) {
+		return rej('app not found');
+	}
+
+	// Get 'token' parameter
+	const [token, tokenErr] = $.str.get(params.token);
+	if (tokenErr) return rej('invalid token param');
+
+	// Fetch token
+	const session = await AuthSess
+		.findOne({
+			token: token,
+			appId: app._id
+		});
+
+	if (session === null) {
+		return rej('session not found');
+	}
+
+	if (session.userId == null) {
+		return rej('this session is not allowed yet');
+	}
+
+	// Lookup access token
+	const accessToken = await AccessToken.findOne({
+		appId: app._id,
+		userId: session.userId
+	});
+
+	// Delete session
+
+	/* https://github.com/Automattic/monk/issues/178
+	AuthSess.deleteOne({
+		_id: session._id
+	});
+	*/
+	AuthSess.remove({
+		_id: session._id
+	});
+
+	// Response
+	res({
+		accessToken: accessToken.token,
+		user: await pack(session.userId, null, {
+			detail: true
+		})
+	});
+});
diff --git a/src/server/api/endpoints/channels.ts b/src/server/api/endpoints/channels.ts
new file mode 100644
index 0000000000..ceef4b9cb9
--- /dev/null
+++ b/src/server/api/endpoints/channels.ts
@@ -0,0 +1,58 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../cafy-id';
+import Channel, { pack } from '../../../models/channel';
+
+/**
+ * Get all channels
+ *
+ * @param {any} params
+ * @param {any} me
+ * @return {Promise<any>}
+ */
+module.exports = (params, me) => new Promise(async (res, rej) => {
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Get 'sinceId' parameter
+	const [sinceId, sinceIdErr] = $.type(ID).optional().get(params.sinceId);
+	if (sinceIdErr) return rej('invalid sinceId param');
+
+	// Get 'untilId' parameter
+	const [untilId, untilIdErr] = $.type(ID).optional().get(params.untilId);
+	if (untilIdErr) return rej('invalid untilId param');
+
+	// Check if both of sinceId and untilId is specified
+	if (sinceId && untilId) {
+		return rej('cannot set sinceId and untilId');
+	}
+
+	// Construct query
+	const sort = {
+		_id: -1
+	};
+	const query = {} as any;
+	if (sinceId) {
+		sort._id = 1;
+		query._id = {
+			$gt: sinceId
+		};
+	} else if (untilId) {
+		query._id = {
+			$lt: untilId
+		};
+	}
+
+	// Issue query
+	const channels = await Channel
+		.find(query, {
+			limit: limit,
+			sort: sort
+		});
+
+	// Serialize
+	res(await Promise.all(channels.map(async channel =>
+		await pack(channel, me))));
+});
diff --git a/src/server/api/endpoints/channels/create.ts b/src/server/api/endpoints/channels/create.ts
new file mode 100644
index 0000000000..0e3c9dc5ac
--- /dev/null
+++ b/src/server/api/endpoints/channels/create.ts
@@ -0,0 +1,35 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy';
+import Channel from '../../../../models/channel';
+import Watching from '../../../../models/channel-watching';
+import { pack } from '../../../../models/channel';
+
+/**
+ * Create a channel
+ */
+module.exports = async (params, user) => new Promise(async (res, rej) => {
+	// Get 'title' parameter
+	const [title, titleErr] = $.str.range(1, 100).get(params.title);
+	if (titleErr) return rej('invalid title param');
+
+	// Create a channel
+	const channel = await Channel.insert({
+		createdAt: new Date(),
+		userId: user._id,
+		title: title,
+		index: 0,
+		watchingCount: 1
+	});
+
+	// Response
+	res(await pack(channel));
+
+	// Create Watching
+	await Watching.insert({
+		createdAt: new Date(),
+		userId: user._id,
+		channelId: channel._id
+	});
+});
diff --git a/src/server/api/endpoints/channels/notes.ts b/src/server/api/endpoints/channels/notes.ts
new file mode 100644
index 0000000000..463152e74a
--- /dev/null
+++ b/src/server/api/endpoints/channels/notes.ts
@@ -0,0 +1,74 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import { default as Channel, IChannel } from '../../../../models/channel';
+import Note, { pack } from '../../../../models/note';
+
+/**
+ * Show a notes of a channel
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'limit' parameter
+	const [limit = 1000, limitErr] = $.num.optional().range(1, 1000).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Get 'sinceId' parameter
+	const [sinceId, sinceIdErr] = $.type(ID).optional().get(params.sinceId);
+	if (sinceIdErr) return rej('invalid sinceId param');
+
+	// Get 'untilId' parameter
+	const [untilId, untilIdErr] = $.type(ID).optional().get(params.untilId);
+	if (untilIdErr) return rej('invalid untilId param');
+
+	// Check if both of sinceId and untilId is specified
+	if (sinceId && untilId) {
+		return rej('cannot set sinceId and untilId');
+	}
+
+	// Get 'channelId' parameter
+	const [channelId, channelIdErr] = $.type(ID).get(params.channelId);
+	if (channelIdErr) return rej('invalid channelId param');
+
+	// Fetch channel
+	const channel: IChannel = await Channel.findOne({
+		_id: channelId
+	});
+
+	if (channel === null) {
+		return rej('channel not found');
+	}
+
+	//#region Construct query
+	const sort = {
+		_id: -1
+	};
+
+	const query = {
+		channelId: channel._id
+	} as any;
+
+	if (sinceId) {
+		sort._id = 1;
+		query._id = {
+			$gt: sinceId
+		};
+	} else if (untilId) {
+		query._id = {
+			$lt: untilId
+		};
+	}
+	//#endregion Construct query
+
+	// Issue query
+	const notes = await Note
+		.find(query, {
+			limit: limit,
+			sort: sort
+		});
+
+	// Serialize
+	res(await Promise.all(notes.map(async (note) =>
+		await pack(note, user)
+	)));
+});
diff --git a/src/server/api/endpoints/channels/show.ts b/src/server/api/endpoints/channels/show.ts
new file mode 100644
index 0000000000..1bba63d490
--- /dev/null
+++ b/src/server/api/endpoints/channels/show.ts
@@ -0,0 +1,26 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import Channel, { IChannel, pack } from '../../../../models/channel';
+
+/**
+ * Show a channel
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'channelId' parameter
+	const [channelId, channelIdErr] = $.type(ID).get(params.channelId);
+	if (channelIdErr) return rej('invalid channelId param');
+
+	// Fetch channel
+	const channel: IChannel = await Channel.findOne({
+		_id: channelId
+	});
+
+	if (channel === null) {
+		return rej('channel not found');
+	}
+
+	// Serialize
+	res(await pack(channel, user));
+});
diff --git a/src/server/api/endpoints/channels/unwatch.ts b/src/server/api/endpoints/channels/unwatch.ts
new file mode 100644
index 0000000000..f7dddff461
--- /dev/null
+++ b/src/server/api/endpoints/channels/unwatch.ts
@@ -0,0 +1,56 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import Channel from '../../../../models/channel';
+import Watching from '../../../../models/channel-watching';
+
+/**
+ * Unwatch a channel
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'channelId' parameter
+	const [channelId, channelIdErr] = $.type(ID).get(params.channelId);
+	if (channelIdErr) return rej('invalid channelId param');
+
+	//#region Fetch channel
+	const channel = await Channel.findOne({
+		_id: channelId
+	});
+
+	if (channel === null) {
+		return rej('channel not found');
+	}
+	//#endregion
+
+	//#region Check whether not watching
+	const exist = await Watching.findOne({
+		userId: user._id,
+		channelId: channel._id,
+		deletedAt: { $exists: false }
+	});
+
+	if (exist === null) {
+		return rej('already not watching');
+	}
+	//#endregion
+
+	// Delete watching
+	await Watching.update({
+		_id: exist._id
+	}, {
+		$set: {
+			deletedAt: new Date()
+		}
+	});
+
+	// Send response
+	res();
+
+	// Decrement watching count
+	Channel.update(channel._id, {
+		$inc: {
+			watchingCount: -1
+		}
+	});
+});
diff --git a/src/server/api/endpoints/channels/watch.ts b/src/server/api/endpoints/channels/watch.ts
new file mode 100644
index 0000000000..34243ff68b
--- /dev/null
+++ b/src/server/api/endpoints/channels/watch.ts
@@ -0,0 +1,54 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import Channel from '../../../../models/channel';
+import Watching from '../../../../models/channel-watching';
+
+/**
+ * Watch a channel
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'channelId' parameter
+	const [channelId, channelIdErr] = $.type(ID).get(params.channelId);
+	if (channelIdErr) return rej('invalid channelId param');
+
+	//#region Fetch channel
+	const channel = await Channel.findOne({
+		_id: channelId
+	});
+
+	if (channel === null) {
+		return rej('channel not found');
+	}
+	//#endregion
+
+	//#region Check whether already watching
+	const exist = await Watching.findOne({
+		userId: user._id,
+		channelId: channel._id,
+		deletedAt: { $exists: false }
+	});
+
+	if (exist !== null) {
+		return rej('already watching');
+	}
+	//#endregion
+
+	// Create Watching
+	await Watching.insert({
+		createdAt: new Date(),
+		userId: user._id,
+		channelId: channel._id
+	});
+
+	// Send response
+	res();
+
+	// Increment watching count
+	Channel.update(channel._id, {
+		$inc: {
+			watchingCount: 1
+		}
+	});
+});
diff --git a/src/server/api/endpoints/drive.ts b/src/server/api/endpoints/drive.ts
new file mode 100644
index 0000000000..d77ab2bbb0
--- /dev/null
+++ b/src/server/api/endpoints/drive.ts
@@ -0,0 +1,37 @@
+/**
+ * Module dependencies
+ */
+import DriveFile from '../../../models/drive-file';
+
+/**
+ * Get drive information
+ *
+ * @param {any} params
+ * @param {any} user
+ * @return {Promise<any>}
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Calculate drive usage
+	const usage = ((await DriveFile
+		.aggregate([
+			{ $match: { 'metadata.userId': user._id } },
+			{
+				$project: {
+					length: true
+				}
+			},
+			{
+				$group: {
+					_id: null,
+					usage: { $sum: '$length' }
+				}
+			}
+		]))[0] || {
+			usage: 0
+		}).usage;
+
+	res({
+		capacity: user.driveCapacity,
+		usage: usage
+	});
+});
diff --git a/src/server/api/endpoints/drive/files.ts b/src/server/api/endpoints/drive/files.ts
new file mode 100644
index 0000000000..ab4b18cef4
--- /dev/null
+++ b/src/server/api/endpoints/drive/files.ts
@@ -0,0 +1,68 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import DriveFile, { pack } from '../../../../models/drive-file';
+
+/**
+ * Get drive files
+ */
+module.exports = async (params, user, app) => {
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) throw 'invalid limit param';
+
+	// Get 'sinceId' parameter
+	const [sinceId, sinceIdErr] = $.type(ID).optional().get(params.sinceId);
+	if (sinceIdErr) throw 'invalid sinceId param';
+
+	// Get 'untilId' parameter
+	const [untilId, untilIdErr] = $.type(ID).optional().get(params.untilId);
+	if (untilIdErr) throw 'invalid untilId param';
+
+	// Check if both of sinceId and untilId is specified
+	if (sinceId && untilId) {
+		throw 'cannot set sinceId and untilId';
+	}
+
+	// Get 'folderId' parameter
+	const [folderId = null, folderIdErr] = $.type(ID).optional().nullable().get(params.folderId);
+	if (folderIdErr) throw 'invalid folderId param';
+
+	// Get 'type' parameter
+	const [type, typeErr] = $.str.optional().match(/^[a-zA-Z\/\-\*]+$/).get(params.type);
+	if (typeErr) throw 'invalid type param';
+
+	// Construct query
+	const sort = {
+		_id: -1
+	};
+	const query = {
+		'metadata.userId': user._id,
+		'metadata.folderId': folderId
+	} as any;
+	if (sinceId) {
+		sort._id = 1;
+		query._id = {
+			$gt: sinceId
+		};
+	} else if (untilId) {
+		query._id = {
+			$lt: untilId
+		};
+	}
+	if (type) {
+		query.contentType = new RegExp(`^${type.replace(/\*/g, '.+?')}$`);
+	}
+
+	// Issue query
+	const files = await DriveFile
+		.find(query, {
+			limit: limit,
+			sort: sort
+		});
+
+	// Serialize
+	const _files = await Promise.all(files.map(file => pack(file)));
+	return _files;
+};
diff --git a/src/server/api/endpoints/drive/files/create.ts b/src/server/api/endpoints/drive/files/create.ts
new file mode 100644
index 0000000000..e9348e4e2f
--- /dev/null
+++ b/src/server/api/endpoints/drive/files/create.ts
@@ -0,0 +1,46 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../../cafy-id';
+import { validateFileName, pack } from '../../../../../models/drive-file';
+import create from '../../../../../services/drive/add-file';
+
+/**
+ * Create a file
+ */
+module.exports = async (file, params, user): Promise<any> => {
+	if (file == null) {
+		throw 'file is required';
+	}
+
+	// Get 'name' parameter
+	let name = file.originalname;
+	if (name !== undefined && name !== null) {
+		name = name.trim();
+		if (name.length === 0) {
+			name = null;
+		} else if (name === 'blob') {
+			name = null;
+		} else if (!validateFileName(name)) {
+			throw 'invalid name';
+		}
+	} else {
+		name = null;
+	}
+
+	// Get 'folderId' parameter
+	const [folderId = null, folderIdErr] = $.type(ID).optional().nullable().get(params.folderId);
+	if (folderIdErr) throw 'invalid folderId param';
+
+	try {
+		// Create file
+		const driveFile = await create(user, file.path, name, null, folderId);
+
+		// Serialize
+		return pack(driveFile);
+	} catch (e) {
+		console.error(e);
+
+		throw e;
+	}
+};
diff --git a/src/server/api/endpoints/drive/files/find.ts b/src/server/api/endpoints/drive/files/find.ts
new file mode 100644
index 0000000000..98165990fe
--- /dev/null
+++ b/src/server/api/endpoints/drive/files/find.ts
@@ -0,0 +1,30 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../../cafy-id';
+import DriveFile, { pack } from '../../../../../models/drive-file';
+
+/**
+ * Find a file(s)
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'name' parameter
+	const [name, nameErr] = $.str.get(params.name);
+	if (nameErr) return rej('invalid name param');
+
+	// Get 'folderId' parameter
+	const [folderId = null, folderIdErr] = $.type(ID).optional().nullable().get(params.folderId);
+	if (folderIdErr) return rej('invalid folderId param');
+
+	// Issue query
+	const files = await DriveFile
+		.find({
+			filename: name,
+			'metadata.userId': user._id,
+			'metadata.folderId': folderId
+		});
+
+	// Serialize
+	res(await Promise.all(files.map(async file =>
+		await pack(file))));
+});
diff --git a/src/server/api/endpoints/drive/files/show.ts b/src/server/api/endpoints/drive/files/show.ts
new file mode 100644
index 0000000000..c7efda7ab0
--- /dev/null
+++ b/src/server/api/endpoints/drive/files/show.ts
@@ -0,0 +1,32 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../../cafy-id';
+import DriveFile, { pack } from '../../../../../models/drive-file';
+
+/**
+ * Show a file
+ */
+module.exports = async (params, user) => {
+	// Get 'fileId' parameter
+	const [fileId, fileIdErr] = $.type(ID).get(params.fileId);
+	if (fileIdErr) throw 'invalid fileId param';
+
+	// Fetch file
+	const file = await DriveFile
+		.findOne({
+			_id: fileId,
+			'metadata.userId': user._id
+		});
+
+	if (file === null) {
+		throw 'file-not-found';
+	}
+
+	// Serialize
+	const _file = await pack(file, {
+		detail: true
+	});
+
+	return _file;
+};
diff --git a/src/server/api/endpoints/drive/files/update.ts b/src/server/api/endpoints/drive/files/update.ts
new file mode 100644
index 0000000000..12fa8e025d
--- /dev/null
+++ b/src/server/api/endpoints/drive/files/update.ts
@@ -0,0 +1,71 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../../cafy-id';
+import DriveFolder from '../../../../../models/drive-folder';
+import DriveFile, { validateFileName, pack } from '../../../../../models/drive-file';
+import { publishDriveStream } from '../../../../../publishers/stream';
+
+/**
+ * Update a file
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'fileId' parameter
+	const [fileId, fileIdErr] = $.type(ID).get(params.fileId);
+	if (fileIdErr) return rej('invalid fileId param');
+
+	// Fetch file
+	const file = await DriveFile
+		.findOne({
+			_id: fileId,
+			'metadata.userId': user._id
+		});
+
+	if (file === null) {
+		return rej('file-not-found');
+	}
+
+	// Get 'name' parameter
+	const [name, nameErr] = $.str.optional().pipe(validateFileName).get(params.name);
+	if (nameErr) return rej('invalid name param');
+	if (name) file.filename = name;
+
+	// Get 'folderId' parameter
+	const [folderId, folderIdErr] = $.type(ID).optional().nullable().get(params.folderId);
+	if (folderIdErr) return rej('invalid folderId param');
+
+	if (folderId !== undefined) {
+		if (folderId === null) {
+			file.metadata.folderId = null;
+		} else {
+			// Fetch folder
+			const folder = await DriveFolder
+				.findOne({
+					_id: folderId,
+					userId: user._id
+				});
+
+			if (folder === null) {
+				return rej('folder-not-found');
+			}
+
+			file.metadata.folderId = folder._id;
+		}
+	}
+
+	await DriveFile.update(file._id, {
+		$set: {
+			filename: file.filename,
+			'metadata.folderId': file.metadata.folderId
+		}
+	});
+
+	// Serialize
+	const fileObj = await pack(file);
+
+	// Response
+	res(fileObj);
+
+	// Publish file_updated event
+	publishDriveStream(user._id, 'file_updated', fileObj);
+});
diff --git a/src/server/api/endpoints/drive/files/upload_from_url.ts b/src/server/api/endpoints/drive/files/upload_from_url.ts
new file mode 100644
index 0000000000..c012f0d3c9
--- /dev/null
+++ b/src/server/api/endpoints/drive/files/upload_from_url.ts
@@ -0,0 +1,22 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../../cafy-id';
+import { pack } from '../../../../../models/drive-file';
+import uploadFromUrl from '../../../../../services/drive/upload-from-url';
+
+/**
+ * Create a file from a URL
+ */
+module.exports = async (params, user): Promise<any> => {
+	// Get 'url' parameter
+	// TODO: Validate this url
+	const [url, urlErr] = $.str.get(params.url);
+	if (urlErr) throw 'invalid url param';
+
+	// Get 'folderId' parameter
+	const [folderId = null, folderIdErr] = $.type(ID).optional().nullable().get(params.folderId);
+	if (folderIdErr) throw 'invalid folderId param';
+
+	return pack(await uploadFromUrl(url, user, folderId));
+};
diff --git a/src/server/api/endpoints/drive/folders.ts b/src/server/api/endpoints/drive/folders.ts
new file mode 100644
index 0000000000..bc6c50eb99
--- /dev/null
+++ b/src/server/api/endpoints/drive/folders.ts
@@ -0,0 +1,61 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import DriveFolder, { pack } from '../../../../models/drive-folder';
+
+/**
+ * Get drive folders
+ */
+module.exports = (params, user, app) => new Promise(async (res, rej) => {
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Get 'sinceId' parameter
+	const [sinceId, sinceIdErr] = $.type(ID).optional().get(params.sinceId);
+	if (sinceIdErr) return rej('invalid sinceId param');
+
+	// Get 'untilId' parameter
+	const [untilId, untilIdErr] = $.type(ID).optional().get(params.untilId);
+	if (untilIdErr) return rej('invalid untilId param');
+
+	// Check if both of sinceId and untilId is specified
+	if (sinceId && untilId) {
+		return rej('cannot set sinceId and untilId');
+	}
+
+	// Get 'folderId' parameter
+	const [folderId = null, folderIdErr] = $.type(ID).optional().nullable().get(params.folderId);
+	if (folderIdErr) return rej('invalid folderId param');
+
+	// Construct query
+	const sort = {
+		_id: -1
+	};
+	const query = {
+		userId: user._id,
+		parentId: folderId
+	} as any;
+	if (sinceId) {
+		sort._id = 1;
+		query._id = {
+			$gt: sinceId
+		};
+	} else if (untilId) {
+		query._id = {
+			$lt: untilId
+		};
+	}
+
+	// Issue query
+	const folders = await DriveFolder
+		.find(query, {
+			limit: limit,
+			sort: sort
+		});
+
+	// Serialize
+	res(await Promise.all(folders.map(async folder =>
+		await pack(folder))));
+});
diff --git a/src/server/api/endpoints/drive/folders/create.ts b/src/server/api/endpoints/drive/folders/create.ts
new file mode 100644
index 0000000000..62e3b6f6e8
--- /dev/null
+++ b/src/server/api/endpoints/drive/folders/create.ts
@@ -0,0 +1,51 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../../cafy-id';
+import DriveFolder, { isValidFolderName, pack } from '../../../../../models/drive-folder';
+import { publishDriveStream } from '../../../../../publishers/stream';
+
+/**
+ * Create drive folder
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'name' parameter
+	const [name = '無題のフォルダー', nameErr] = $.str.optional().pipe(isValidFolderName).get(params.name);
+	if (nameErr) return rej('invalid name param');
+
+	// Get 'parentId' parameter
+	const [parentId = null, parentIdErr] = $.type(ID).optional().nullable().get(params.parentId);
+	if (parentIdErr) return rej('invalid parentId param');
+
+	// If the parent folder is specified
+	let parent = null;
+	if (parentId) {
+		// Fetch parent folder
+		parent = await DriveFolder
+			.findOne({
+				_id: parentId,
+				userId: user._id
+			});
+
+		if (parent === null) {
+			return rej('parent-not-found');
+		}
+	}
+
+	// Create folder
+	const folder = await DriveFolder.insert({
+		createdAt: new Date(),
+		name: name,
+		parentId: parent !== null ? parent._id : null,
+		userId: user._id
+	});
+
+	// Serialize
+	const folderObj = await pack(folder);
+
+	// Response
+	res(folderObj);
+
+	// Publish folder_created event
+	publishDriveStream(user._id, 'folder_created', folderObj);
+});
diff --git a/src/server/api/endpoints/drive/folders/find.ts b/src/server/api/endpoints/drive/folders/find.ts
new file mode 100644
index 0000000000..9703d9e99d
--- /dev/null
+++ b/src/server/api/endpoints/drive/folders/find.ts
@@ -0,0 +1,29 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../../cafy-id';
+import DriveFolder, { pack } from '../../../../../models/drive-folder';
+
+/**
+ * Find a folder(s)
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'name' parameter
+	const [name, nameErr] = $.str.get(params.name);
+	if (nameErr) return rej('invalid name param');
+
+	// Get 'parentId' parameter
+	const [parentId = null, parentIdErr] = $.type(ID).optional().nullable().get(params.parentId);
+	if (parentIdErr) return rej('invalid parentId param');
+
+	// Issue query
+	const folders = await DriveFolder
+		.find({
+			name: name,
+			userId: user._id,
+			parentId: parentId
+		});
+
+	// Serialize
+	res(await Promise.all(folders.map(folder => pack(folder))));
+});
diff --git a/src/server/api/endpoints/drive/folders/show.ts b/src/server/api/endpoints/drive/folders/show.ts
new file mode 100644
index 0000000000..44f1889001
--- /dev/null
+++ b/src/server/api/endpoints/drive/folders/show.ts
@@ -0,0 +1,30 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../../cafy-id';
+import DriveFolder, { pack } from '../../../../../models/drive-folder';
+
+/**
+ * Show a folder
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'folderId' parameter
+	const [folderId, folderIdErr] = $.type(ID).get(params.folderId);
+	if (folderIdErr) return rej('invalid folderId param');
+
+	// Get folder
+	const folder = await DriveFolder
+		.findOne({
+			_id: folderId,
+			userId: user._id
+		});
+
+	if (folder === null) {
+		return rej('folder-not-found');
+	}
+
+	// Serialize
+	res(await pack(folder, {
+		detail: true
+	}));
+});
diff --git a/src/server/api/endpoints/drive/folders/update.ts b/src/server/api/endpoints/drive/folders/update.ts
new file mode 100644
index 0000000000..e24d8a14cd
--- /dev/null
+++ b/src/server/api/endpoints/drive/folders/update.ts
@@ -0,0 +1,95 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../../cafy-id';
+import DriveFolder, { isValidFolderName, pack } from '../../../../../models/drive-folder';
+import { publishDriveStream } from '../../../../../publishers/stream';
+
+/**
+ * Update a folder
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'folderId' parameter
+	const [folderId, folderIdErr] = $.type(ID).get(params.folderId);
+	if (folderIdErr) return rej('invalid folderId param');
+
+	// Fetch folder
+	const folder = await DriveFolder
+		.findOne({
+			_id: folderId,
+			userId: user._id
+		});
+
+	if (folder === null) {
+		return rej('folder-not-found');
+	}
+
+	// Get 'name' parameter
+	const [name, nameErr] = $.str.optional().pipe(isValidFolderName).get(params.name);
+	if (nameErr) return rej('invalid name param');
+	if (name) folder.name = name;
+
+	// Get 'parentId' parameter
+	const [parentId, parentIdErr] = $.type(ID).optional().nullable().get(params.parentId);
+	if (parentIdErr) return rej('invalid parentId param');
+	if (parentId !== undefined) {
+		if (parentId === null) {
+			folder.parentId = null;
+		} else {
+			// Get parent folder
+			const parent = await DriveFolder
+				.findOne({
+					_id: parentId,
+					userId: user._id
+				});
+
+			if (parent === null) {
+				return rej('parent-folder-not-found');
+			}
+
+			// Check if the circular reference will occur
+			async function checkCircle(folderId) {
+				// Fetch folder
+				const folder2 = await DriveFolder.findOne({
+					_id: folderId
+				}, {
+					_id: true,
+					parentId: true
+				});
+
+				if (folder2._id.equals(folder._id)) {
+					return true;
+				} else if (folder2.parentId) {
+					return await checkCircle(folder2.parentId);
+				} else {
+					return false;
+				}
+			}
+
+			if (parent.parentId !== null) {
+				if (await checkCircle(parent.parentId)) {
+					return rej('detected-circular-definition');
+				}
+			}
+
+			folder.parentId = parent._id;
+		}
+	}
+
+	// Update
+	DriveFolder.update(folder._id, {
+		$set: {
+			name: folder.name,
+			parentId: folder.parentId
+		}
+	});
+
+	// Serialize
+	const folderObj = await pack(folder);
+
+	// Response
+	res(folderObj);
+
+	// Publish folder_updated event
+	publishDriveStream(user._id, 'folder_updated', folderObj);
+});
diff --git a/src/server/api/endpoints/drive/stream.ts b/src/server/api/endpoints/drive/stream.ts
new file mode 100644
index 0000000000..8cb3a99b42
--- /dev/null
+++ b/src/server/api/endpoints/drive/stream.ts
@@ -0,0 +1,63 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import DriveFile, { pack } from '../../../../models/drive-file';
+
+/**
+ * Get drive stream
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Get 'sinceId' parameter
+	const [sinceId, sinceIdErr] = $.type(ID).optional().get(params.sinceId);
+	if (sinceIdErr) return rej('invalid sinceId param');
+
+	// Get 'untilId' parameter
+	const [untilId, untilIdErr] = $.type(ID).optional().get(params.untilId);
+	if (untilIdErr) return rej('invalid untilId param');
+
+	// Check if both of sinceId and untilId is specified
+	if (sinceId && untilId) {
+		return rej('cannot set sinceId and untilId');
+	}
+
+	// Get 'type' parameter
+	const [type, typeErr] = $.str.optional().match(/^[a-zA-Z\/\-\*]+$/).get(params.type);
+	if (typeErr) return rej('invalid type param');
+
+	// Construct query
+	const sort = {
+		_id: -1
+	};
+	const query = {
+		'metadata.userId': user._id
+	} as any;
+	if (sinceId) {
+		sort._id = 1;
+		query._id = {
+			$gt: sinceId
+		};
+	} else if (untilId) {
+		query._id = {
+			$lt: untilId
+		};
+	}
+	if (type) {
+		query.contentType = new RegExp(`^${type.replace(/\*/g, '.+?')}$`);
+	}
+
+	// Issue query
+	const files = await DriveFile
+		.find(query, {
+			limit: limit,
+			sort: sort
+		});
+
+	// Serialize
+	res(await Promise.all(files.map(async file =>
+		await pack(file))));
+});
diff --git a/src/server/api/endpoints/following/create.ts b/src/server/api/endpoints/following/create.ts
new file mode 100644
index 0000000000..766a8c03d0
--- /dev/null
+++ b/src/server/api/endpoints/following/create.ts
@@ -0,0 +1,53 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import User from '../../../../models/user';
+import Following from '../../../../models/following';
+import create from '../../../../services/following/create';
+
+/**
+ * Follow a user
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	const follower = user;
+
+	// Get 'userId' parameter
+	const [userId, userIdErr] = $.type(ID).get(params.userId);
+	if (userIdErr) return rej('invalid userId param');
+
+	// 自分自身
+	if (user._id.equals(userId)) {
+		return rej('followee is yourself');
+	}
+
+	// Get followee
+	const followee = await User.findOne({
+		_id: userId
+	}, {
+		fields: {
+			data: false,
+			profile: false
+		}
+	});
+
+	if (followee === null) {
+		return rej('user not found');
+	}
+
+	// Check if already following
+	const exist = await Following.findOne({
+		followerId: follower._id,
+		followeeId: followee._id
+	});
+
+	if (exist !== null) {
+		return rej('already following');
+	}
+
+	// Create following
+	create(follower, followee);
+
+	// Send response
+	res();
+});
diff --git a/src/server/api/endpoints/following/delete.ts b/src/server/api/endpoints/following/delete.ts
new file mode 100644
index 0000000000..396b19a6f6
--- /dev/null
+++ b/src/server/api/endpoints/following/delete.ts
@@ -0,0 +1,53 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import User from '../../../../models/user';
+import Following from '../../../../models/following';
+import deleteFollowing from '../../../../services/following/delete';
+
+/**
+ * Unfollow a user
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	const follower = user;
+
+	// Get 'userId' parameter
+	const [userId, userIdErr] = $.type(ID).get(params.userId);
+	if (userIdErr) return rej('invalid userId param');
+
+	// Check if the followee is yourself
+	if (user._id.equals(userId)) {
+		return rej('followee is yourself');
+	}
+
+	// Get followee
+	const followee = await User.findOne({
+		_id: userId
+	}, {
+		fields: {
+			data: false,
+			'profile': false
+		}
+	});
+
+	if (followee === null) {
+		return rej('user not found');
+	}
+
+	// Check not following
+	const exist = await Following.findOne({
+		followerId: follower._id,
+		followeeId: followee._id
+	});
+
+	if (exist === null) {
+		return rej('already not following');
+	}
+
+	// Delete following
+	deleteFollowing(follower, followee);
+
+	// Send response
+	res();
+});
diff --git a/src/server/api/endpoints/following/stalk.ts b/src/server/api/endpoints/following/stalk.ts
new file mode 100644
index 0000000000..f0bc8cbdfc
--- /dev/null
+++ b/src/server/api/endpoints/following/stalk.ts
@@ -0,0 +1,35 @@
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import Following from '../../../../models/following';
+
+/**
+ * Stalk a user
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	const follower = user;
+
+	// Get 'userId' parameter
+	const [userId, userIdErr] = $.type(ID).get(params.userId);
+	if (userIdErr) return rej('invalid userId param');
+
+	// Fetch following
+	const following = await Following.findOne({
+		followerId: follower._id,
+		followeeId: userId
+	});
+
+	if (following === null) {
+		return rej('following not found');
+	}
+
+	// Stalk
+	await Following.update({ _id: following._id }, {
+		$set: {
+			stalk: true
+		}
+	});
+
+	// Send response
+	res();
+
+	// TODO: イベント
+});
diff --git a/src/server/api/endpoints/following/unstalk.ts b/src/server/api/endpoints/following/unstalk.ts
new file mode 100644
index 0000000000..0d0a018c34
--- /dev/null
+++ b/src/server/api/endpoints/following/unstalk.ts
@@ -0,0 +1,35 @@
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import Following from '../../../../models/following';
+
+/**
+ * Unstalk a user
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	const follower = user;
+
+	// Get 'userId' parameter
+	const [userId, userIdErr] = $.type(ID).get(params.userId);
+	if (userIdErr) return rej('invalid userId param');
+
+	// Fetch following
+	const following = await Following.findOne({
+		followerId: follower._id,
+		followeeId: userId
+	});
+
+	if (following === null) {
+		return rej('following not found');
+	}
+
+	// Stalk
+	await Following.update({ _id: following._id }, {
+		$set: {
+			stalk: false
+		}
+	});
+
+	// Send response
+	res();
+
+	// TODO: イベント
+});
diff --git a/src/server/api/endpoints/i.ts b/src/server/api/endpoints/i.ts
new file mode 100644
index 0000000000..379c3c4d88
--- /dev/null
+++ b/src/server/api/endpoints/i.ts
@@ -0,0 +1,24 @@
+/**
+ * Module dependencies
+ */
+import User, { pack } from '../../../models/user';
+
+/**
+ * Show myself
+ */
+module.exports = (params, user, app) => new Promise(async (res, rej) => {
+	const isSecure = user != null && app == null;
+
+	// Serialize
+	res(await pack(user, user, {
+		detail: true,
+		includeSecrets: isSecure
+	}));
+
+	// Update lastUsedAt
+	User.update({ _id: user._id }, {
+		$set: {
+			lastUsedAt: new Date()
+		}
+	});
+});
diff --git a/src/server/api/endpoints/i/2fa/done.ts b/src/server/api/endpoints/i/2fa/done.ts
new file mode 100644
index 0000000000..1a2706aa84
--- /dev/null
+++ b/src/server/api/endpoints/i/2fa/done.ts
@@ -0,0 +1,37 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy';
+import * as speakeasy from 'speakeasy';
+import User from '../../../../../models/user';
+
+module.exports = async (params, user) => new Promise(async (res, rej) => {
+	// Get 'token' parameter
+	const [token, tokenErr] = $.str.get(params.token);
+	if (tokenErr) return rej('invalid token param');
+
+	const _token = token.replace(/\s/g, '');
+
+	if (user.twoFactorTempSecret == null) {
+		return rej('二段階認証の設定が開始されていません');
+	}
+
+	const verified = (speakeasy as any).totp.verify({
+		secret: user.twoFactorTempSecret,
+		encoding: 'base32',
+		token: _token
+	});
+
+	if (!verified) {
+		return rej('not verified');
+	}
+
+	await User.update(user._id, {
+		$set: {
+			'twoFactorSecret': user.twoFactorTempSecret,
+			'twoFactorEnabled': true
+		}
+	});
+
+	res();
+});
diff --git a/src/server/api/endpoints/i/2fa/register.ts b/src/server/api/endpoints/i/2fa/register.ts
new file mode 100644
index 0000000000..d314e1a280
--- /dev/null
+++ b/src/server/api/endpoints/i/2fa/register.ts
@@ -0,0 +1,48 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy';
+import * as bcrypt from 'bcryptjs';
+import * as speakeasy from 'speakeasy';
+import * as QRCode from 'qrcode';
+import User from '../../../../../models/user';
+import config from '../../../../../config';
+
+module.exports = async (params, user) => new Promise(async (res, rej) => {
+	// Get 'password' parameter
+	const [password, passwordErr] = $.str.get(params.password);
+	if (passwordErr) return rej('invalid password param');
+
+	// Compare password
+	const same = await bcrypt.compare(password, user.password);
+
+	if (!same) {
+		return rej('incorrect password');
+	}
+
+	// Generate user's secret key
+	const secret = speakeasy.generateSecret({
+		length: 32
+	});
+
+	await User.update(user._id, {
+		$set: {
+			twoFactorTempSecret: secret.base32
+		}
+	});
+
+	// Get the data URL of the authenticator URL
+	QRCode.toDataURL(speakeasy.otpauthURL({
+		secret: secret.base32,
+		encoding: 'base32',
+		label: user.username,
+		issuer: config.host
+	}), (err, data_url) => {
+		res({
+			qr: data_url,
+			secret: secret.base32,
+			label: user.username,
+			issuer: config.host
+		});
+	});
+});
diff --git a/src/server/api/endpoints/i/2fa/unregister.ts b/src/server/api/endpoints/i/2fa/unregister.ts
new file mode 100644
index 0000000000..336a3564ab
--- /dev/null
+++ b/src/server/api/endpoints/i/2fa/unregister.ts
@@ -0,0 +1,28 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy';
+import * as bcrypt from 'bcryptjs';
+import User from '../../../../../models/user';
+
+module.exports = async (params, user) => new Promise(async (res, rej) => {
+	// Get 'password' parameter
+	const [password, passwordErr] = $.str.get(params.password);
+	if (passwordErr) return rej('invalid password param');
+
+	// Compare password
+	const same = await bcrypt.compare(password, user.password);
+
+	if (!same) {
+		return rej('incorrect password');
+	}
+
+	await User.update(user._id, {
+		$set: {
+			'twoFactorSecret': null,
+			'twoFactorEnabled': false
+		}
+	});
+
+	res();
+});
diff --git a/src/server/api/endpoints/i/authorized_apps.ts b/src/server/api/endpoints/i/authorized_apps.ts
new file mode 100644
index 0000000000..d15bd67bf2
--- /dev/null
+++ b/src/server/api/endpoints/i/authorized_apps.ts
@@ -0,0 +1,39 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy';
+import AccessToken from '../../../../models/access-token';
+import { pack } from '../../../../models/app';
+
+/**
+ * Get authorized apps of my account
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Get 'offset' parameter
+	const [offset = 0, offsetErr] = $.num.optional().min(0).get(params.offset);
+	if (offsetErr) return rej('invalid offset param');
+
+	// Get 'sort' parameter
+	const [sort = 'desc', sortError] = $.str.optional().or('desc asc').get(params.sort);
+	if (sortError) return rej('invalid sort param');
+
+	// Get tokens
+	const tokens = await AccessToken
+		.find({
+			userId: user._id
+		}, {
+			limit: limit,
+			skip: offset,
+			sort: {
+				_id: sort == 'asc' ? 1 : -1
+			}
+		});
+
+	// Serialize
+	res(await Promise.all(tokens.map(async token =>
+		await pack(token.appId))));
+});
diff --git a/src/server/api/endpoints/i/change_password.ts b/src/server/api/endpoints/i/change_password.ts
new file mode 100644
index 0000000000..a1a1a43406
--- /dev/null
+++ b/src/server/api/endpoints/i/change_password.ts
@@ -0,0 +1,38 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy';
+import * as bcrypt from 'bcryptjs';
+import User from '../../../../models/user';
+
+/**
+ * Change password
+ */
+module.exports = async (params, user) => new Promise(async (res, rej) => {
+	// Get 'currentPasword' parameter
+	const [currentPassword, currentPasswordErr] = $.str.get(params.currentPasword);
+	if (currentPasswordErr) return rej('invalid currentPasword param');
+
+	// Get 'newPassword' parameter
+	const [newPassword, newPasswordErr] = $.str.get(params.newPassword);
+	if (newPasswordErr) return rej('invalid newPassword param');
+
+	// Compare password
+	const same = await bcrypt.compare(currentPassword, user.password);
+
+	if (!same) {
+		return rej('incorrect password');
+	}
+
+	// Generate hash of password
+	const salt = await bcrypt.genSalt(8);
+	const hash = await bcrypt.hash(newPassword, salt);
+
+	await User.update(user._id, {
+		$set: {
+			'password': hash
+		}
+	});
+
+	res();
+});
diff --git a/src/server/api/endpoints/i/favorites.ts b/src/server/api/endpoints/i/favorites.ts
new file mode 100644
index 0000000000..23517baaff
--- /dev/null
+++ b/src/server/api/endpoints/i/favorites.ts
@@ -0,0 +1,53 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import Favorite, { pack } from '../../../../models/favorite';
+
+/**
+ * Get favorited notes
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Get 'sinceId' parameter
+	const [sinceId, sinceIdErr] = $.type(ID).optional().get(params.sinceId);
+	if (sinceIdErr) return rej('invalid sinceId param');
+
+	// Get 'untilId' parameter
+	const [untilId, untilIdErr] = $.type(ID).optional().get(params.untilId);
+	if (untilIdErr) return rej('invalid untilId param');
+
+	// Check if both of sinceId and untilId is specified
+	if (sinceId && untilId) {
+		return rej('cannot set sinceId and untilId');
+	}
+
+	const query = {
+		userId: user._id
+	} as any;
+
+	const sort = {
+		_id: -1
+	};
+
+	if (sinceId) {
+		sort._id = 1;
+		query._id = {
+			$gt: sinceId
+		};
+	} else if (untilId) {
+		query._id = {
+			$lt: untilId
+		};
+	}
+
+	// Get favorites
+	const favorites = await Favorite
+		.find(query, { limit, sort });
+
+	// Serialize
+	res(await Promise.all(favorites.map(favorite => pack(favorite, user))));
+});
diff --git a/src/server/api/endpoints/i/notifications.ts b/src/server/api/endpoints/i/notifications.ts
new file mode 100644
index 0000000000..50ed9b27e8
--- /dev/null
+++ b/src/server/api/endpoints/i/notifications.ts
@@ -0,0 +1,106 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import Notification from '../../../../models/notification';
+import Mute from '../../../../models/mute';
+import { pack } from '../../../../models/notification';
+import { getFriendIds } from '../../common/get-friends';
+import read from '../../common/read-notification';
+
+/**
+ * Get notifications
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'following' parameter
+	const [following = false, followingError] =
+		$.bool.optional().get(params.following);
+	if (followingError) return rej('invalid following param');
+
+	// Get 'markAsRead' parameter
+	const [markAsRead = true, markAsReadErr] = $.bool.optional().get(params.markAsRead);
+	if (markAsReadErr) return rej('invalid markAsRead param');
+
+	// Get 'type' parameter
+	const [type, typeErr] = $.arr($.str).optional().unique().get(params.type);
+	if (typeErr) return rej('invalid type param');
+
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Get 'sinceId' parameter
+	const [sinceId, sinceIdErr] = $.type(ID).optional().get(params.sinceId);
+	if (sinceIdErr) return rej('invalid sinceId param');
+
+	// Get 'untilId' parameter
+	const [untilId, untilIdErr] = $.type(ID).optional().get(params.untilId);
+	if (untilIdErr) return rej('invalid untilId param');
+
+	// Check if both of sinceId and untilId is specified
+	if (sinceId && untilId) {
+		return rej('cannot set sinceId and untilId');
+	}
+
+	const mute = await Mute.find({
+		muterId: user._id,
+		deletedAt: { $exists: false }
+	});
+
+	const query = {
+		notifieeId: user._id,
+		$and: [{
+			notifierId: {
+				$nin: mute.map(m => m.muteeId)
+			}
+		}]
+	} as any;
+
+	const sort = {
+		_id: -1
+	};
+
+	if (following) {
+		// ID list of the user itself and other users who the user follows
+		const followingIds = await getFriendIds(user._id);
+
+		query.$and.push({
+			notifierId: {
+				$in: followingIds
+			}
+		});
+	}
+
+	if (type) {
+		query.type = {
+			$in: type
+		};
+	}
+
+	if (sinceId) {
+		sort._id = 1;
+		query._id = {
+			$gt: sinceId
+		};
+	} else if (untilId) {
+		query._id = {
+			$lt: untilId
+		};
+	}
+
+	// Issue query
+	const notifications = await Notification
+		.find(query, {
+			limit: limit,
+			sort: sort
+		});
+
+	// Serialize
+	res(await Promise.all(notifications.map(async notification =>
+		await pack(notification))));
+
+	// Mark as read all
+	if (notifications.length > 0 && markAsRead) {
+		read(user._id, notifications);
+	}
+});
diff --git a/src/server/api/endpoints/i/pin.ts b/src/server/api/endpoints/i/pin.ts
new file mode 100644
index 0000000000..423f0ac4ae
--- /dev/null
+++ b/src/server/api/endpoints/i/pin.ts
@@ -0,0 +1,40 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import User from '../../../../models/user';
+import Note from '../../../../models/note';
+import { pack } from '../../../../models/user';
+
+/**
+ * Pin note
+ */
+module.exports = async (params, user) => new Promise(async (res, rej) => {
+	// Get 'noteId' parameter
+	const [noteId, noteIdErr] = $.type(ID).get(params.noteId);
+	if (noteIdErr) return rej('invalid noteId param');
+
+	// Fetch pinee
+	const note = await Note.findOne({
+		_id: noteId,
+		userId: user._id
+	});
+
+	if (note === null) {
+		return rej('note not found');
+	}
+
+	await User.update(user._id, {
+		$set: {
+			pinnedNoteId: note._id
+		}
+	});
+
+	// Serialize
+	const iObj = await pack(user, user, {
+		detail: true
+	});
+
+	// Send response
+	res(iObj);
+});
diff --git a/src/server/api/endpoints/i/regenerate_token.ts b/src/server/api/endpoints/i/regenerate_token.ts
new file mode 100644
index 0000000000..6e1e571297
--- /dev/null
+++ b/src/server/api/endpoints/i/regenerate_token.ts
@@ -0,0 +1,38 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy';
+import * as bcrypt from 'bcryptjs';
+import User from '../../../../models/user';
+import event from '../../../../publishers/stream';
+import generateUserToken from '../../common/generate-native-user-token';
+
+/**
+ * Regenerate native token
+ */
+module.exports = async (params, user) => new Promise(async (res, rej) => {
+	// Get 'password' parameter
+	const [password, passwordErr] = $.str.get(params.password);
+	if (passwordErr) return rej('invalid password param');
+
+	// Compare password
+	const same = await bcrypt.compare(password, user.password);
+
+	if (!same) {
+		return rej('incorrect password');
+	}
+
+	// Generate secret
+	const secret = generateUserToken();
+
+	await User.update(user._id, {
+		$set: {
+			'token': secret
+		}
+	});
+
+	res();
+
+	// Publish event
+	event(user._id, 'my_token_regenerated');
+});
diff --git a/src/server/api/endpoints/i/signin_history.ts b/src/server/api/endpoints/i/signin_history.ts
new file mode 100644
index 0000000000..63a74b41b1
--- /dev/null
+++ b/src/server/api/endpoints/i/signin_history.ts
@@ -0,0 +1,57 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import Signin, { pack } from '../../../../models/signin';
+
+/**
+ * Get signin history of my account
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Get 'sinceId' parameter
+	const [sinceId, sinceIdErr] = $.type(ID).optional().get(params.sinceId);
+	if (sinceIdErr) return rej('invalid sinceId param');
+
+	// Get 'untilId' parameter
+	const [untilId, untilIdErr] = $.type(ID).optional().get(params.untilId);
+	if (untilIdErr) return rej('invalid untilId param');
+
+	// Check if both of sinceId and untilId is specified
+	if (sinceId && untilId) {
+		return rej('cannot set sinceId and untilId');
+	}
+
+	const query = {
+		userId: user._id
+	} as any;
+
+	const sort = {
+		_id: -1
+	};
+
+	if (sinceId) {
+		sort._id = 1;
+		query._id = {
+			$gt: sinceId
+		};
+	} else if (untilId) {
+		query._id = {
+			$lt: untilId
+		};
+	}
+
+	// Issue query
+	const history = await Signin
+		.find(query, {
+			limit: limit,
+			sort: sort
+		});
+
+	// Serialize
+	res(await Promise.all(history.map(async record =>
+		await pack(record))));
+});
diff --git a/src/server/api/endpoints/i/update.ts b/src/server/api/endpoints/i/update.ts
new file mode 100644
index 0000000000..6ba4729951
--- /dev/null
+++ b/src/server/api/endpoints/i/update.ts
@@ -0,0 +1,77 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import User, { isValidName, isValidDescription, isValidLocation, isValidBirthday, pack } from '../../../../models/user';
+import event from '../../../../publishers/stream';
+
+/**
+ * Update myself
+ */
+module.exports = async (params, user, app) => new Promise(async (res, rej) => {
+	const isSecure = user != null && app == null;
+
+	// Get 'name' parameter
+	const [name, nameErr] = $.str.optional().nullable().pipe(isValidName).get(params.name);
+	if (nameErr) return rej('invalid name param');
+	if (name) user.name = name;
+
+	// Get 'description' parameter
+	const [description, descriptionErr] = $.str.optional().nullable().pipe(isValidDescription).get(params.description);
+	if (descriptionErr) return rej('invalid description param');
+	if (description !== undefined) user.description = description;
+
+	// Get 'location' parameter
+	const [location, locationErr] = $.str.optional().nullable().pipe(isValidLocation).get(params.location);
+	if (locationErr) return rej('invalid location param');
+	if (location !== undefined) user.profile.location = location;
+
+	// Get 'birthday' parameter
+	const [birthday, birthdayErr] = $.str.optional().nullable().pipe(isValidBirthday).get(params.birthday);
+	if (birthdayErr) return rej('invalid birthday param');
+	if (birthday !== undefined) user.profile.birthday = birthday;
+
+	// Get 'avatarId' parameter
+	const [avatarId, avatarIdErr] = $.type(ID).optional().get(params.avatarId);
+	if (avatarIdErr) return rej('invalid avatarId param');
+	if (avatarId) user.avatarId = avatarId;
+
+	// Get 'bannerId' parameter
+	const [bannerId, bannerIdErr] = $.type(ID).optional().get(params.bannerId);
+	if (bannerIdErr) return rej('invalid bannerId param');
+	if (bannerId) user.bannerId = bannerId;
+
+	// Get 'isBot' parameter
+	const [isBot, isBotErr] = $.bool.optional().get(params.isBot);
+	if (isBotErr) return rej('invalid isBot param');
+	if (isBot != null) user.isBot = isBot;
+
+	// Get 'autoWatch' parameter
+	const [autoWatch, autoWatchErr] = $.bool.optional().get(params.autoWatch);
+	if (autoWatchErr) return rej('invalid autoWatch param');
+	if (autoWatch != null) user.settings.autoWatch = autoWatch;
+
+	await User.update(user._id, {
+		$set: {
+			name: user.name,
+			description: user.description,
+			avatarId: user.avatarId,
+			bannerId: user.bannerId,
+			profile: user.profile,
+			isBot: user.isBot,
+			settings: user.settings
+		}
+	});
+
+	// Serialize
+	const iObj = await pack(user, user, {
+		detail: true,
+		includeSecrets: isSecure
+	});
+
+	// Send response
+	res(iObj);
+
+	// Publish i updated event
+	event(user._id, 'i_updated', iObj);
+});
diff --git a/src/server/api/endpoints/i/update_client_setting.ts b/src/server/api/endpoints/i/update_client_setting.ts
new file mode 100644
index 0000000000..e91d7565fd
--- /dev/null
+++ b/src/server/api/endpoints/i/update_client_setting.ts
@@ -0,0 +1,34 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy';
+import User from '../../../../models/user';
+import event from '../../../../publishers/stream';
+
+/**
+ * Update myself
+ */
+module.exports = async (params, user) => new Promise(async (res, rej) => {
+	// Get 'name' parameter
+	const [name, nameErr] = $.str.get(params.name);
+	if (nameErr) return rej('invalid name param');
+
+	// Get 'value' parameter
+	const [value, valueErr] = $.any.nullable().get(params.value);
+	if (valueErr) return rej('invalid value param');
+
+	const x = {};
+	x[`clientSettings.${name}`] = value;
+
+	await User.update(user._id, {
+		$set: x
+	});
+
+	res();
+
+	// Publish event
+	event(user._id, 'clientSettingUpdated', {
+		key: name,
+		value
+	});
+});
diff --git a/src/server/api/endpoints/i/update_home.ts b/src/server/api/endpoints/i/update_home.ts
new file mode 100644
index 0000000000..8ce551957e
--- /dev/null
+++ b/src/server/api/endpoints/i/update_home.ts
@@ -0,0 +1,62 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy';
+import User from '../../../../models/user';
+import event from '../../../../publishers/stream';
+
+module.exports = async (params, user) => new Promise(async (res, rej) => {
+	// Get 'home' parameter
+	const [home, homeErr] = $.arr(
+		$.obj.strict()
+			.have('name', $.str)
+			.have('id', $.str)
+			.have('place', $.str)
+			.have('data', $.obj))
+		.optional()
+		.get(params.home);
+	if (homeErr) return rej('invalid home param');
+
+	// Get 'id' parameter
+	const [id, idErr] = $.str.optional().get(params.id);
+	if (idErr) return rej('invalid id param');
+
+	// Get 'data' parameter
+	const [data, dataErr] = $.obj.optional().get(params.data);
+	if (dataErr) return rej('invalid data param');
+
+	if (home) {
+		await User.update(user._id, {
+			$set: {
+				'clientSettings.home': home
+			}
+		});
+
+		res();
+
+		event(user._id, 'home_updated', {
+			home
+		});
+	} else {
+		if (id == null && data == null) return rej('you need to set id and data params if home param unset');
+
+		const _home = user.clientSettings.home;
+		const widget = _home.find(w => w.id == id);
+
+		if (widget == null) return rej('widget not found');
+
+		widget.data = data;
+
+		await User.update(user._id, {
+			$set: {
+				'clientSettings.home': _home
+			}
+		});
+
+		res();
+
+		event(user._id, 'home_updated', {
+			id, data
+		});
+	}
+});
diff --git a/src/server/api/endpoints/i/update_mobile_home.ts b/src/server/api/endpoints/i/update_mobile_home.ts
new file mode 100644
index 0000000000..d79a77072b
--- /dev/null
+++ b/src/server/api/endpoints/i/update_mobile_home.ts
@@ -0,0 +1,60 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy';
+import User from '../../../../models/user';
+import event from '../../../../publishers/stream';
+
+module.exports = async (params, user) => new Promise(async (res, rej) => {
+	// Get 'home' parameter
+	const [home, homeErr] = $.arr(
+		$.obj.strict()
+			.have('name', $.str)
+			.have('id', $.str)
+			.have('data', $.obj))
+		.optional().get(params.home);
+	if (homeErr) return rej('invalid home param');
+
+	// Get 'id' parameter
+	const [id, idErr] = $.str.optional().get(params.id);
+	if (idErr) return rej('invalid id param');
+
+	// Get 'data' parameter
+	const [data, dataErr] = $.obj.optional().get(params.data);
+	if (dataErr) return rej('invalid data param');
+
+	if (home) {
+		await User.update(user._id, {
+			$set: {
+				'clientSettings.mobileHome': home
+			}
+		});
+
+		res();
+
+		event(user._id, 'mobile_home_updated', {
+			home
+		});
+	} else {
+		if (id == null && data == null) return rej('you need to set id and data params if home param unset');
+
+		const _home = user.clientSettings.mobileHome || [];
+		const widget = _home.find(w => w.id == id);
+
+		if (widget == null) return rej('widget not found');
+
+		widget.data = data;
+
+		await User.update(user._id, {
+			$set: {
+				'clientSettings.mobileHome': _home
+			}
+		});
+
+		res();
+
+		event(user._id, 'mobile_home_updated', {
+			id, data
+		});
+	}
+});
diff --git a/src/server/api/endpoints/messaging/history.ts b/src/server/api/endpoints/messaging/history.ts
new file mode 100644
index 0000000000..ec97642f17
--- /dev/null
+++ b/src/server/api/endpoints/messaging/history.ts
@@ -0,0 +1,39 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy';
+import History from '../../../../models/messaging-history';
+import Mute from '../../../../models/mute';
+import { pack } from '../../../../models/messaging-message';
+
+/**
+ * Show messaging history
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	const mute = await Mute.find({
+		muterId: user._id,
+		deletedAt: { $exists: false }
+	});
+
+	// Get history
+	const history = await History
+		.find({
+			userId: user._id,
+			partnerId: {
+				$nin: mute.map(m => m.muteeId)
+			}
+		}, {
+			limit: limit,
+			sort: {
+				updatedAt: -1
+			}
+		});
+
+	// Serialize
+	res(await Promise.all(history.map(async h =>
+		await pack(h.messageId, user))));
+});
diff --git a/src/server/api/endpoints/messaging/messages.ts b/src/server/api/endpoints/messaging/messages.ts
new file mode 100644
index 0000000000..0338aba68a
--- /dev/null
+++ b/src/server/api/endpoints/messaging/messages.ts
@@ -0,0 +1,102 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import Message from '../../../../models/messaging-message';
+import User from '../../../../models/user';
+import { pack } from '../../../../models/messaging-message';
+import read from '../../common/read-messaging-message';
+
+/**
+ * Get messages
+ *
+ * @param {any} params
+ * @param {any} user
+ * @return {Promise<any>}
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'userId' parameter
+	const [recipientId, recipientIdErr] = $.type(ID).get(params.userId);
+	if (recipientIdErr) return rej('invalid userId param');
+
+	// Fetch recipient
+	const recipient = await User.findOne({
+		_id: recipientId
+	}, {
+		fields: {
+			_id: true
+		}
+	});
+
+	if (recipient === null) {
+		return rej('user not found');
+	}
+
+	// Get 'markAsRead' parameter
+	const [markAsRead = true, markAsReadErr] = $.bool.optional().get(params.markAsRead);
+	if (markAsReadErr) return rej('invalid markAsRead param');
+
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Get 'sinceId' parameter
+	const [sinceId, sinceIdErr] = $.type(ID).optional().get(params.sinceId);
+	if (sinceIdErr) return rej('invalid sinceId param');
+
+	// Get 'untilId' parameter
+	const [untilId, untilIdErr] = $.type(ID).optional().get(params.untilId);
+	if (untilIdErr) return rej('invalid untilId param');
+
+	// Check if both of sinceId and untilId is specified
+	if (sinceId && untilId) {
+		return rej('cannot set sinceId and untilId');
+	}
+
+	const query = {
+		$or: [{
+			userId: user._id,
+			recipientId: recipient._id
+		}, {
+			userId: recipient._id,
+			recipientId: user._id
+		}]
+	} as any;
+
+	const sort = {
+		_id: -1
+	};
+
+	if (sinceId) {
+		sort._id = 1;
+		query._id = {
+			$gt: sinceId
+		};
+	} else if (untilId) {
+		query._id = {
+			$lt: untilId
+		};
+	}
+
+	// Issue query
+	const messages = await Message
+		.find(query, {
+			limit: limit,
+			sort: sort
+		});
+
+	// Serialize
+	res(await Promise.all(messages.map(async message =>
+		await pack(message, user, {
+			populateRecipient: false
+		}))));
+
+	if (messages.length === 0) {
+		return;
+	}
+
+	// Mark as read all
+	if (markAsRead) {
+		read(user._id, recipient._id, messages);
+	}
+});
diff --git a/src/server/api/endpoints/messaging/messages/create.ts b/src/server/api/endpoints/messaging/messages/create.ts
new file mode 100644
index 0000000000..db471839e7
--- /dev/null
+++ b/src/server/api/endpoints/messaging/messages/create.ts
@@ -0,0 +1,153 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../../cafy-id';
+import Message from '../../../../../models/messaging-message';
+import { isValidText } from '../../../../../models/messaging-message';
+import History from '../../../../../models/messaging-history';
+import User from '../../../../../models/user';
+import Mute from '../../../../../models/mute';
+import DriveFile from '../../../../../models/drive-file';
+import { pack } from '../../../../../models/messaging-message';
+import publishUserStream from '../../../../../publishers/stream';
+import { publishMessagingStream, publishMessagingIndexStream } from '../../../../../publishers/stream';
+import pushSw from '../../../../../publishers/push-sw';
+import config from '../../../../../config';
+
+/**
+ * Create a message
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'userId' parameter
+	const [recipientId, recipientIdErr] = $.type(ID).get(params.userId);
+	if (recipientIdErr) return rej('invalid userId param');
+
+	// Myself
+	if (recipientId.equals(user._id)) {
+		return rej('cannot send message to myself');
+	}
+
+	// Fetch recipient
+	const recipient = await User.findOne({
+		_id: recipientId
+	}, {
+		fields: {
+			_id: true
+		}
+	});
+
+	if (recipient === null) {
+		return rej('user not found');
+	}
+
+	// Get 'text' parameter
+	const [text, textErr] = $.str.optional().pipe(isValidText).get(params.text);
+	if (textErr) return rej('invalid text');
+
+	// Get 'fileId' parameter
+	const [fileId, fileIdErr] = $.type(ID).optional().get(params.fileId);
+	if (fileIdErr) return rej('invalid fileId param');
+
+	let file = null;
+	if (fileId !== undefined) {
+		file = await DriveFile.findOne({
+			_id: fileId,
+			'metadata.userId': user._id
+		});
+
+		if (file === null) {
+			return rej('file not found');
+		}
+	}
+
+	// テキストが無いかつ添付ファイルも無かったらエラー
+	if (text === undefined && file === null) {
+		return rej('text or file is required');
+	}
+
+	// メッセージを作成
+	const message = await Message.insert({
+		createdAt: new Date(),
+		fileId: file ? file._id : undefined,
+		recipientId: recipient._id,
+		text: text ? text : undefined,
+		userId: user._id,
+		isRead: false
+	});
+
+	// Serialize
+	const messageObj = await pack(message);
+
+	// Reponse
+	res(messageObj);
+
+	// 自分のストリーム
+	publishMessagingStream(message.userId, message.recipientId, 'message', messageObj);
+	publishMessagingIndexStream(message.userId, 'message', messageObj);
+	publishUserStream(message.userId, 'messaging_message', messageObj);
+
+	// 相手のストリーム
+	publishMessagingStream(message.recipientId, message.userId, 'message', messageObj);
+	publishMessagingIndexStream(message.recipientId, 'message', messageObj);
+	publishUserStream(message.recipientId, 'messaging_message', messageObj);
+
+	// 3秒経っても(今回作成した)メッセージが既読にならなかったら「未読のメッセージがありますよ」イベントを発行する
+	setTimeout(async () => {
+		const freshMessage = await Message.findOne({ _id: message._id }, { isRead: true });
+		if (!freshMessage.isRead) {
+			//#region ただしミュートされているなら発行しない
+			const mute = await Mute.find({
+				muterId: recipient._id,
+				deletedAt: { $exists: false }
+			});
+			const mutedUserIds = mute.map(m => m.muteeId.toString());
+			if (mutedUserIds.indexOf(user._id.toString()) != -1) {
+				return;
+			}
+			//#endregion
+
+			publishUserStream(message.recipientId, 'unread_messaging_message', messageObj);
+			pushSw(message.recipientId, 'unread_messaging_message', messageObj);
+		}
+	}, 3000);
+
+	// Register to search database
+	if (message.text && config.elasticsearch.enable) {
+		const es = require('../../../db/elasticsearch');
+
+		es.index({
+			index: 'misskey',
+			type: 'messaging_message',
+			id: message._id.toString(),
+			body: {
+				text: message.text
+			}
+		});
+	}
+
+	// 履歴作成(自分)
+	History.update({
+		userId: user._id,
+		partnerId: recipient._id
+	}, {
+		updatedAt: new Date(),
+		userId: user._id,
+		partnerId: recipient._id,
+		messageId: message._id
+	}, {
+		upsert: true
+	});
+
+	// 履歴作成(相手)
+	History.update({
+		userId: recipient._id,
+		partnerId: user._id
+	}, {
+		updatedAt: new Date(),
+		userId: recipient._id,
+		partnerId: user._id,
+		messageId: message._id
+	}, {
+		upsert: true
+	});
+});
diff --git a/src/server/api/endpoints/messaging/unread.ts b/src/server/api/endpoints/messaging/unread.ts
new file mode 100644
index 0000000000..1d83af501d
--- /dev/null
+++ b/src/server/api/endpoints/messaging/unread.ts
@@ -0,0 +1,29 @@
+/**
+ * Module dependencies
+ */
+import Message from '../../../../models/messaging-message';
+import Mute from '../../../../models/mute';
+
+/**
+ * Get count of unread messages
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	const mute = await Mute.find({
+		muterId: user._id,
+		deletedAt: { $exists: false }
+	});
+	const mutedUserIds = mute.map(m => m.muteeId);
+
+	const count = await Message
+		.count({
+			userId: {
+				$nin: mutedUserIds
+			},
+			recipientId: user._id,
+			isRead: false
+		});
+
+	res({
+		count: count
+	});
+});
diff --git a/src/server/api/endpoints/meta.ts b/src/server/api/endpoints/meta.ts
new file mode 100644
index 0000000000..0e9ecf47df
--- /dev/null
+++ b/src/server/api/endpoints/meta.ts
@@ -0,0 +1,60 @@
+/**
+ * Module dependencies
+ */
+import * as os from 'os';
+import config from '../../../config';
+import Meta from '../../../models/meta';
+
+const pkg = require('../../../../package.json');
+const client = require('../../../../built/client/meta.json');
+
+/**
+ * @swagger
+ * /meta:
+ *   note:
+ *     summary: Show the misskey's information
+ *     responses:
+ *       200:
+ *         description: Success
+ *         schema:
+ *           type: object
+ *           properties:
+ *             maintainer:
+ *               description: maintainer's name
+ *               type: string
+ *             commit:
+ *               description: latest commit's hash
+ *               type: string
+ *             secure:
+ *               description: whether the server supports secure protocols
+ *               type: boolean
+ *
+ *       default:
+ *         description: Failed
+ *         schema:
+ *           $ref: "#/definitions/Error"
+ */
+
+/**
+ * Show core info
+ */
+module.exports = (params) => new Promise(async (res, rej) => {
+	const meta: any = (await Meta.findOne()) || {};
+
+	res({
+		maintainer: config.maintainer,
+
+		version: pkg.version,
+		clientVersion: client.version,
+
+		secure: config.https != null,
+		machine: os.hostname(),
+		os: os.platform(),
+		node: process.version,
+		cpu: {
+			model: os.cpus()[0].model,
+			cores: os.cpus().length
+		},
+		broadcasts: meta.broadcasts
+	});
+});
diff --git a/src/server/api/endpoints/mute/create.ts b/src/server/api/endpoints/mute/create.ts
new file mode 100644
index 0000000000..534020c671
--- /dev/null
+++ b/src/server/api/endpoints/mute/create.ts
@@ -0,0 +1,56 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import User from '../../../../models/user';
+import Mute from '../../../../models/mute';
+
+/**
+ * Mute a user
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	const muter = user;
+
+	// Get 'userId' parameter
+	const [userId, userIdErr] = $.type(ID).get(params.userId);
+	if (userIdErr) return rej('invalid userId param');
+
+	// 自分自身
+	if (user._id.equals(userId)) {
+		return rej('mutee is yourself');
+	}
+
+	// Get mutee
+	const mutee = await User.findOne({
+		_id: userId
+	}, {
+		fields: {
+			data: false,
+			profile: false
+		}
+	});
+
+	if (mutee === null) {
+		return rej('user not found');
+	}
+
+	// Check if already muting
+	const exist = await Mute.findOne({
+		muterId: muter._id,
+		muteeId: mutee._id
+	});
+
+	if (exist !== null) {
+		return rej('already muting');
+	}
+
+	// Create mute
+	await Mute.insert({
+		createdAt: new Date(),
+		muterId: muter._id,
+		muteeId: mutee._id,
+	});
+
+	// Send response
+	res();
+});
diff --git a/src/server/api/endpoints/mute/delete.ts b/src/server/api/endpoints/mute/delete.ts
new file mode 100644
index 0000000000..949aff64ba
--- /dev/null
+++ b/src/server/api/endpoints/mute/delete.ts
@@ -0,0 +1,54 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import User from '../../../../models/user';
+import Mute from '../../../../models/mute';
+
+/**
+ * Unmute a user
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	const muter = user;
+
+	// Get 'userId' parameter
+	const [userId, userIdErr] = $.type(ID).get(params.userId);
+	if (userIdErr) return rej('invalid userId param');
+
+	// Check if the mutee is yourself
+	if (user._id.equals(userId)) {
+		return rej('mutee is yourself');
+	}
+
+	// Get mutee
+	const mutee = await User.findOne({
+		_id: userId
+	}, {
+		fields: {
+			data: false,
+			profile: false
+		}
+	});
+
+	if (mutee === null) {
+		return rej('user not found');
+	}
+
+	// Check not muting
+	const exist = await Mute.findOne({
+		muterId: muter._id,
+		muteeId: mutee._id
+	});
+
+	if (exist === null) {
+		return rej('already not muting');
+	}
+
+	// Delete mute
+	await Mute.remove({
+		_id: exist._id
+	});
+
+	// Send response
+	res();
+});
diff --git a/src/server/api/endpoints/mute/list.ts b/src/server/api/endpoints/mute/list.ts
new file mode 100644
index 0000000000..cf89f7e959
--- /dev/null
+++ b/src/server/api/endpoints/mute/list.ts
@@ -0,0 +1,69 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import Mute from '../../../../models/mute';
+import { pack } from '../../../../models/user';
+import { getFriendIds } from '../../common/get-friends';
+
+/**
+ * Get muted users of a user
+ */
+module.exports = (params, me) => new Promise(async (res, rej) => {
+	// Get 'iknow' parameter
+	const [iknow = false, iknowErr] = $.bool.optional().get(params.iknow);
+	if (iknowErr) return rej('invalid iknow param');
+
+	// Get 'limit' parameter
+	const [limit = 30, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Get 'cursor' parameter
+	const [cursor = null, cursorErr] = $.type(ID).optional().get(params.cursor);
+	if (cursorErr) return rej('invalid cursor param');
+
+	// Construct query
+	const query = {
+		muterId: me._id,
+		deletedAt: { $exists: false }
+	} as any;
+
+	if (iknow) {
+		// Get my friends
+		const myFriends = await getFriendIds(me._id);
+
+		query.muteeId = {
+			$in: myFriends
+		};
+	}
+
+	// カーソルが指定されている場合
+	if (cursor) {
+		query._id = {
+			$lt: cursor
+		};
+	}
+
+	// Get mutes
+	const mutes = await Mute
+		.find(query, {
+			limit: limit + 1,
+			sort: { _id: -1 }
+		});
+
+	// 「次のページ」があるかどうか
+	const inStock = mutes.length === limit + 1;
+	if (inStock) {
+		mutes.pop();
+	}
+
+	// Serialize
+	const users = await Promise.all(mutes.map(async m =>
+		await pack(m.muteeId, me, { detail: true })));
+
+	// Response
+	res({
+		users: users,
+		next: inStock ? mutes[mutes.length - 1]._id : null,
+	});
+});
diff --git a/src/server/api/endpoints/my/apps.ts b/src/server/api/endpoints/my/apps.ts
new file mode 100644
index 0000000000..086e0b8965
--- /dev/null
+++ b/src/server/api/endpoints/my/apps.ts
@@ -0,0 +1,36 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy';
+import App, { pack } from '../../../../models/app';
+
+/**
+ * Get my apps
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Get 'offset' parameter
+	const [offset = 0, offsetErr] = $.num.optional().min(0).get(params.offset);
+	if (offsetErr) return rej('invalid offset param');
+
+	const query = {
+		userId: user._id
+	};
+
+	// Execute query
+	const apps = await App
+		.find(query, {
+			limit: limit,
+			skip: offset,
+			sort: {
+				_id: -1
+			}
+		});
+
+	// Reply
+	res(await Promise.all(apps.map(async app =>
+		await pack(app))));
+});
diff --git a/src/server/api/endpoints/notes.ts b/src/server/api/endpoints/notes.ts
new file mode 100644
index 0000000000..4ce7613d70
--- /dev/null
+++ b/src/server/api/endpoints/notes.ts
@@ -0,0 +1,94 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../cafy-id';
+import Note, { pack } from '../../../models/note';
+
+/**
+ * Get all notes
+ */
+module.exports = (params) => new Promise(async (res, rej) => {
+	// Get 'reply' parameter
+	const [reply, replyErr] = $.bool.optional().get(params.reply);
+	if (replyErr) return rej('invalid reply param');
+
+	// Get 'renote' parameter
+	const [renote, renoteErr] = $.bool.optional().get(params.renote);
+	if (renoteErr) return rej('invalid renote param');
+
+	// Get 'media' parameter
+	const [media, mediaErr] = $.bool.optional().get(params.media);
+	if (mediaErr) return rej('invalid media param');
+
+	// Get 'poll' parameter
+	const [poll, pollErr] = $.bool.optional().get(params.poll);
+	if (pollErr) return rej('invalid poll param');
+
+	// Get 'bot' parameter
+	//const [bot, botErr] = $.bool.optional().get(params.bot);
+	//if (botErr) return rej('invalid bot param');
+
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Get 'sinceId' parameter
+	const [sinceId, sinceIdErr] = $.type(ID).optional().get(params.sinceId);
+	if (sinceIdErr) return rej('invalid sinceId param');
+
+	// Get 'untilId' parameter
+	const [untilId, untilIdErr] = $.type(ID).optional().get(params.untilId);
+	if (untilIdErr) return rej('invalid untilId param');
+
+	// Check if both of sinceId and untilId is specified
+	if (sinceId && untilId) {
+		return rej('cannot set sinceId and untilId');
+	}
+
+	// Construct query
+	const sort = {
+		_id: -1
+	};
+	const query = {} as any;
+	if (sinceId) {
+		sort._id = 1;
+		query._id = {
+			$gt: sinceId
+		};
+	} else if (untilId) {
+		query._id = {
+			$lt: untilId
+		};
+	}
+
+	if (reply != undefined) {
+		query.replyId = reply ? { $exists: true, $ne: null } : null;
+	}
+
+	if (renote != undefined) {
+		query.renoteId = renote ? { $exists: true, $ne: null } : null;
+	}
+
+	if (media != undefined) {
+		query.mediaIds = media ? { $exists: true, $ne: null } : [];
+	}
+
+	if (poll != undefined) {
+		query.poll = poll ? { $exists: true, $ne: null } : null;
+	}
+
+	// TODO
+	//if (bot != undefined) {
+	//	query.isBot = bot;
+	//}
+
+	// Issue query
+	const notes = await Note
+		.find(query, {
+			limit: limit,
+			sort: sort
+		});
+
+	// Serialize
+	res(await Promise.all(notes.map(note => pack(note))));
+});
diff --git a/src/server/api/endpoints/notes/context.ts b/src/server/api/endpoints/notes/context.ts
new file mode 100644
index 0000000000..1cd27250e2
--- /dev/null
+++ b/src/server/api/endpoints/notes/context.ts
@@ -0,0 +1,63 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import Note, { pack } from '../../../../models/note';
+
+/**
+ * Show a context of a note
+ *
+ * @param {any} params
+ * @param {any} user
+ * @return {Promise<any>}
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'noteId' parameter
+	const [noteId, noteIdErr] = $.type(ID).get(params.noteId);
+	if (noteIdErr) return rej('invalid noteId param');
+
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Get 'offset' parameter
+	const [offset = 0, offsetErr] = $.num.optional().min(0).get(params.offset);
+	if (offsetErr) return rej('invalid offset param');
+
+	// Lookup note
+	const note = await Note.findOne({
+		_id: noteId
+	});
+
+	if (note === null) {
+		return rej('note not found');
+	}
+
+	const context = [];
+	let i = 0;
+
+	async function get(id) {
+		i++;
+		const p = await Note.findOne({ _id: id });
+
+		if (i > offset) {
+			context.push(p);
+		}
+
+		if (context.length == limit) {
+			return;
+		}
+
+		if (p.replyId) {
+			await get(p.replyId);
+		}
+	}
+
+	if (note.replyId) {
+		await get(note.replyId);
+	}
+
+	// Serialize
+	res(await Promise.all(context.map(async note =>
+		await pack(note, user))));
+});
diff --git a/src/server/api/endpoints/notes/create.ts b/src/server/api/endpoints/notes/create.ts
new file mode 100644
index 0000000000..429b6d370a
--- /dev/null
+++ b/src/server/api/endpoints/notes/create.ts
@@ -0,0 +1,215 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import Note, { INote, isValidText, isValidCw, pack } from '../../../../models/note';
+import User, { ILocalUser } from '../../../../models/user';
+import Channel, { IChannel } from '../../../../models/channel';
+import DriveFile from '../../../../models/drive-file';
+import create from '../../../../services/note/create';
+import { IApp } from '../../../../models/app';
+
+/**
+ * Create a note
+ */
+module.exports = (params, user: ILocalUser, app: IApp) => new Promise(async (res, rej) => {
+	// Get 'visibility' parameter
+	const [visibility = 'public', visibilityErr] = $.str.optional().or(['public', 'home', 'followers', 'specified', 'private']).get(params.visibility);
+	if (visibilityErr) return rej('invalid visibility');
+
+	// Get 'visibleUserIds' parameter
+	const [visibleUserIds, visibleUserIdsErr] = $.arr($.type(ID)).optional().unique().min(1).get(params.visibleUserIds);
+	if (visibleUserIdsErr) return rej('invalid visibleUserIds');
+
+	let visibleUsers = [];
+	if (visibleUserIds !== undefined) {
+		visibleUsers = await Promise.all(visibleUserIds.map(id => User.findOne({
+			_id: id
+		})));
+	}
+
+	// Get 'text' parameter
+	const [text = null, textErr] = $.str.optional().nullable().pipe(isValidText).get(params.text);
+	if (textErr) return rej('invalid text');
+
+	// Get 'cw' parameter
+	const [cw, cwErr] = $.str.optional().nullable().pipe(isValidCw).get(params.cw);
+	if (cwErr) return rej('invalid cw');
+
+	// Get 'viaMobile' parameter
+	const [viaMobile = false, viaMobileErr] = $.bool.optional().get(params.viaMobile);
+	if (viaMobileErr) return rej('invalid viaMobile');
+
+	// Get 'tags' parameter
+	const [tags = [], tagsErr] = $.arr($.str.range(1, 32)).optional().unique().get(params.tags);
+	if (tagsErr) return rej('invalid tags');
+
+	// Get 'geo' parameter
+	const [geo, geoErr] = $.obj.optional().nullable().strict()
+		.have('coordinates', $.arr().length(2)
+			.item(0, $.num.range(-180, 180))
+			.item(1, $.num.range(-90, 90)))
+		.have('altitude', $.num.nullable())
+		.have('accuracy', $.num.nullable())
+		.have('altitudeAccuracy', $.num.nullable())
+		.have('heading', $.num.nullable().range(0, 360))
+		.have('speed', $.num.nullable())
+		.get(params.geo);
+	if (geoErr) return rej('invalid geo');
+
+	// Get 'mediaIds' parameter
+	const [mediaIds, mediaIdsErr] = $.arr($.type(ID)).optional().unique().range(1, 4).get(params.mediaIds);
+	if (mediaIdsErr) return rej('invalid mediaIds');
+
+	let files = [];
+	if (mediaIds !== undefined) {
+		// Fetch files
+		// forEach だと途中でエラーなどがあっても return できないので
+		// 敢えて for を使っています。
+		for (const mediaId of mediaIds) {
+			// Fetch file
+			// SELECT _id
+			const entity = await DriveFile.findOne({
+				_id: mediaId,
+				'metadata.userId': user._id
+			});
+
+			if (entity === null) {
+				return rej('file not found');
+			} else {
+				files.push(entity);
+			}
+		}
+	} else {
+		files = null;
+	}
+
+	// Get 'renoteId' parameter
+	const [renoteId, renoteIdErr] = $.type(ID).optional().get(params.renoteId);
+	if (renoteIdErr) return rej('invalid renoteId');
+
+	let renote: INote = null;
+	let isQuote = false;
+	if (renoteId !== undefined) {
+		// Fetch renote to note
+		renote = await Note.findOne({
+			_id: renoteId
+		});
+
+		if (renote == null) {
+			return rej('renoteee is not found');
+		} else if (renote.renoteId && !renote.text && !renote.mediaIds) {
+			return rej('cannot renote to renote');
+		}
+
+		isQuote = text != null || files != null;
+	}
+
+	// Get 'replyId' parameter
+	const [replyId, replyIdErr] = $.type(ID).optional().get(params.replyId);
+	if (replyIdErr) return rej('invalid replyId');
+
+	let reply: INote = null;
+	if (replyId !== undefined) {
+		// Fetch reply
+		reply = await Note.findOne({
+			_id: replyId
+		});
+
+		if (reply === null) {
+			return rej('in reply to note is not found');
+		}
+
+		// 返信対象が引用でないRenoteだったらエラー
+		if (reply.renoteId && !reply.text && !reply.mediaIds) {
+			return rej('cannot reply to renote');
+		}
+	}
+
+	// Get 'channelId' parameter
+	const [channelId, channelIdErr] = $.type(ID).optional().get(params.channelId);
+	if (channelIdErr) return rej('invalid channelId');
+
+	let channel: IChannel = null;
+	if (channelId !== undefined) {
+		// Fetch channel
+		channel = await Channel.findOne({
+			_id: channelId
+		});
+
+		if (channel === null) {
+			return rej('channel not found');
+		}
+
+		// 返信対象の投稿がこのチャンネルじゃなかったらダメ
+		if (reply && !channelId.equals(reply.channelId)) {
+			return rej('チャンネル内部からチャンネル外部の投稿に返信することはできません');
+		}
+
+		// Renote対象の投稿がこのチャンネルじゃなかったらダメ
+		if (renote && !channelId.equals(renote.channelId)) {
+			return rej('チャンネル内部からチャンネル外部の投稿をRenoteすることはできません');
+		}
+
+		// 引用ではないRenoteはダメ
+		if (renote && !isQuote) {
+			return rej('チャンネル内部では引用ではないRenoteをすることはできません');
+		}
+	} else {
+		// 返信対象の投稿がチャンネルへの投稿だったらダメ
+		if (reply && reply.channelId != null) {
+			return rej('チャンネル外部からチャンネル内部の投稿に返信することはできません');
+		}
+
+		// Renote対象の投稿がチャンネルへの投稿だったらダメ
+		if (renote && renote.channelId != null) {
+			return rej('チャンネル外部からチャンネル内部の投稿をRenoteすることはできません');
+		}
+	}
+
+	// Get 'poll' parameter
+	const [poll, pollErr] = $.obj.optional().strict()
+		.have('choices', $.arr($.str)
+			.unique()
+			.range(2, 10)
+			.each(c => c.length > 0 && c.length < 50))
+		.get(params.poll);
+	if (pollErr) return rej('invalid poll');
+
+	if (poll) {
+		(poll as any).choices = (poll as any).choices.map((choice, i) => ({
+			id: i, // IDを付与
+			text: choice.trim(),
+			votes: 0
+		}));
+	}
+
+	// テキストが無いかつ添付ファイルが無いかつRenoteも無いかつ投票も無かったらエラー
+	if (text === undefined && files === null && renote === null && poll === undefined) {
+		return rej('text, mediaIds, renoteId or poll is required');
+	}
+
+	// 投稿を作成
+	const note = await create(user, {
+		createdAt: new Date(),
+		media: files,
+		poll,
+		text,
+		reply,
+		renote,
+		cw,
+		tags,
+		app,
+		viaMobile,
+		visibility,
+		visibleUsers,
+		geo
+	});
+
+	const noteObj = await pack(note, user);
+
+	// Reponse
+	res({
+		createdNote: noteObj
+	});
+});
diff --git a/src/server/api/endpoints/notes/favorites/create.ts b/src/server/api/endpoints/notes/favorites/create.ts
new file mode 100644
index 0000000000..6832b52f75
--- /dev/null
+++ b/src/server/api/endpoints/notes/favorites/create.ts
@@ -0,0 +1,44 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../../cafy-id';
+import Favorite from '../../../../../models/favorite';
+import Note from '../../../../../models/note';
+
+/**
+ * Favorite a note
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'noteId' parameter
+	const [noteId, noteIdErr] = $.type(ID).get(params.noteId);
+	if (noteIdErr) return rej('invalid noteId param');
+
+	// Get favoritee
+	const note = await Note.findOne({
+		_id: noteId
+	});
+
+	if (note === null) {
+		return rej('note not found');
+	}
+
+	// if already favorited
+	const exist = await Favorite.findOne({
+		noteId: note._id,
+		userId: user._id
+	});
+
+	if (exist !== null) {
+		return rej('already favorited');
+	}
+
+	// Create favorite
+	await Favorite.insert({
+		createdAt: new Date(),
+		noteId: note._id,
+		userId: user._id
+	});
+
+	// Send response
+	res();
+});
diff --git a/src/server/api/endpoints/notes/favorites/delete.ts b/src/server/api/endpoints/notes/favorites/delete.ts
new file mode 100644
index 0000000000..07112dae15
--- /dev/null
+++ b/src/server/api/endpoints/notes/favorites/delete.ts
@@ -0,0 +1,42 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../../cafy-id';
+import Favorite from '../../../../../models/favorite';
+import Note from '../../../../../models/note';
+
+/**
+ * Unfavorite a note
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'noteId' parameter
+	const [noteId, noteIdErr] = $.type(ID).get(params.noteId);
+	if (noteIdErr) return rej('invalid noteId param');
+
+	// Get favoritee
+	const note = await Note.findOne({
+		_id: noteId
+	});
+
+	if (note === null) {
+		return rej('note not found');
+	}
+
+	// if already favorited
+	const exist = await Favorite.findOne({
+		noteId: note._id,
+		userId: user._id
+	});
+
+	if (exist === null) {
+		return rej('already not favorited');
+	}
+
+	// Delete favorite
+	await Favorite.remove({
+		_id: exist._id
+	});
+
+	// Send response
+	res();
+});
diff --git a/src/server/api/endpoints/notes/global-timeline.ts b/src/server/api/endpoints/notes/global-timeline.ts
new file mode 100644
index 0000000000..d22a1763de
--- /dev/null
+++ b/src/server/api/endpoints/notes/global-timeline.ts
@@ -0,0 +1,91 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import Note from '../../../../models/note';
+import Mute from '../../../../models/mute';
+import { pack } from '../../../../models/note';
+
+/**
+ * Get timeline of global
+ */
+module.exports = async (params, user, app) => {
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) throw 'invalid limit param';
+
+	// Get 'sinceId' parameter
+	const [sinceId, sinceIdErr] = $.type(ID).optional().get(params.sinceId);
+	if (sinceIdErr) throw 'invalid sinceId param';
+
+	// Get 'untilId' parameter
+	const [untilId, untilIdErr] = $.type(ID).optional().get(params.untilId);
+	if (untilIdErr) throw 'invalid untilId param';
+
+	// Get 'sinceDate' parameter
+	const [sinceDate, sinceDateErr] = $.num.optional().get(params.sinceDate);
+	if (sinceDateErr) throw 'invalid sinceDate param';
+
+	// Get 'untilDate' parameter
+	const [untilDate, untilDateErr] = $.num.optional().get(params.untilDate);
+	if (untilDateErr) throw 'invalid untilDate param';
+
+	// Check if only one of sinceId, untilId, sinceDate, untilDate specified
+	if ([sinceId, untilId, sinceDate, untilDate].filter(x => x != null).length > 1) {
+		throw 'only one of sinceId, untilId, sinceDate, untilDate can be specified';
+	}
+
+	// ミュートしているユーザーを取得
+	const mutedUserIds = (await Mute.find({
+		muterId: user._id
+	})).map(m => m.muteeId);
+
+	//#region Construct query
+	const sort = {
+		_id: -1
+	};
+
+	const query = {
+		// mute
+		userId: {
+			$nin: mutedUserIds
+		},
+		'_reply.userId': {
+			$nin: mutedUserIds
+		},
+		'_renote.userId': {
+			$nin: mutedUserIds
+		}
+	} as any;
+
+	if (sinceId) {
+		sort._id = 1;
+		query._id = {
+			$gt: sinceId
+		};
+	} else if (untilId) {
+		query._id = {
+			$lt: untilId
+		};
+	} else if (sinceDate) {
+		sort._id = 1;
+		query.createdAt = {
+			$gt: new Date(sinceDate)
+		};
+	} else if (untilDate) {
+		query.createdAt = {
+			$lt: new Date(untilDate)
+		};
+	}
+	//#endregion
+
+	// Issue query
+	const timeline = await Note
+		.find(query, {
+			limit: limit,
+			sort: sort
+		});
+
+	// Serialize
+	return await Promise.all(timeline.map(note => pack(note, user)));
+};
diff --git a/src/server/api/endpoints/notes/local-timeline.ts b/src/server/api/endpoints/notes/local-timeline.ts
new file mode 100644
index 0000000000..e7ebe5d960
--- /dev/null
+++ b/src/server/api/endpoints/notes/local-timeline.ts
@@ -0,0 +1,94 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import Note from '../../../../models/note';
+import Mute from '../../../../models/mute';
+import { pack } from '../../../../models/note';
+
+/**
+ * Get timeline of local
+ */
+module.exports = async (params, user, app) => {
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) throw 'invalid limit param';
+
+	// Get 'sinceId' parameter
+	const [sinceId, sinceIdErr] = $.type(ID).optional().get(params.sinceId);
+	if (sinceIdErr) throw 'invalid sinceId param';
+
+	// Get 'untilId' parameter
+	const [untilId, untilIdErr] = $.type(ID).optional().get(params.untilId);
+	if (untilIdErr) throw 'invalid untilId param';
+
+	// Get 'sinceDate' parameter
+	const [sinceDate, sinceDateErr] = $.num.optional().get(params.sinceDate);
+	if (sinceDateErr) throw 'invalid sinceDate param';
+
+	// Get 'untilDate' parameter
+	const [untilDate, untilDateErr] = $.num.optional().get(params.untilDate);
+	if (untilDateErr) throw 'invalid untilDate param';
+
+	// Check if only one of sinceId, untilId, sinceDate, untilDate specified
+	if ([sinceId, untilId, sinceDate, untilDate].filter(x => x != null).length > 1) {
+		throw 'only one of sinceId, untilId, sinceDate, untilDate can be specified';
+	}
+
+	// ミュートしているユーザーを取得
+	const mutedUserIds = (await Mute.find({
+		muterId: user._id
+	})).map(m => m.muteeId);
+
+	//#region Construct query
+	const sort = {
+		_id: -1
+	};
+
+	const query = {
+		// mute
+		userId: {
+			$nin: mutedUserIds
+		},
+		'_reply.userId': {
+			$nin: mutedUserIds
+		},
+		'_renote.userId': {
+			$nin: mutedUserIds
+		},
+
+		// local
+		'_user.host': null
+	} as any;
+
+	if (sinceId) {
+		sort._id = 1;
+		query._id = {
+			$gt: sinceId
+		};
+	} else if (untilId) {
+		query._id = {
+			$lt: untilId
+		};
+	} else if (sinceDate) {
+		sort._id = 1;
+		query.createdAt = {
+			$gt: new Date(sinceDate)
+		};
+	} else if (untilDate) {
+		query.createdAt = {
+			$lt: new Date(untilDate)
+		};
+	}
+	//#endregion
+
+	// Issue query
+	const timeline = await Note
+		.find(query, {
+			limit: limit,
+			sort: sort
+		});
+
+	// Serialize
+	return await Promise.all(timeline.map(note => pack(note, user)));
+};
diff --git a/src/server/api/endpoints/notes/mentions.ts b/src/server/api/endpoints/notes/mentions.ts
new file mode 100644
index 0000000000..163a6b4866
--- /dev/null
+++ b/src/server/api/endpoints/notes/mentions.ts
@@ -0,0 +1,78 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import Note from '../../../../models/note';
+import { getFriendIds } from '../../common/get-friends';
+import { pack } from '../../../../models/note';
+
+/**
+ * Get mentions of myself
+ *
+ * @param {any} params
+ * @param {any} user
+ * @return {Promise<any>}
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'following' parameter
+	const [following = false, followingError] =
+		$.bool.optional().get(params.following);
+	if (followingError) return rej('invalid following param');
+
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Get 'sinceId' parameter
+	const [sinceId, sinceIdErr] = $.type(ID).optional().get(params.sinceId);
+	if (sinceIdErr) return rej('invalid sinceId param');
+
+	// Get 'untilId' parameter
+	const [untilId, untilIdErr] = $.type(ID).optional().get(params.untilId);
+	if (untilIdErr) return rej('invalid untilId param');
+
+	// Check if both of sinceId and untilId is specified
+	if (sinceId && untilId) {
+		return rej('cannot set sinceId and untilId');
+	}
+
+	// Construct query
+	const query = {
+		mentions: user._id
+	} as any;
+
+	const sort = {
+		_id: -1
+	};
+
+	if (following) {
+		const followingIds = await getFriendIds(user._id);
+
+		query.userId = {
+			$in: followingIds
+		};
+	}
+
+	if (sinceId) {
+		sort._id = 1;
+		query._id = {
+			$gt: sinceId
+		};
+	} else if (untilId) {
+		query._id = {
+			$lt: untilId
+		};
+	}
+
+	// Issue query
+	const mentions = await Note
+		.find(query, {
+			limit: limit,
+			sort: sort
+		});
+
+	// Serialize
+	res(await Promise.all(mentions.map(async mention =>
+		await pack(mention, user)
+	)));
+});
diff --git a/src/server/api/endpoints/notes/polls/recommendation.ts b/src/server/api/endpoints/notes/polls/recommendation.ts
new file mode 100644
index 0000000000..a272378d19
--- /dev/null
+++ b/src/server/api/endpoints/notes/polls/recommendation.ts
@@ -0,0 +1,55 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy';
+import Vote from '../../../../../models/poll-vote';
+import Note, { pack } from '../../../../../models/note';
+
+/**
+ * Get recommended polls
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Get 'offset' parameter
+	const [offset = 0, offsetErr] = $.num.optional().min(0).get(params.offset);
+	if (offsetErr) return rej('invalid offset param');
+
+	// Get votes
+	const votes = await Vote.find({
+		userId: user._id
+	}, {
+		fields: {
+			_id: false,
+			noteId: true
+		}
+	});
+
+	const nin = votes && votes.length != 0 ? votes.map(v => v.noteId) : [];
+
+	const notes = await Note
+		.find({
+			_id: {
+				$nin: nin
+			},
+			userId: {
+				$ne: user._id
+			},
+			poll: {
+				$exists: true,
+				$ne: null
+			}
+		}, {
+			limit: limit,
+			skip: offset,
+			sort: {
+				_id: -1
+			}
+		});
+
+	// Serialize
+	res(await Promise.all(notes.map(async note =>
+		await pack(note, user, { detail: true }))));
+});
diff --git a/src/server/api/endpoints/notes/polls/vote.ts b/src/server/api/endpoints/notes/polls/vote.ts
new file mode 100644
index 0000000000..f8f4515308
--- /dev/null
+++ b/src/server/api/endpoints/notes/polls/vote.ts
@@ -0,0 +1,111 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../../cafy-id';
+import Vote from '../../../../../models/poll-vote';
+import Note from '../../../../../models/note';
+import Watching from '../../../../../models/note-watching';
+import watch from '../../../../../services/note/watch';
+import { publishNoteStream } from '../../../../../publishers/stream';
+import notify from '../../../../../publishers/notify';
+
+/**
+ * Vote poll of a note
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'noteId' parameter
+	const [noteId, noteIdErr] = $.type(ID).get(params.noteId);
+	if (noteIdErr) return rej('invalid noteId param');
+
+	// Get votee
+	const note = await Note.findOne({
+		_id: noteId
+	});
+
+	if (note === null) {
+		return rej('note not found');
+	}
+
+	if (note.poll == null) {
+		return rej('poll not found');
+	}
+
+	// Get 'choice' parameter
+	const [choice, choiceError] =
+		$.num
+			.pipe(c => note.poll.choices.some(x => x.id == c))
+			.get(params.choice);
+	if (choiceError) return rej('invalid choice param');
+
+	// if already voted
+	const exist = await Vote.findOne({
+		noteId: note._id,
+		userId: user._id
+	});
+
+	if (exist !== null) {
+		return rej('already voted');
+	}
+
+	// Create vote
+	await Vote.insert({
+		createdAt: new Date(),
+		noteId: note._id,
+		userId: user._id,
+		choice: choice
+	});
+
+	// Send response
+	res();
+
+	const inc = {};
+	inc[`poll.choices.${findWithAttr(note.poll.choices, 'id', choice)}.votes`] = 1;
+
+	// Increment votes count
+	await Note.update({ _id: note._id }, {
+		$inc: inc
+	});
+
+	publishNoteStream(note._id, 'poll_voted');
+
+	// Notify
+	notify(note.userId, user._id, 'poll_vote', {
+		noteId: note._id,
+		choice: choice
+	});
+
+	// Fetch watchers
+	Watching
+		.find({
+			noteId: note._id,
+			userId: { $ne: user._id },
+			// 削除されたドキュメントは除く
+			deletedAt: { $exists: false }
+		}, {
+			fields: {
+				userId: true
+			}
+		})
+		.then(watchers => {
+			watchers.forEach(watcher => {
+				notify(watcher.userId, user._id, 'poll_vote', {
+					noteId: note._id,
+					choice: choice
+				});
+			});
+		});
+
+	// この投稿をWatchする
+	if (user.settings.autoWatch !== false) {
+		watch(user._id, note);
+	}
+});
+
+function findWithAttr(array, attr, value) {
+	for (let i = 0; i < array.length; i += 1) {
+		if (array[i][attr] === value) {
+			return i;
+		}
+	}
+	return -1;
+}
diff --git a/src/server/api/endpoints/notes/reactions.ts b/src/server/api/endpoints/notes/reactions.ts
new file mode 100644
index 0000000000..4ad952a7a1
--- /dev/null
+++ b/src/server/api/endpoints/notes/reactions.ts
@@ -0,0 +1,57 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import Note from '../../../../models/note';
+import Reaction, { pack } from '../../../../models/note-reaction';
+
+/**
+ * Show reactions of a note
+ *
+ * @param {any} params
+ * @param {any} user
+ * @return {Promise<any>}
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'noteId' parameter
+	const [noteId, noteIdErr] = $.type(ID).get(params.noteId);
+	if (noteIdErr) return rej('invalid noteId param');
+
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Get 'offset' parameter
+	const [offset = 0, offsetErr] = $.num.optional().min(0).get(params.offset);
+	if (offsetErr) return rej('invalid offset param');
+
+	// Get 'sort' parameter
+	const [sort = 'desc', sortError] = $.str.optional().or('desc asc').get(params.sort);
+	if (sortError) return rej('invalid sort param');
+
+	// Lookup note
+	const note = await Note.findOne({
+		_id: noteId
+	});
+
+	if (note === null) {
+		return rej('note not found');
+	}
+
+	// Issue query
+	const reactions = await Reaction
+		.find({
+			noteId: note._id,
+			deletedAt: { $exists: false }
+		}, {
+			limit: limit,
+			skip: offset,
+			sort: {
+				_id: sort == 'asc' ? 1 : -1
+			}
+		});
+
+	// Serialize
+	res(await Promise.all(reactions.map(async reaction =>
+		await pack(reaction, user))));
+});
diff --git a/src/server/api/endpoints/notes/reactions/create.ts b/src/server/api/endpoints/notes/reactions/create.ts
new file mode 100644
index 0000000000..21757cb427
--- /dev/null
+++ b/src/server/api/endpoints/notes/reactions/create.ts
@@ -0,0 +1,37 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../../cafy-id';
+import Note from '../../../../../models/note';
+import create from '../../../../../services/note/reaction/create';
+import { validateReaction } from '../../../../../models/note-reaction';
+
+/**
+ * React to a note
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'noteId' parameter
+	const [noteId, noteIdErr] = $.type(ID).get(params.noteId);
+	if (noteIdErr) return rej('invalid noteId param');
+
+	// Get 'reaction' parameter
+	const [reaction, reactionErr] = $.str.pipe(validateReaction.ok).get(params.reaction);
+	if (reactionErr) return rej('invalid reaction param');
+
+	// Fetch reactee
+	const note = await Note.findOne({
+		_id: noteId
+	});
+
+	if (note === null) {
+		return rej('note not found');
+	}
+
+	try {
+		await create(user, note, reaction);
+	} catch (e) {
+		rej(e);
+	}
+
+	res();
+});
diff --git a/src/server/api/endpoints/notes/reactions/delete.ts b/src/server/api/endpoints/notes/reactions/delete.ts
new file mode 100644
index 0000000000..afb8629112
--- /dev/null
+++ b/src/server/api/endpoints/notes/reactions/delete.ts
@@ -0,0 +1,55 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../../cafy-id';
+import Reaction from '../../../../../models/note-reaction';
+import Note from '../../../../../models/note';
+
+/**
+ * Unreact to a note
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'noteId' parameter
+	const [noteId, noteIdErr] = $.type(ID).get(params.noteId);
+	if (noteIdErr) return rej('invalid noteId param');
+
+	// Fetch unreactee
+	const note = await Note.findOne({
+		_id: noteId
+	});
+
+	if (note === null) {
+		return rej('note not found');
+	}
+
+	// if already unreacted
+	const exist = await Reaction.findOne({
+		noteId: note._id,
+		userId: user._id,
+		deletedAt: { $exists: false }
+	});
+
+	if (exist === null) {
+		return rej('never reacted');
+	}
+
+	// Delete reaction
+	await Reaction.update({
+		_id: exist._id
+	}, {
+			$set: {
+				deletedAt: new Date()
+			}
+		});
+
+	// Send response
+	res();
+
+	const dec = {};
+	dec[`reactionCounts.${exist.reaction}`] = -1;
+
+	// Decrement reactions count
+	Note.update({ _id: note._id }, {
+		$inc: dec
+	});
+});
diff --git a/src/server/api/endpoints/notes/replies.ts b/src/server/api/endpoints/notes/replies.ts
new file mode 100644
index 0000000000..11d221d8f7
--- /dev/null
+++ b/src/server/api/endpoints/notes/replies.ts
@@ -0,0 +1,53 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import Note, { pack } from '../../../../models/note';
+
+/**
+ * Show a replies of a note
+ *
+ * @param {any} params
+ * @param {any} user
+ * @return {Promise<any>}
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'noteId' parameter
+	const [noteId, noteIdErr] = $.type(ID).get(params.noteId);
+	if (noteIdErr) return rej('invalid noteId param');
+
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Get 'offset' parameter
+	const [offset = 0, offsetErr] = $.num.optional().min(0).get(params.offset);
+	if (offsetErr) return rej('invalid offset param');
+
+	// Get 'sort' parameter
+	const [sort = 'desc', sortError] = $.str.optional().or('desc asc').get(params.sort);
+	if (sortError) return rej('invalid sort param');
+
+	// Lookup note
+	const note = await Note.findOne({
+		_id: noteId
+	});
+
+	if (note === null) {
+		return rej('note not found');
+	}
+
+	// Issue query
+	const replies = await Note
+		.find({ replyId: note._id }, {
+			limit: limit,
+			skip: offset,
+			sort: {
+				_id: sort == 'asc' ? 1 : -1
+			}
+		});
+
+	// Serialize
+	res(await Promise.all(replies.map(async note =>
+		await pack(note, user))));
+});
diff --git a/src/server/api/endpoints/notes/reposts.ts b/src/server/api/endpoints/notes/reposts.ts
new file mode 100644
index 0000000000..3098211b61
--- /dev/null
+++ b/src/server/api/endpoints/notes/reposts.ts
@@ -0,0 +1,73 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import Note, { pack } from '../../../../models/note';
+
+/**
+ * Show a renotes of a note
+ *
+ * @param {any} params
+ * @param {any} user
+ * @return {Promise<any>}
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'noteId' parameter
+	const [noteId, noteIdErr] = $.type(ID).get(params.noteId);
+	if (noteIdErr) return rej('invalid noteId param');
+
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Get 'sinceId' parameter
+	const [sinceId, sinceIdErr] = $.type(ID).optional().get(params.sinceId);
+	if (sinceIdErr) return rej('invalid sinceId param');
+
+	// Get 'untilId' parameter
+	const [untilId, untilIdErr] = $.type(ID).optional().get(params.untilId);
+	if (untilIdErr) return rej('invalid untilId param');
+
+	// Check if both of sinceId and untilId is specified
+	if (sinceId && untilId) {
+		return rej('cannot set sinceId and untilId');
+	}
+
+	// Lookup note
+	const note = await Note.findOne({
+		_id: noteId
+	});
+
+	if (note === null) {
+		return rej('note not found');
+	}
+
+	// Construct query
+	const sort = {
+		_id: -1
+	};
+	const query = {
+		renoteId: note._id
+	} as any;
+	if (sinceId) {
+		sort._id = 1;
+		query._id = {
+			$gt: sinceId
+		};
+	} else if (untilId) {
+		query._id = {
+			$lt: untilId
+		};
+	}
+
+	// Issue query
+	const renotes = await Note
+		.find(query, {
+			limit: limit,
+			sort: sort
+		});
+
+	// Serialize
+	res(await Promise.all(renotes.map(async note =>
+		await pack(note, user))));
+});
diff --git a/src/server/api/endpoints/notes/search.ts b/src/server/api/endpoints/notes/search.ts
new file mode 100644
index 0000000000..9705dcfd6e
--- /dev/null
+++ b/src/server/api/endpoints/notes/search.ts
@@ -0,0 +1,364 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+const escapeRegexp = require('escape-regexp');
+import Note from '../../../../models/note';
+import User from '../../../../models/user';
+import Mute from '../../../../models/mute';
+import { getFriendIds } from '../../common/get-friends';
+import { pack } from '../../../../models/note';
+
+/**
+ * Search a note
+ *
+ * @param {any} params
+ * @param {any} me
+ * @return {Promise<any>}
+ */
+module.exports = (params, me) => new Promise(async (res, rej) => {
+	// Get 'text' parameter
+	const [text, textError] = $.str.optional().get(params.text);
+	if (textError) return rej('invalid text param');
+
+	// Get 'includeUserIds' parameter
+	const [includeUserIds = [], includeUserIdsErr] = $.arr($.type(ID)).optional().get(params.includeUserIds);
+	if (includeUserIdsErr) return rej('invalid includeUserIds param');
+
+	// Get 'excludeUserIds' parameter
+	const [excludeUserIds = [], excludeUserIdsErr] = $.arr($.type(ID)).optional().get(params.excludeUserIds);
+	if (excludeUserIdsErr) return rej('invalid excludeUserIds param');
+
+	// Get 'includeUserUsernames' parameter
+	const [includeUserUsernames = [], includeUserUsernamesErr] = $.arr($.str).optional().get(params.includeUserUsernames);
+	if (includeUserUsernamesErr) return rej('invalid includeUserUsernames param');
+
+	// Get 'excludeUserUsernames' parameter
+	const [excludeUserUsernames = [], excludeUserUsernamesErr] = $.arr($.str).optional().get(params.excludeUserUsernames);
+	if (excludeUserUsernamesErr) return rej('invalid excludeUserUsernames param');
+
+	// Get 'following' parameter
+	const [following = null, followingErr] = $.bool.optional().nullable().get(params.following);
+	if (followingErr) return rej('invalid following param');
+
+	// Get 'mute' parameter
+	const [mute = 'mute_all', muteErr] = $.str.optional().get(params.mute);
+	if (muteErr) return rej('invalid mute param');
+
+	// Get 'reply' parameter
+	const [reply = null, replyErr] = $.bool.optional().nullable().get(params.reply);
+	if (replyErr) return rej('invalid reply param');
+
+	// Get 'renote' parameter
+	const [renote = null, renoteErr] = $.bool.optional().nullable().get(params.renote);
+	if (renoteErr) return rej('invalid renote param');
+
+	// Get 'media' parameter
+	const [media = null, mediaErr] = $.bool.optional().nullable().get(params.media);
+	if (mediaErr) return rej('invalid media param');
+
+	// Get 'poll' parameter
+	const [poll = null, pollErr] = $.bool.optional().nullable().get(params.poll);
+	if (pollErr) return rej('invalid poll param');
+
+	// Get 'sinceDate' parameter
+	const [sinceDate, sinceDateErr] = $.num.optional().get(params.sinceDate);
+	if (sinceDateErr) throw 'invalid sinceDate param';
+
+	// Get 'untilDate' parameter
+	const [untilDate, untilDateErr] = $.num.optional().get(params.untilDate);
+	if (untilDateErr) throw 'invalid untilDate param';
+
+	// Get 'offset' parameter
+	const [offset = 0, offsetErr] = $.num.optional().min(0).get(params.offset);
+	if (offsetErr) return rej('invalid offset param');
+
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 30).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	let includeUsers = includeUserIds;
+	if (includeUserUsernames != null) {
+		const ids = (await Promise.all(includeUserUsernames.map(async (username) => {
+			const _user = await User.findOne({
+				usernameLower: username.toLowerCase()
+			});
+			return _user ? _user._id : null;
+		}))).filter(id => id != null);
+		includeUsers = includeUsers.concat(ids);
+	}
+
+	let excludeUsers = excludeUserIds;
+	if (excludeUserUsernames != null) {
+		const ids = (await Promise.all(excludeUserUsernames.map(async (username) => {
+			const _user = await User.findOne({
+				usernameLower: username.toLowerCase()
+			});
+			return _user ? _user._id : null;
+		}))).filter(id => id != null);
+		excludeUsers = excludeUsers.concat(ids);
+	}
+
+	search(res, rej, me, text, includeUsers, excludeUsers, following,
+			mute, reply, renote, media, poll, sinceDate, untilDate, offset, limit);
+});
+
+async function search(
+	res, rej, me, text, includeUserIds, excludeUserIds, following,
+	mute, reply, renote, media, poll, sinceDate, untilDate, offset, max) {
+
+	let q: any = {
+		$and: []
+	};
+
+	const push = x => q.$and.push(x);
+
+	if (text) {
+		// 完全一致検索
+		if (/"""(.+?)"""/.test(text)) {
+			const x = text.match(/"""(.+?)"""/)[1];
+			push({
+				text: x
+			});
+		} else {
+			const tags = text.split(' ').filter(x => x[0] == '#');
+			if (tags) {
+				push({
+					$and: tags.map(x => ({
+						tags: x
+					}))
+				});
+			}
+
+			push({
+				$and: text.split(' ').map(x => ({
+					// キーワードが-で始まる場合そのキーワードを除外する
+					text: x[0] == '-' ? {
+						$not: new RegExp(escapeRegexp(x.substr(1)))
+					} : new RegExp(escapeRegexp(x))
+				}))
+			});
+		}
+	}
+
+	if (includeUserIds && includeUserIds.length != 0) {
+		push({
+			userId: {
+				$in: includeUserIds
+			}
+		});
+	} else if (excludeUserIds && excludeUserIds.length != 0) {
+		push({
+			userId: {
+				$nin: excludeUserIds
+			}
+		});
+	}
+
+	if (following != null && me != null) {
+		const ids = await getFriendIds(me._id, false);
+		push({
+			userId: following ? {
+				$in: ids
+			} : {
+				$nin: ids.concat(me._id)
+			}
+		});
+	}
+
+	if (me != null) {
+		const mutes = await Mute.find({
+			muterId: me._id,
+			deletedAt: { $exists: false }
+		});
+		const mutedUserIds = mutes.map(m => m.muteeId);
+
+		switch (mute) {
+			case 'mute_all':
+				push({
+					userId: {
+						$nin: mutedUserIds
+					},
+					'_reply.userId': {
+						$nin: mutedUserIds
+					},
+					'_renote.userId': {
+						$nin: mutedUserIds
+					}
+				});
+				break;
+			case 'mute_related':
+				push({
+					'_reply.userId': {
+						$nin: mutedUserIds
+					},
+					'_renote.userId': {
+						$nin: mutedUserIds
+					}
+				});
+				break;
+			case 'mute_direct':
+				push({
+					userId: {
+						$nin: mutedUserIds
+					}
+				});
+				break;
+			case 'direct_only':
+				push({
+					userId: {
+						$in: mutedUserIds
+					}
+				});
+				break;
+			case 'related_only':
+				push({
+					$or: [{
+						'_reply.userId': {
+							$in: mutedUserIds
+						}
+					}, {
+						'_renote.userId': {
+							$in: mutedUserIds
+						}
+					}]
+				});
+				break;
+			case 'all_only':
+				push({
+					$or: [{
+						userId: {
+							$in: mutedUserIds
+						}
+					}, {
+						'_reply.userId': {
+							$in: mutedUserIds
+						}
+					}, {
+						'_renote.userId': {
+							$in: mutedUserIds
+						}
+					}]
+				});
+				break;
+		}
+	}
+
+	if (reply != null) {
+		if (reply) {
+			push({
+				replyId: {
+					$exists: true,
+					$ne: null
+				}
+			});
+		} else {
+			push({
+				$or: [{
+					replyId: {
+						$exists: false
+					}
+				}, {
+					replyId: null
+				}]
+			});
+		}
+	}
+
+	if (renote != null) {
+		if (renote) {
+			push({
+				renoteId: {
+					$exists: true,
+					$ne: null
+				}
+			});
+		} else {
+			push({
+				$or: [{
+					renoteId: {
+						$exists: false
+					}
+				}, {
+					renoteId: null
+				}]
+			});
+		}
+	}
+
+	if (media != null) {
+		if (media) {
+			push({
+				mediaIds: {
+					$exists: true,
+					$ne: null
+				}
+			});
+		} else {
+			push({
+				$or: [{
+					mediaIds: {
+						$exists: false
+					}
+				}, {
+					mediaIds: null
+				}]
+			});
+		}
+	}
+
+	if (poll != null) {
+		if (poll) {
+			push({
+				poll: {
+					$exists: true,
+					$ne: null
+				}
+			});
+		} else {
+			push({
+				$or: [{
+					poll: {
+						$exists: false
+					}
+				}, {
+					poll: null
+				}]
+			});
+		}
+	}
+
+	if (sinceDate) {
+		push({
+			createdAt: {
+				$gt: new Date(sinceDate)
+			}
+		});
+	}
+
+	if (untilDate) {
+		push({
+			createdAt: {
+				$lt: new Date(untilDate)
+			}
+		});
+	}
+
+	if (q.$and.length == 0) {
+		q = {};
+	}
+
+	// Search notes
+	const notes = await Note
+		.find(q, {
+			sort: {
+				_id: -1
+			},
+			limit: max,
+			skip: offset
+		});
+
+	// Serialize
+	res(await Promise.all(notes.map(async note =>
+		await pack(note, me))));
+}
diff --git a/src/server/api/endpoints/notes/show.ts b/src/server/api/endpoints/notes/show.ts
new file mode 100644
index 0000000000..78dc55a703
--- /dev/null
+++ b/src/server/api/endpoints/notes/show.ts
@@ -0,0 +1,32 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import Note, { pack } from '../../../../models/note';
+
+/**
+ * Show a note
+ *
+ * @param {any} params
+ * @param {any} user
+ * @return {Promise<any>}
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'noteId' parameter
+	const [noteId, noteIdErr] = $.type(ID).get(params.noteId);
+	if (noteIdErr) return rej('invalid noteId param');
+
+	// Get note
+	const note = await Note.findOne({
+		_id: noteId
+	});
+
+	if (note === null) {
+		return rej('note not found');
+	}
+
+	// Serialize
+	res(await pack(note, user, {
+		detail: true
+	}));
+});
diff --git a/src/server/api/endpoints/notes/timeline.ts b/src/server/api/endpoints/notes/timeline.ts
new file mode 100644
index 0000000000..78786d4a16
--- /dev/null
+++ b/src/server/api/endpoints/notes/timeline.ts
@@ -0,0 +1,195 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import Note from '../../../../models/note';
+import Mute from '../../../../models/mute';
+import ChannelWatching from '../../../../models/channel-watching';
+import { getFriends } from '../../common/get-friends';
+import { pack } from '../../../../models/note';
+
+/**
+ * Get timeline of myself
+ */
+module.exports = async (params, user, app) => {
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) throw 'invalid limit param';
+
+	// Get 'sinceId' parameter
+	const [sinceId, sinceIdErr] = $.type(ID).optional().get(params.sinceId);
+	if (sinceIdErr) throw 'invalid sinceId param';
+
+	// Get 'untilId' parameter
+	const [untilId, untilIdErr] = $.type(ID).optional().get(params.untilId);
+	if (untilIdErr) throw 'invalid untilId param';
+
+	// Get 'sinceDate' parameter
+	const [sinceDate, sinceDateErr] = $.num.optional().get(params.sinceDate);
+	if (sinceDateErr) throw 'invalid sinceDate param';
+
+	// Get 'untilDate' parameter
+	const [untilDate, untilDateErr] = $.num.optional().get(params.untilDate);
+	if (untilDateErr) throw 'invalid untilDate param';
+
+	// Check if only one of sinceId, untilId, sinceDate, untilDate specified
+	if ([sinceId, untilId, sinceDate, untilDate].filter(x => x != null).length > 1) {
+		throw 'only one of sinceId, untilId, sinceDate, untilDate can be specified';
+	}
+
+	// Get 'includeMyRenotes' parameter
+	const [includeMyRenotes = true, includeMyRenotesErr] = $.bool.optional().get(params.includeMyRenotes);
+	if (includeMyRenotesErr) throw 'invalid includeMyRenotes param';
+
+	// Get 'includeRenotedMyNotes' parameter
+	const [includeRenotedMyNotes = true, includeRenotedMyNotesErr] = $.bool.optional().get(params.includeRenotedMyNotes);
+	if (includeRenotedMyNotesErr) throw 'invalid includeRenotedMyNotes param';
+
+	const [followings, watchingChannelIds, mutedUserIds] = await Promise.all([
+		// フォローを取得
+		// Fetch following
+		getFriends(user._id),
+
+		// Watchしているチャンネルを取得
+		ChannelWatching.find({
+			userId: user._id,
+			// 削除されたドキュメントは除く
+			deletedAt: { $exists: false }
+		}).then(watches => watches.map(w => w.channelId)),
+
+		// ミュートしているユーザーを取得
+		Mute.find({
+			muterId: user._id
+		}).then(ms => ms.map(m => m.muteeId))
+	]);
+
+	//#region Construct query
+	const sort = {
+		_id: -1
+	};
+
+	const followQuery = followings.map(f => f.stalk ? {
+		userId: f.id
+	} : {
+		userId: f.id,
+
+		// ストーキングしてないならリプライは含めない(ただし投稿者自身の投稿へのリプライ、自分の投稿へのリプライ、自分のリプライは含める)
+		$or: [{
+			// リプライでない
+			replyId: null
+		}, { // または
+			// リプライだが返信先が投稿者自身の投稿
+			$expr: {
+				$eq: ['$_reply.userId', '$userId']
+			}
+		}, { // または
+			// リプライだが返信先が自分(フォロワー)の投稿
+			'_reply.userId': user._id
+		}, { // または
+			// 自分(フォロワー)が送信したリプライ
+			userId: user._id
+		}]
+	});
+
+	const query = {
+		$and: [{
+			$or: [{
+				$and: [{
+					// フォローしている人のタイムラインへの投稿
+					$or: followQuery
+				}, {
+					// 「タイムラインへの」投稿に限定するためにチャンネルが指定されていないもののみに限る
+					$or: [{
+						channelId: {
+							$exists: false
+						}
+					}, {
+						channelId: null
+					}]
+				}]
+			}, {
+				// Watchしているチャンネルへの投稿
+				channelId: {
+					$in: watchingChannelIds
+				}
+			}],
+			// mute
+			userId: {
+				$nin: mutedUserIds
+			},
+			'_reply.userId': {
+				$nin: mutedUserIds
+			},
+			'_renote.userId': {
+				$nin: mutedUserIds
+			},
+		}]
+	} as any;
+
+	// MongoDBではトップレベルで否定ができないため、De Morganの法則を利用してクエリします。
+	// つまり、「『自分の投稿かつRenote』ではない」を「『自分の投稿ではない』または『Renoteではない』」と表現します。
+	// for details: https://en.wikipedia.org/wiki/De_Morgan%27s_laws
+
+	if (includeMyRenotes === false) {
+		query.$and.push({
+			$or: [{
+				userId: { $ne: user._id }
+			}, {
+				renoteId: null
+			}, {
+				text: { $ne: null }
+			}, {
+				mediaIds: { $ne: [] }
+			}, {
+				poll: { $ne: null }
+			}]
+		});
+	}
+
+	if (includeRenotedMyNotes === false) {
+		query.$and.push({
+			$or: [{
+				'_renote.userId': { $ne: user._id }
+			}, {
+				renoteId: null
+			}, {
+				text: { $ne: null }
+			}, {
+				mediaIds: { $ne: [] }
+			}, {
+				poll: { $ne: null }
+			}]
+		});
+	}
+
+	if (sinceId) {
+		sort._id = 1;
+		query._id = {
+			$gt: sinceId
+		};
+	} else if (untilId) {
+		query._id = {
+			$lt: untilId
+		};
+	} else if (sinceDate) {
+		sort._id = 1;
+		query.createdAt = {
+			$gt: new Date(sinceDate)
+		};
+	} else if (untilDate) {
+		query.createdAt = {
+			$lt: new Date(untilDate)
+		};
+	}
+	//#endregion
+
+	// Issue query
+	const timeline = await Note
+		.find(query, {
+			limit: limit,
+			sort: sort
+		});
+
+	// Serialize
+	return await Promise.all(timeline.map(note => pack(note, user)));
+};
diff --git a/src/server/api/endpoints/notes/trend.ts b/src/server/api/endpoints/notes/trend.ts
new file mode 100644
index 0000000000..9cb3debe63
--- /dev/null
+++ b/src/server/api/endpoints/notes/trend.ts
@@ -0,0 +1,79 @@
+/**
+ * Module dependencies
+ */
+const ms = require('ms');
+import $ from 'cafy';
+import Note, { pack } from '../../../../models/note';
+
+/**
+ * Get trend notes
+ *
+ * @param {any} params
+ * @param {any} user
+ * @return {Promise<any>}
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Get 'offset' parameter
+	const [offset = 0, offsetErr] = $.num.optional().min(0).get(params.offset);
+	if (offsetErr) return rej('invalid offset param');
+
+	// Get 'reply' parameter
+	const [reply, replyErr] = $.bool.optional().get(params.reply);
+	if (replyErr) return rej('invalid reply param');
+
+	// Get 'renote' parameter
+	const [renote, renoteErr] = $.bool.optional().get(params.renote);
+	if (renoteErr) return rej('invalid renote param');
+
+	// Get 'media' parameter
+	const [media, mediaErr] = $.bool.optional().get(params.media);
+	if (mediaErr) return rej('invalid media param');
+
+	// Get 'poll' parameter
+	const [poll, pollErr] = $.bool.optional().get(params.poll);
+	if (pollErr) return rej('invalid poll param');
+
+	const query = {
+		createdAt: {
+			$gte: new Date(Date.now() - ms('1days'))
+		},
+		renoteCount: {
+			$gt: 0
+		}
+	} as any;
+
+	if (reply != undefined) {
+		query.replyId = reply ? { $exists: true, $ne: null } : null;
+	}
+
+	if (renote != undefined) {
+		query.renoteId = renote ? { $exists: true, $ne: null } : null;
+	}
+
+	if (media != undefined) {
+		query.mediaIds = media ? { $exists: true, $ne: null } : null;
+	}
+
+	if (poll != undefined) {
+		query.poll = poll ? { $exists: true, $ne: null } : null;
+	}
+
+	// Issue query
+	const notes = await Note
+		.find(query, {
+			limit: limit,
+			skip: offset,
+			sort: {
+				renoteCount: -1,
+				_id: -1
+			}
+		});
+
+	// Serialize
+	res(await Promise.all(notes.map(async note =>
+		await pack(note, user, { detail: true }))));
+});
diff --git a/src/server/api/endpoints/notes/user-list-timeline.ts b/src/server/api/endpoints/notes/user-list-timeline.ts
new file mode 100644
index 0000000000..9f8397d679
--- /dev/null
+++ b/src/server/api/endpoints/notes/user-list-timeline.ts
@@ -0,0 +1,179 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import Note from '../../../../models/note';
+import Mute from '../../../../models/mute';
+import { pack } from '../../../../models/note';
+import UserList from '../../../../models/user-list';
+
+/**
+ * Get timeline of a user list
+ */
+module.exports = async (params, user, app) => {
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) throw 'invalid limit param';
+
+	// Get 'sinceId' parameter
+	const [sinceId, sinceIdErr] = $.type(ID).optional().get(params.sinceId);
+	if (sinceIdErr) throw 'invalid sinceId param';
+
+	// Get 'untilId' parameter
+	const [untilId, untilIdErr] = $.type(ID).optional().get(params.untilId);
+	if (untilIdErr) throw 'invalid untilId param';
+
+	// Get 'sinceDate' parameter
+	const [sinceDate, sinceDateErr] = $.num.optional().get(params.sinceDate);
+	if (sinceDateErr) throw 'invalid sinceDate param';
+
+	// Get 'untilDate' parameter
+	const [untilDate, untilDateErr] = $.num.optional().get(params.untilDate);
+	if (untilDateErr) throw 'invalid untilDate param';
+
+	// Check if only one of sinceId, untilId, sinceDate, untilDate specified
+	if ([sinceId, untilId, sinceDate, untilDate].filter(x => x != null).length > 1) {
+		throw 'only one of sinceId, untilId, sinceDate, untilDate can be specified';
+	}
+
+	// Get 'includeMyRenotes' parameter
+	const [includeMyRenotes = true, includeMyRenotesErr] = $.bool.optional().get(params.includeMyRenotes);
+	if (includeMyRenotesErr) throw 'invalid includeMyRenotes param';
+
+	// Get 'includeRenotedMyNotes' parameter
+	const [includeRenotedMyNotes = true, includeRenotedMyNotesErr] = $.bool.optional().get(params.includeRenotedMyNotes);
+	if (includeRenotedMyNotesErr) throw 'invalid includeRenotedMyNotes param';
+
+	// Get 'listId' parameter
+	const [listId, listIdErr] = $.type(ID).get(params.listId);
+	if (listIdErr) throw 'invalid listId param';
+
+	const [list, mutedUserIds] = await Promise.all([
+		// リストを取得
+		// Fetch the list
+		UserList.findOne({
+			_id: listId,
+			userId: user._id
+		}),
+
+		// ミュートしているユーザーを取得
+		Mute.find({
+			muterId: user._id
+		}).then(ms => ms.map(m => m.muteeId))
+	]);
+
+	if (list.userIds.length == 0) {
+		return [];
+	}
+
+	//#region Construct query
+	const sort = {
+		_id: -1
+	};
+
+	const listQuery = list.userIds.map(u => ({
+		userId: u,
+
+		// リプライは含めない(ただし投稿者自身の投稿へのリプライ、自分の投稿へのリプライ、自分のリプライは含める)
+		$or: [{
+			// リプライでない
+			replyId: null
+		}, { // または
+			// リプライだが返信先が投稿者自身の投稿
+			$expr: {
+				$eq: ['$_reply.userId', '$userId']
+			}
+		}, { // または
+			// リプライだが返信先が自分(フォロワー)の投稿
+			'_reply.userId': user._id
+		}, { // または
+			// 自分(フォロワー)が送信したリプライ
+			userId: user._id
+		}]
+	}));
+
+	const query = {
+		$and: [{
+			// リストに入っている人のタイムラインへの投稿
+			$or: listQuery,
+
+			// mute
+			userId: {
+				$nin: mutedUserIds
+			},
+			'_reply.userId': {
+				$nin: mutedUserIds
+			},
+			'_renote.userId': {
+				$nin: mutedUserIds
+			},
+		}]
+	} as any;
+
+	// MongoDBではトップレベルで否定ができないため、De Morganの法則を利用してクエリします。
+	// つまり、「『自分の投稿かつRenote』ではない」を「『自分の投稿ではない』または『Renoteではない』」と表現します。
+	// for details: https://en.wikipedia.org/wiki/De_Morgan%27s_laws
+
+	if (includeMyRenotes === false) {
+		query.$and.push({
+			$or: [{
+				userId: { $ne: user._id }
+			}, {
+				renoteId: null
+			}, {
+				text: { $ne: null }
+			}, {
+				mediaIds: { $ne: [] }
+			}, {
+				poll: { $ne: null }
+			}]
+		});
+	}
+
+	if (includeRenotedMyNotes === false) {
+		query.$and.push({
+			$or: [{
+				'_renote.userId': { $ne: user._id }
+			}, {
+				renoteId: null
+			}, {
+				text: { $ne: null }
+			}, {
+				mediaIds: { $ne: [] }
+			}, {
+				poll: { $ne: null }
+			}]
+		});
+	}
+
+	if (sinceId) {
+		sort._id = 1;
+		query._id = {
+			$gt: sinceId
+		};
+	} else if (untilId) {
+		query._id = {
+			$lt: untilId
+		};
+	} else if (sinceDate) {
+		sort._id = 1;
+		query.createdAt = {
+			$gt: new Date(sinceDate)
+		};
+	} else if (untilDate) {
+		query.createdAt = {
+			$lt: new Date(untilDate)
+		};
+	}
+	//#endregion
+
+	// Issue query
+	const timeline = await Note
+		.find(query, {
+			limit: limit,
+			sort: sort
+		});
+
+	// Serialize
+	return await Promise.all(timeline.map(note => pack(note, user)));
+};
diff --git a/src/server/api/endpoints/notifications/get_unread_count.ts b/src/server/api/endpoints/notifications/get_unread_count.ts
new file mode 100644
index 0000000000..600a80d194
--- /dev/null
+++ b/src/server/api/endpoints/notifications/get_unread_count.ts
@@ -0,0 +1,29 @@
+/**
+ * Module dependencies
+ */
+import Notification from '../../../../models/notification';
+import Mute from '../../../../models/mute';
+
+/**
+ * Get count of unread notifications
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	const mute = await Mute.find({
+		muterId: user._id,
+		deletedAt: { $exists: false }
+	});
+	const mutedUserIds = mute.map(m => m.muteeId);
+
+	const count = await Notification
+		.count({
+			notifieeId: user._id,
+			notifierId: {
+				$nin: mutedUserIds
+			},
+			isRead: false
+		});
+
+	res({
+		count: count
+	});
+});
diff --git a/src/server/api/endpoints/notifications/mark_as_read_all.ts b/src/server/api/endpoints/notifications/mark_as_read_all.ts
new file mode 100644
index 0000000000..dce3cb4663
--- /dev/null
+++ b/src/server/api/endpoints/notifications/mark_as_read_all.ts
@@ -0,0 +1,28 @@
+/**
+ * Module dependencies
+ */
+import Notification from '../../../../models/notification';
+import event from '../../../../publishers/stream';
+
+/**
+ * Mark as read all notifications
+ */
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Update documents
+	await Notification.update({
+		notifieeId: user._id,
+		isRead: false
+	}, {
+		$set: {
+			isRead: true
+		}
+	}, {
+		multi: true
+	});
+
+	// Response
+	res();
+
+	// 全ての通知を読みましたよというイベントを発行
+	event(user._id, 'read_all_notifications');
+});
diff --git a/src/server/api/endpoints/othello/games.ts b/src/server/api/endpoints/othello/games.ts
new file mode 100644
index 0000000000..2320a34b04
--- /dev/null
+++ b/src/server/api/endpoints/othello/games.ts
@@ -0,0 +1,62 @@
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import OthelloGame, { pack } from '../../../../models/othello-game';
+
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'my' parameter
+	const [my = false, myErr] = $.bool.optional().get(params.my);
+	if (myErr) return rej('invalid my param');
+
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Get 'sinceId' parameter
+	const [sinceId, sinceIdErr] = $.type(ID).optional().get(params.sinceId);
+	if (sinceIdErr) return rej('invalid sinceId param');
+
+	// Get 'untilId' parameter
+	const [untilId, untilIdErr] = $.type(ID).optional().get(params.untilId);
+	if (untilIdErr) return rej('invalid untilId param');
+
+	// Check if both of sinceId and untilId is specified
+	if (sinceId && untilId) {
+		return rej('cannot set sinceId and untilId');
+	}
+
+	const q: any = my ? {
+		isStarted: true,
+		$or: [{
+			user1Id: user._id
+		}, {
+			user2Id: user._id
+		}]
+	} : {
+		isStarted: true
+	};
+
+	const sort = {
+		_id: -1
+	};
+
+	if (sinceId) {
+		sort._id = 1;
+		q._id = {
+			$gt: sinceId
+		};
+	} else if (untilId) {
+		q._id = {
+			$lt: untilId
+		};
+	}
+
+	// Fetch games
+	const games = await OthelloGame.find(q, {
+		sort,
+		limit
+	});
+
+	// Reponse
+	res(Promise.all(games.map(async (g) => await pack(g, user, {
+		detail: false
+	}))));
+});
diff --git a/src/server/api/endpoints/othello/games/show.ts b/src/server/api/endpoints/othello/games/show.ts
new file mode 100644
index 0000000000..6b2f5ce137
--- /dev/null
+++ b/src/server/api/endpoints/othello/games/show.ts
@@ -0,0 +1,32 @@
+import $ from 'cafy'; import ID from '../../../../../cafy-id';
+import OthelloGame, { pack } from '../../../../../models/othello-game';
+import Othello from '../../../../../othello/core';
+
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'gameId' parameter
+	const [gameId, gameIdErr] = $.type(ID).get(params.gameId);
+	if (gameIdErr) return rej('invalid gameId param');
+
+	const game = await OthelloGame.findOne({ _id: gameId });
+
+	if (game == null) {
+		return rej('game not found');
+	}
+
+	const o = new Othello(game.settings.map, {
+		isLlotheo: game.settings.isLlotheo,
+		canPutEverywhere: game.settings.canPutEverywhere,
+		loopedBoard: game.settings.loopedBoard
+	});
+
+	game.logs.forEach(log => {
+		o.put(log.color, log.pos);
+	});
+
+	const packed = await pack(game, user);
+
+	res(Object.assign({
+		board: o.board,
+		turn: o.turn
+	}, packed));
+});
diff --git a/src/server/api/endpoints/othello/invitations.ts b/src/server/api/endpoints/othello/invitations.ts
new file mode 100644
index 0000000000..4761537614
--- /dev/null
+++ b/src/server/api/endpoints/othello/invitations.ts
@@ -0,0 +1,15 @@
+import Matching, { pack as packMatching } from '../../../../models/othello-matching';
+
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Find session
+	const invitations = await Matching.find({
+		childId: user._id
+	}, {
+		sort: {
+			_id: -1
+		}
+	});
+
+	// Reponse
+	res(Promise.all(invitations.map(async (i) => await packMatching(i, user))));
+});
diff --git a/src/server/api/endpoints/othello/match.ts b/src/server/api/endpoints/othello/match.ts
new file mode 100644
index 0000000000..e70e579755
--- /dev/null
+++ b/src/server/api/endpoints/othello/match.ts
@@ -0,0 +1,95 @@
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import Matching, { pack as packMatching } from '../../../../models/othello-matching';
+import OthelloGame, { pack as packGame } from '../../../../models/othello-game';
+import User from '../../../../models/user';
+import publishUserStream, { publishOthelloStream } from '../../../../publishers/stream';
+import { eighteight } from '../../../../othello/maps';
+
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	// Get 'userId' parameter
+	const [childId, childIdErr] = $.type(ID).get(params.userId);
+	if (childIdErr) return rej('invalid userId param');
+
+	// Myself
+	if (childId.equals(user._id)) {
+		return rej('invalid userId param');
+	}
+
+	// Find session
+	const exist = await Matching.findOne({
+		parentId: childId,
+		childId: user._id
+	});
+
+	if (exist) {
+		// Destroy session
+		Matching.remove({
+			_id: exist._id
+		});
+
+		// Create game
+		const game = await OthelloGame.insert({
+			createdAt: new Date(),
+			user1Id: exist.parentId,
+			user2Id: user._id,
+			user1Accepted: false,
+			user2Accepted: false,
+			isStarted: false,
+			isEnded: false,
+			logs: [],
+			settings: {
+				map: eighteight.data,
+				bw: 'random',
+				isLlotheo: false
+			}
+		});
+
+		// Reponse
+		res(await packGame(game, user));
+
+		publishOthelloStream(exist.parentId, 'matched', await packGame(game, exist.parentId));
+
+		const other = await Matching.count({
+			childId: user._id
+		});
+
+		if (other == 0) {
+			publishUserStream(user._id, 'othello_no_invites');
+		}
+	} else {
+		// Fetch child
+		const child = await User.findOne({
+			_id: childId
+		}, {
+			fields: {
+				_id: true
+			}
+		});
+
+		if (child === null) {
+			return rej('user not found');
+		}
+
+		// 以前のセッションはすべて削除しておく
+		await Matching.remove({
+			parentId: user._id
+		});
+
+		// セッションを作成
+		const matching = await Matching.insert({
+			createdAt: new Date(),
+			parentId: user._id,
+			childId: child._id
+		});
+
+		// Reponse
+		res();
+
+		const packed = await packMatching(matching, child);
+
+		// 招待
+		publishOthelloStream(child._id, 'invited', packed);
+
+		publishUserStream(child._id, 'othello_invited', packed);
+	}
+});
diff --git a/src/server/api/endpoints/othello/match/cancel.ts b/src/server/api/endpoints/othello/match/cancel.ts
new file mode 100644
index 0000000000..562e691061
--- /dev/null
+++ b/src/server/api/endpoints/othello/match/cancel.ts
@@ -0,0 +1,9 @@
+import Matching from '../../../../../models/othello-matching';
+
+module.exports = (params, user) => new Promise(async (res, rej) => {
+	await Matching.remove({
+		parentId: user._id
+	});
+
+	res();
+});
diff --git a/src/server/api/endpoints/stats.ts b/src/server/api/endpoints/stats.ts
new file mode 100644
index 0000000000..52e5195484
--- /dev/null
+++ b/src/server/api/endpoints/stats.ts
@@ -0,0 +1,48 @@
+/**
+ * Module dependencies
+ */
+import Note from '../../../models/note';
+import User from '../../../models/user';
+
+/**
+ * @swagger
+ * /stats:
+ *   note:
+ *     summary: Show the misskey's statistics
+ *     responses:
+ *       200:
+ *         description: Success
+ *         schema:
+ *           type: object
+ *           properties:
+ *             notesCount:
+ *               description: count of all notes of misskey
+ *               type: number
+ *             usersCount:
+ *               description: count of all users of misskey
+ *               type: number
+ *
+ *       default:
+ *         description: Failed
+ *         schema:
+ *           $ref: "#/definitions/Error"
+ */
+
+/**
+ * Show the misskey's statistics
+ *
+ * @param {any} params
+ * @return {Promise<any>}
+ */
+module.exports = params => new Promise(async (res, rej) => {
+	const notesCount = await Note
+		.count();
+
+	const usersCount = await User
+		.count();
+
+	res({
+		notesCount: notesCount,
+		usersCount: usersCount
+	});
+});
diff --git a/src/server/api/endpoints/sw/register.ts b/src/server/api/endpoints/sw/register.ts
new file mode 100644
index 0000000000..b22a8b08ef
--- /dev/null
+++ b/src/server/api/endpoints/sw/register.ts
@@ -0,0 +1,44 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy';
+import Subscription from '../../../../models/sw-subscription';
+
+/**
+ * subscribe service worker
+ */
+module.exports = async (params, user, app) => new Promise(async (res, rej) => {
+	// Get 'endpoint' parameter
+	const [endpoint, endpointErr] = $.str.get(params.endpoint);
+	if (endpointErr) return rej('invalid endpoint param');
+
+	// Get 'auth' parameter
+	const [auth, authErr] = $.str.get(params.auth);
+	if (authErr) return rej('invalid auth param');
+
+	// Get 'publickey' parameter
+	const [publickey, publickeyErr] = $.str.get(params.publickey);
+	if (publickeyErr) return rej('invalid publickey param');
+
+	// if already subscribed
+	const exist = await Subscription.findOne({
+		userId: user._id,
+		endpoint: endpoint,
+		auth: auth,
+		publickey: publickey,
+		deletedAt: { $exists: false }
+	});
+
+	if (exist !== null) {
+		return res();
+	}
+
+	await Subscription.insert({
+		userId: user._id,
+		endpoint: endpoint,
+		auth: auth,
+		publickey: publickey
+	});
+
+	res();
+});
diff --git a/src/server/api/endpoints/username/available.ts b/src/server/api/endpoints/username/available.ts
new file mode 100644
index 0000000000..b11bec4e58
--- /dev/null
+++ b/src/server/api/endpoints/username/available.ts
@@ -0,0 +1,32 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy';
+import User from '../../../../models/user';
+import { validateUsername } from '../../../../models/user';
+
+/**
+ * Check available username
+ *
+ * @param {any} params
+ * @return {Promise<any>}
+ */
+module.exports = async (params) => new Promise(async (res, rej) => {
+	// Get 'username' parameter
+	const [username, usernameError] = $.str.pipe(validateUsername).get(params.username);
+	if (usernameError) return rej('invalid username param');
+
+	// Get exist
+	const exist = await User
+		.count({
+			host: null,
+			usernameLower: username.toLowerCase()
+		}, {
+			limit: 1
+		});
+
+	// Reply
+	res({
+		available: exist === 0
+	});
+});
diff --git a/src/server/api/endpoints/users.ts b/src/server/api/endpoints/users.ts
new file mode 100644
index 0000000000..eb581cb7e6
--- /dev/null
+++ b/src/server/api/endpoints/users.ts
@@ -0,0 +1,54 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy';
+import User, { pack } from '../../../models/user';
+
+/**
+ * Lists all users
+ */
+module.exports = (params, me) => new Promise(async (res, rej) => {
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Get 'offset' parameter
+	const [offset = 0, offsetErr] = $.num.optional().min(0).get(params.offset);
+	if (offsetErr) return rej('invalid offset param');
+
+	// Get 'sort' parameter
+	const [sort, sortError] = $.str.optional().or('+follower|-follower').get(params.sort);
+	if (sortError) return rej('invalid sort param');
+
+	// Construct query
+	let _sort;
+	if (sort) {
+		if (sort == '+follower') {
+			_sort = {
+				followersCount: -1
+			};
+		} else if (sort == '-follower') {
+			_sort = {
+				followersCount: 1
+			};
+		}
+	} else {
+		_sort = {
+			_id: -1
+		};
+	}
+
+	// Issue query
+	const users = await User
+		.find({
+			host: null
+		}, {
+			limit: limit,
+			sort: _sort,
+			skip: offset
+		});
+
+	// Serialize
+	res(await Promise.all(users.map(async user =>
+		await pack(user, me))));
+});
diff --git a/src/server/api/endpoints/users/followers.ts b/src/server/api/endpoints/users/followers.ts
new file mode 100644
index 0000000000..810cd7341b
--- /dev/null
+++ b/src/server/api/endpoints/users/followers.ts
@@ -0,0 +1,87 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import User from '../../../../models/user';
+import Following from '../../../../models/following';
+import { pack } from '../../../../models/user';
+import { getFriendIds } from '../../common/get-friends';
+
+/**
+ * Get followers of a user
+ */
+module.exports = (params, me) => new Promise(async (res, rej) => {
+	// Get 'userId' parameter
+	const [userId, userIdErr] = $.type(ID).get(params.userId);
+	if (userIdErr) return rej('invalid userId param');
+
+	// Get 'iknow' parameter
+	const [iknow = false, iknowErr] = $.bool.optional().get(params.iknow);
+	if (iknowErr) return rej('invalid iknow param');
+
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Get 'cursor' parameter
+	const [cursor = null, cursorErr] = $.type(ID).optional().get(params.cursor);
+	if (cursorErr) return rej('invalid cursor param');
+
+	// Lookup user
+	const user = await User.findOne({
+		_id: userId
+	}, {
+		fields: {
+			_id: true
+		}
+	});
+
+	if (user === null) {
+		return rej('user not found');
+	}
+
+	// Construct query
+	const query = {
+		followeeId: user._id
+	} as any;
+
+	// ログインしていてかつ iknow フラグがあるとき
+	if (me && iknow) {
+		// Get my friends
+		const myFriends = await getFriendIds(me._id);
+
+		query.followerId = {
+			$in: myFriends
+		};
+	}
+
+	// カーソルが指定されている場合
+	if (cursor) {
+		query._id = {
+			$lt: cursor
+		};
+	}
+
+	// Get followers
+	const following = await Following
+		.find(query, {
+			limit: limit + 1,
+			sort: { _id: -1 }
+		});
+
+	// 「次のページ」があるかどうか
+	const inStock = following.length === limit + 1;
+	if (inStock) {
+		following.pop();
+	}
+
+	// Serialize
+	const users = await Promise.all(following.map(async f =>
+		await pack(f.followerId, me, { detail: true })));
+
+	// Response
+	res({
+		users: users,
+		next: inStock ? following[following.length - 1]._id : null,
+	});
+});
diff --git a/src/server/api/endpoints/users/following.ts b/src/server/api/endpoints/users/following.ts
new file mode 100644
index 0000000000..3373b9d632
--- /dev/null
+++ b/src/server/api/endpoints/users/following.ts
@@ -0,0 +1,91 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import User from '../../../../models/user';
+import Following from '../../../../models/following';
+import { pack } from '../../../../models/user';
+import { getFriendIds } from '../../common/get-friends';
+
+/**
+ * Get following users of a user
+ *
+ * @param {any} params
+ * @param {any} me
+ * @return {Promise<any>}
+ */
+module.exports = (params, me) => new Promise(async (res, rej) => {
+	// Get 'userId' parameter
+	const [userId, userIdErr] = $.type(ID).get(params.userId);
+	if (userIdErr) return rej('invalid userId param');
+
+	// Get 'iknow' parameter
+	const [iknow = false, iknowErr] = $.bool.optional().get(params.iknow);
+	if (iknowErr) return rej('invalid iknow param');
+
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Get 'cursor' parameter
+	const [cursor = null, cursorErr] = $.type(ID).optional().get(params.cursor);
+	if (cursorErr) return rej('invalid cursor param');
+
+	// Lookup user
+	const user = await User.findOne({
+		_id: userId
+	}, {
+		fields: {
+			_id: true
+		}
+	});
+
+	if (user === null) {
+		return rej('user not found');
+	}
+
+	// Construct query
+	const query = {
+		followerId: user._id
+	} as any;
+
+	// ログインしていてかつ iknow フラグがあるとき
+	if (me && iknow) {
+		// Get my friends
+		const myFriends = await getFriendIds(me._id);
+
+		query.followeeId = {
+			$in: myFriends
+		};
+	}
+
+	// カーソルが指定されている場合
+	if (cursor) {
+		query._id = {
+			$lt: cursor
+		};
+	}
+
+	// Get followers
+	const following = await Following
+		.find(query, {
+			limit: limit + 1,
+			sort: { _id: -1 }
+		});
+
+	// 「次のページ」があるかどうか
+	const inStock = following.length === limit + 1;
+	if (inStock) {
+		following.pop();
+	}
+
+	// Serialize
+	const users = await Promise.all(following.map(async f =>
+		await pack(f.followeeId, me, { detail: true })));
+
+	// Response
+	res({
+		users: users,
+		next: inStock ? following[following.length - 1]._id : null,
+	});
+});
diff --git a/src/server/api/endpoints/users/get_frequently_replied_users.ts b/src/server/api/endpoints/users/get_frequently_replied_users.ts
new file mode 100644
index 0000000000..64d737a06b
--- /dev/null
+++ b/src/server/api/endpoints/users/get_frequently_replied_users.ts
@@ -0,0 +1,99 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import Note from '../../../../models/note';
+import User, { pack } from '../../../../models/user';
+
+module.exports = (params, me) => new Promise(async (res, rej) => {
+	// Get 'userId' parameter
+	const [userId, userIdErr] = $.type(ID).get(params.userId);
+	if (userIdErr) return rej('invalid userId param');
+
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Lookup user
+	const user = await User.findOne({
+		_id: userId
+	}, {
+		fields: {
+			_id: true
+		}
+	});
+
+	if (user === null) {
+		return rej('user not found');
+	}
+
+	// Fetch recent notes
+	const recentNotes = await Note.find({
+		userId: user._id,
+		replyId: {
+			$exists: true,
+			$ne: null
+		}
+	}, {
+		sort: {
+			_id: -1
+		},
+		limit: 1000,
+		fields: {
+			_id: false,
+			replyId: true
+		}
+	});
+
+	// 投稿が少なかったら中断
+	if (recentNotes.length === 0) {
+		return res([]);
+	}
+
+	const replyTargetNotes = await Note.find({
+		_id: {
+			$in: recentNotes.map(p => p.replyId)
+		},
+		userId: {
+			$ne: user._id
+		}
+	}, {
+		fields: {
+			_id: false,
+			userId: true
+		}
+	});
+
+	const repliedUsers = {};
+
+	// Extract replies from recent notes
+	replyTargetNotes.forEach(note => {
+		const userId = note.userId.toString();
+		if (repliedUsers[userId]) {
+			repliedUsers[userId]++;
+		} else {
+			repliedUsers[userId] = 1;
+		}
+	});
+
+	// Calc peak
+	let peak = 0;
+	Object.keys(repliedUsers).forEach(user => {
+		if (repliedUsers[user] > peak) peak = repliedUsers[user];
+	});
+
+	// Sort replies by frequency
+	const repliedUsersSorted = Object.keys(repliedUsers).sort((a, b) => repliedUsers[b] - repliedUsers[a]);
+
+	// Extract top replied users
+	const topRepliedUsers = repliedUsersSorted.slice(0, limit);
+
+	// Make replies object (includes weights)
+	const repliesObj = await Promise.all(topRepliedUsers.map(async (user) => ({
+		user: await pack(user, me, { detail: true }),
+		weight: repliedUsers[user] / peak
+	})));
+
+	// Response
+	res(repliesObj);
+});
diff --git a/src/server/api/endpoints/users/lists/create.ts b/src/server/api/endpoints/users/lists/create.ts
new file mode 100644
index 0000000000..100a78b872
--- /dev/null
+++ b/src/server/api/endpoints/users/lists/create.ts
@@ -0,0 +1,25 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy';
+import UserList, { pack } from '../../../../../models/user-list';
+
+/**
+ * Create a user list
+ */
+module.exports = async (params, user) => new Promise(async (res, rej) => {
+	// Get 'title' parameter
+	const [title, titleErr] = $.str.range(1, 100).get(params.title);
+	if (titleErr) return rej('invalid title param');
+
+	// insert
+	const userList = await UserList.insert({
+		createdAt: new Date(),
+		userId: user._id,
+		title: title,
+		userIds: []
+	});
+
+	// Response
+	res(await pack(userList));
+});
diff --git a/src/server/api/endpoints/users/lists/list.ts b/src/server/api/endpoints/users/lists/list.ts
new file mode 100644
index 0000000000..d19339a1f5
--- /dev/null
+++ b/src/server/api/endpoints/users/lists/list.ts
@@ -0,0 +1,13 @@
+import UserList, { pack } from '../../../../../models/user-list';
+
+/**
+ * Add a user to a user list
+ */
+module.exports = async (params, me) => new Promise(async (res, rej) => {
+	// Fetch lists
+	const userLists = await UserList.find({
+		userId: me._id,
+	});
+
+	res(await Promise.all(userLists.map(x => pack(x))));
+});
diff --git a/src/server/api/endpoints/users/lists/push.ts b/src/server/api/endpoints/users/lists/push.ts
new file mode 100644
index 0000000000..da5a9a134c
--- /dev/null
+++ b/src/server/api/endpoints/users/lists/push.ts
@@ -0,0 +1,61 @@
+import $ from 'cafy'; import ID from '../../../../../cafy-id';
+import UserList from '../../../../../models/user-list';
+import User, { pack as packUser, isRemoteUser, getGhost } from '../../../../../models/user';
+import { publishUserListStream } from '../../../../../publishers/stream';
+import ap from '../../../../../remote/activitypub/renderer';
+import renderFollow from '../../../../../remote/activitypub/renderer/follow';
+import { deliver } from '../../../../../queue';
+
+/**
+ * Add a user to a user list
+ */
+module.exports = async (params, me) => new Promise(async (res, rej) => {
+	// Get 'listId' parameter
+	const [listId, listIdErr] = $.type(ID).get(params.listId);
+	if (listIdErr) return rej('invalid listId param');
+
+	// Fetch the list
+	const userList = await UserList.findOne({
+		_id: listId,
+		userId: me._id,
+	});
+
+	if (userList == null) {
+		return rej('list not found');
+	}
+
+	// Get 'userId' parameter
+	const [userId, userIdErr] = $.type(ID).get(params.userId);
+	if (userIdErr) return rej('invalid userId param');
+
+	// Fetch the user
+	const user = await User.findOne({
+		_id: userId
+	});
+
+	if (user == null) {
+		return rej('user not found');
+	}
+
+	if (userList.userIds.map(id => id.toHexString()).includes(user._id.toHexString())) {
+		return rej('the user already added');
+	}
+
+	// Push the user
+	await UserList.update({ _id: userList._id }, {
+		$push: {
+			userIds: user._id
+		}
+	});
+
+	res();
+
+	publishUserListStream(userList._id, 'userAdded', await packUser(user));
+
+	// このインスタンス内にこのリモートユーザーをフォローしているユーザーがいなくても投稿を受け取るためにダミーのユーザーがフォローしたということにする
+	if (isRemoteUser(user)) {
+		const ghost = await getGhost();
+		const content = ap(renderFollow(ghost, user));
+		deliver(ghost, content, user.inbox);
+	}
+});
diff --git a/src/server/api/endpoints/users/lists/show.ts b/src/server/api/endpoints/users/lists/show.ts
new file mode 100644
index 0000000000..16cb3382fd
--- /dev/null
+++ b/src/server/api/endpoints/users/lists/show.ts
@@ -0,0 +1,23 @@
+import $ from 'cafy'; import ID from '../../../../../cafy-id';
+import UserList, { pack } from '../../../../../models/user-list';
+
+/**
+ * Show a user list
+ */
+module.exports = async (params, me) => new Promise(async (res, rej) => {
+	// Get 'listId' parameter
+	const [listId, listIdErr] = $.type(ID).get(params.listId);
+	if (listIdErr) return rej('invalid listId param');
+
+	// Fetch the list
+	const userList = await UserList.findOne({
+		_id: listId,
+		userId: me._id,
+	});
+
+	if (userList == null) {
+		return rej('list not found');
+	}
+
+	res(await pack(userList));
+});
diff --git a/src/server/api/endpoints/users/notes.ts b/src/server/api/endpoints/users/notes.ts
new file mode 100644
index 0000000000..061c363d0f
--- /dev/null
+++ b/src/server/api/endpoints/users/notes.ts
@@ -0,0 +1,133 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import getHostLower from '../../common/get-host-lower';
+import Note, { pack } from '../../../../models/note';
+import User from '../../../../models/user';
+
+/**
+ * Get notes of a user
+ */
+module.exports = (params, me) => new Promise(async (res, rej) => {
+	// Get 'userId' parameter
+	const [userId, userIdErr] = $.type(ID).optional().get(params.userId);
+	if (userIdErr) return rej('invalid userId param');
+
+	// Get 'username' parameter
+	const [username, usernameErr] = $.str.optional().get(params.username);
+	if (usernameErr) return rej('invalid username param');
+
+	if (userId === undefined && username === undefined) {
+		return rej('userId or pair of username and host is required');
+	}
+
+	// Get 'host' parameter
+	const [host, hostErr] = $.str.optional().get(params.host);
+	if (hostErr) return rej('invalid host param');
+
+	if (userId === undefined && host === undefined) {
+		return rej('userId or pair of username and host is required');
+	}
+
+	// Get 'includeReplies' parameter
+	const [includeReplies = true, includeRepliesErr] = $.bool.optional().get(params.includeReplies);
+	if (includeRepliesErr) return rej('invalid includeReplies param');
+
+	// Get 'withMedia' parameter
+	const [withMedia = false, withMediaErr] = $.bool.optional().get(params.withMedia);
+	if (withMediaErr) return rej('invalid withMedia param');
+
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Get 'sinceId' parameter
+	const [sinceId, sinceIdErr] = $.type(ID).optional().get(params.sinceId);
+	if (sinceIdErr) return rej('invalid sinceId param');
+
+	// Get 'untilId' parameter
+	const [untilId, untilIdErr] = $.type(ID).optional().get(params.untilId);
+	if (untilIdErr) return rej('invalid untilId param');
+
+	// Get 'sinceDate' parameter
+	const [sinceDate, sinceDateErr] = $.num.optional().get(params.sinceDate);
+	if (sinceDateErr) throw 'invalid sinceDate param';
+
+	// Get 'untilDate' parameter
+	const [untilDate, untilDateErr] = $.num.optional().get(params.untilDate);
+	if (untilDateErr) throw 'invalid untilDate param';
+
+	// Check if only one of sinceId, untilId, sinceDate, untilDate specified
+	if ([sinceId, untilId, sinceDate, untilDate].filter(x => x != null).length > 1) {
+		throw 'only one of sinceId, untilId, sinceDate, untilDate can be specified';
+	}
+
+	const q = userId !== undefined
+		? { _id: userId }
+		: { usernameLower: username.toLowerCase(), host: getHostLower(host) } ;
+
+	// Lookup user
+	const user = await User.findOne(q, {
+		fields: {
+			_id: true
+		}
+	});
+
+	if (user === null) {
+		return rej('user not found');
+	}
+
+	//#region Construct query
+	const sort = {
+		_id: -1
+	};
+
+	const query = {
+		userId: user._id
+	} as any;
+
+	if (sinceId) {
+		sort._id = 1;
+		query._id = {
+			$gt: sinceId
+		};
+	} else if (untilId) {
+		query._id = {
+			$lt: untilId
+		};
+	} else if (sinceDate) {
+		sort._id = 1;
+		query.createdAt = {
+			$gt: new Date(sinceDate)
+		};
+	} else if (untilDate) {
+		query.createdAt = {
+			$lt: new Date(untilDate)
+		};
+	}
+
+	if (!includeReplies) {
+		query.replyId = null;
+	}
+
+	if (withMedia) {
+		query.mediaIds = {
+			$exists: true,
+			$ne: []
+		};
+	}
+	//#endregion
+
+	// Issue query
+	const notes = await Note
+		.find(query, {
+			limit: limit,
+			sort: sort
+		});
+
+	// Serialize
+	res(await Promise.all(notes.map(async (note) =>
+		await pack(note, me)
+	)));
+});
diff --git a/src/server/api/endpoints/users/recommendation.ts b/src/server/api/endpoints/users/recommendation.ts
new file mode 100644
index 0000000000..620ae17ca2
--- /dev/null
+++ b/src/server/api/endpoints/users/recommendation.ts
@@ -0,0 +1,57 @@
+/**
+ * Module dependencies
+ */
+const ms = require('ms');
+import $ from 'cafy';
+import User, { pack } from '../../../../models/user';
+import { getFriendIds } from '../../common/get-friends';
+import Mute from '../../../../models/mute';
+
+/**
+ * Get recommended users
+ *
+ * @param {any} params
+ * @param {any} me
+ * @return {Promise<any>}
+ */
+module.exports = (params, me) => new Promise(async (res, rej) => {
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	// Get 'offset' parameter
+	const [offset = 0, offsetErr] = $.num.optional().min(0).get(params.offset);
+	if (offsetErr) return rej('invalid offset param');
+
+	// ID list of the user itself and other users who the user follows
+	const followingIds = await getFriendIds(me._id);
+
+	// ミュートしているユーザーを取得
+	const mutedUserIds = (await Mute.find({
+		muterId: me._id
+	})).map(m => m.muteeId);
+
+	const users = await User
+		.find({
+			_id: {
+				$nin: followingIds.concat(mutedUserIds)
+			},
+			$or: [{
+				lastUsedAt: {
+					$gte: new Date(Date.now() - ms('7days'))
+				}
+			}, {
+				host: null
+			}]
+		}, {
+			limit: limit,
+			skip: offset,
+			sort: {
+				followersCount: -1
+			}
+		});
+
+	// Serialize
+	res(await Promise.all(users.map(async user =>
+		await pack(user, me, { detail: true }))));
+});
diff --git a/src/server/api/endpoints/users/search.ts b/src/server/api/endpoints/users/search.ts
new file mode 100644
index 0000000000..cfbdc337bf
--- /dev/null
+++ b/src/server/api/endpoints/users/search.ts
@@ -0,0 +1,98 @@
+/**
+ * Module dependencies
+ */
+import * as mongo from 'mongodb';
+import $ from 'cafy';
+import User, { pack } from '../../../../models/user';
+import config from '../../../../config';
+const escapeRegexp = require('escape-regexp');
+
+/**
+ * Search a user
+ *
+ * @param {any} params
+ * @param {any} me
+ * @return {Promise<any>}
+ */
+module.exports = (params, me) => new Promise(async (res, rej) => {
+	// Get 'query' parameter
+	const [query, queryError] = $.str.pipe(x => x != '').get(params.query);
+	if (queryError) return rej('invalid query param');
+
+	// Get 'offset' parameter
+	const [offset = 0, offsetErr] = $.num.optional().min(0).get(params.offset);
+	if (offsetErr) return rej('invalid offset param');
+
+	// Get 'max' parameter
+	const [max = 10, maxErr] = $.num.optional().range(1, 30).get(params.max);
+	if (maxErr) return rej('invalid max param');
+
+	// If Elasticsearch is available, search by $
+	// If not, search by MongoDB
+	(config.elasticsearch.enable ? byElasticsearch : byNative)
+		(res, rej, me, query, offset, max);
+});
+
+// Search by MongoDB
+async function byNative(res, rej, me, query, offset, max) {
+	const escapedQuery = escapeRegexp(query);
+
+	// Search users
+	const users = await User
+		.find({
+			$or: [{
+				usernameLower: new RegExp(escapedQuery.replace('@', '').toLowerCase())
+			}, {
+				name: new RegExp(escapedQuery)
+			}]
+		}, {
+			limit: max
+		});
+
+	// Serialize
+	res(await Promise.all(users.map(async user =>
+		await pack(user, me, { detail: true }))));
+}
+
+// Search by Elasticsearch
+async function byElasticsearch(res, rej, me, query, offset, max) {
+	const es = require('../../db/elasticsearch');
+
+	es.search({
+		index: 'misskey',
+		type: 'user',
+		body: {
+			size: max,
+			from: offset,
+			query: {
+				simple_query_string: {
+					fields: ['username', 'name', 'bio'],
+					query: query,
+					default_operator: 'and'
+				}
+			}
+		}
+	}, async (error, response) => {
+		if (error) {
+			console.error(error);
+			return res(500);
+		}
+
+		if (response.hits.total === 0) {
+			return res([]);
+		}
+
+		const hits = response.hits.hits.map(hit => new mongo.ObjectID(hit._id));
+
+		const users = await User
+			.find({
+				_id: {
+					$in: hits
+				}
+			});
+
+		// Serialize
+		res(await Promise.all(users.map(async user =>
+			await pack(user, me, { detail: true }))));
+	});
+}
diff --git a/src/server/api/endpoints/users/search_by_username.ts b/src/server/api/endpoints/users/search_by_username.ts
new file mode 100644
index 0000000000..5927d00faf
--- /dev/null
+++ b/src/server/api/endpoints/users/search_by_username.ts
@@ -0,0 +1,34 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy';
+import User, { pack } from '../../../../models/user';
+
+/**
+ * Search a user by username
+ */
+module.exports = (params, me) => new Promise(async (res, rej) => {
+	// Get 'query' parameter
+	const [query, queryError] = $.str.get(params.query);
+	if (queryError) return rej('invalid query param');
+
+	// Get 'offset' parameter
+	const [offset = 0, offsetErr] = $.num.optional().min(0).get(params.offset);
+	if (offsetErr) return rej('invalid offset param');
+
+	// Get 'limit' parameter
+	const [limit = 10, limitErr] = $.num.optional().range(1, 100).get(params.limit);
+	if (limitErr) return rej('invalid limit param');
+
+	const users = await User
+		.find({
+			usernameLower: new RegExp(query.toLowerCase())
+		}, {
+			limit: limit,
+			skip: offset
+		});
+
+	// Serialize
+	res(await Promise.all(users.map(async user =>
+		await pack(user, me, { detail: true }))));
+});
diff --git a/src/server/api/endpoints/users/show.ts b/src/server/api/endpoints/users/show.ts
new file mode 100644
index 0000000000..b8c6ff25c4
--- /dev/null
+++ b/src/server/api/endpoints/users/show.ts
@@ -0,0 +1,68 @@
+/**
+ * Module dependencies
+ */
+import $ from 'cafy'; import ID from '../../../../cafy-id';
+import User, { pack } from '../../../../models/user';
+import resolveRemoteUser from '../../../../remote/resolve-user';
+
+const cursorOption = { fields: { data: false } };
+
+/**
+ * Show user(s)
+ */
+module.exports = (params, me) => new Promise(async (res, rej) => {
+	let user;
+
+	// Get 'userId' parameter
+	const [userId, userIdErr] = $.type(ID).optional().get(params.userId);
+	if (userIdErr) return rej('invalid userId param');
+
+	// Get 'userIds' parameter
+	const [userIds, userIdsErr] = $.arr($.type(ID)).optional().get(params.userIds);
+	if (userIdsErr) return rej('invalid userIds param');
+
+	// Get 'username' parameter
+	const [username, usernameErr] = $.str.optional().get(params.username);
+	if (usernameErr) return rej('invalid username param');
+
+	// Get 'host' parameter
+	const [host, hostErr] = $.str.optional().nullable().get(params.host);
+	if (hostErr) return rej('invalid host param');
+
+	if (userIds) {
+		const users = await User.find({
+			_id: {
+				$in: userIds
+			}
+		});
+
+		res(await Promise.all(users.map(u => pack(u, me, {
+			detail: true
+		}))));
+	} else {
+		// Lookup user
+		if (typeof host === 'string') {
+			try {
+				user = await resolveRemoteUser(username, host, cursorOption);
+			} catch (e) {
+				console.warn(`failed to resolve remote user: ${e}`);
+				return rej('failed to resolve remote user');
+			}
+		} else {
+			const q = userId !== undefined
+				? { _id: userId }
+				: { usernameLower: username.toLowerCase(), host: null };
+
+			user = await User.findOne(q, cursorOption);
+
+			if (user === null) {
+				return rej('user not found');
+			}
+		}
+
+		// Send response
+		res(await pack(user, me, {
+			detail: true
+		}));
+	}
+});
diff --git a/src/server/api/index.ts b/src/server/api/index.ts
new file mode 100644
index 0000000000..009c99acae
--- /dev/null
+++ b/src/server/api/index.ts
@@ -0,0 +1,47 @@
+/**
+ * API Server
+ */
+
+import * as Koa from 'koa';
+import * as Router from 'koa-router';
+import * as multer from 'koa-multer';
+import * as bodyParser from 'koa-bodyparser';
+
+import endpoints from './endpoints';
+
+const handler = require('./api-handler').default;
+
+// Init app
+const app = new Koa();
+app.use(bodyParser({
+	// リクエストが multipart/form-data でない限りはJSONだと見なす
+	detectJSON: ctx => !ctx.is('multipart/form-data')
+}));
+
+// Init multer instance
+const upload = multer({
+	storage: multer.diskStorage({})
+});
+
+// Init router
+const router = new Router();
+
+/**
+ * Register endpoint handlers
+ */
+endpoints.forEach(endpoint => endpoint.withFile
+	? router.post(`/${endpoint.name}`, upload.single('file'), handler.bind(null, endpoint))
+	: router.post(`/${endpoint.name}`, handler.bind(null, endpoint))
+);
+
+router.post('/signup', require('./private/signup').default);
+router.post('/signin', require('./private/signin').default);
+
+router.use(require('./service/github').routes());
+router.use(require('./service/twitter').routes());
+router.use(require('./bot/interfaces/line').routes());
+
+// Register router
+app.use(router.routes());
+
+module.exports = app;
diff --git a/src/server/api/limitter.ts b/src/server/api/limitter.ts
new file mode 100644
index 0000000000..b84e16ecde
--- /dev/null
+++ b/src/server/api/limitter.ts
@@ -0,0 +1,83 @@
+import * as Limiter from 'ratelimiter';
+import * as debug from 'debug';
+import limiterDB from '../../db/redis';
+import { Endpoint } from './endpoints';
+import getAcct from '../../acct/render';
+import { IUser } from '../../models/user';
+
+const log = debug('misskey:limitter');
+
+export default (endpoint: Endpoint, user: IUser) => new Promise((ok, reject) => {
+	const limitation = endpoint.limit;
+
+	const key = limitation.hasOwnProperty('key')
+		? limitation.key
+		: endpoint.name;
+
+	const hasShortTermLimit =
+		limitation.hasOwnProperty('minInterval');
+
+	const hasLongTermLimit =
+		limitation.hasOwnProperty('duration') &&
+		limitation.hasOwnProperty('max');
+
+	if (hasShortTermLimit) {
+		min();
+	} else if (hasLongTermLimit) {
+		max();
+	} else {
+		ok();
+	}
+
+	// Short-term limit
+	function min() {
+		const minIntervalLimiter = new Limiter({
+			id: `${user._id}:${key}:min`,
+			duration: limitation.minInterval,
+			max: 1,
+			db: limiterDB
+		});
+
+		minIntervalLimiter.get((err, info) => {
+			if (err) {
+				return reject('ERR');
+			}
+
+			log(`@${getAcct(user)} ${endpoint.name} min remaining: ${info.remaining}`);
+
+			if (info.remaining === 0) {
+				reject('BRIEF_REQUEST_INTERVAL');
+			} else {
+				if (hasLongTermLimit) {
+					max();
+				} else {
+					ok();
+				}
+			}
+		});
+	}
+
+	// Long term limit
+	function max() {
+		const limiter = new Limiter({
+			id: `${user._id}:${key}`,
+			duration: limitation.duration,
+			max: limitation.max,
+			db: limiterDB
+		});
+
+		limiter.get((err, info) => {
+			if (err) {
+				return reject('ERR');
+			}
+
+			log(`@${getAcct(user)} ${endpoint.name} max remaining: ${info.remaining}`);
+
+			if (info.remaining === 0) {
+				reject('RATE_LIMIT_EXCEEDED');
+			} else {
+				ok();
+			}
+		});
+	}
+});
diff --git a/src/server/api/private/signin.ts b/src/server/api/private/signin.ts
new file mode 100644
index 0000000000..5450c7ad27
--- /dev/null
+++ b/src/server/api/private/signin.ts
@@ -0,0 +1,89 @@
+import * as Koa from 'koa';
+import * as bcrypt from 'bcryptjs';
+import * as speakeasy from 'speakeasy';
+import User, { ILocalUser } from '../../../models/user';
+import Signin, { pack } from '../../../models/signin';
+import event from '../../../publishers/stream';
+import signin from '../common/signin';
+import config from '../../../config';
+
+export default async (ctx: Koa.Context) => {
+	ctx.set('Access-Control-Allow-Origin', config.url);
+	ctx.set('Access-Control-Allow-Credentials', 'true');
+
+	const username = ctx.request.body['username'];
+	const password = ctx.request.body['password'];
+	const token = ctx.request.body['token'];
+
+	if (typeof username != 'string') {
+		ctx.status = 400;
+		return;
+	}
+
+	if (typeof password != 'string') {
+		ctx.status = 400;
+		return;
+	}
+
+	if (token != null && typeof token != 'string') {
+		ctx.status = 400;
+		return;
+	}
+
+	// Fetch user
+	const user = await User.findOne({
+		usernameLower: username.toLowerCase(),
+		host: null
+	}, {
+		fields: {
+			data: false,
+			profile: false
+		}
+	}) as ILocalUser;
+
+	if (user === null) {
+		ctx.throw(404, {
+			error: 'user not found'
+		});
+		return;
+	}
+
+	// Compare password
+	const same = await bcrypt.compare(password, user.password);
+
+	if (same) {
+		if (user.twoFactorEnabled) {
+			const verified = (speakeasy as any).totp.verify({
+				secret: user.twoFactorSecret,
+				encoding: 'base32',
+				token: token
+			});
+
+			if (verified) {
+				signin(ctx, user);
+			} else {
+				ctx.throw(400, {
+					error: 'invalid token'
+				});
+			}
+		} else {
+			signin(ctx, user);
+		}
+	} else {
+		ctx.throw(400, {
+			error: 'incorrect password'
+		});
+	}
+
+	// Append signin history
+	const record = await Signin.insert({
+		createdAt: new Date(),
+		userId: user._id,
+		ip: ctx.ip,
+		headers: ctx.headers,
+		success: same
+	});
+
+	// Publish signin event
+	event(user._id, 'signin', await pack(record));
+};
diff --git a/src/server/api/private/signup.ts b/src/server/api/private/signup.ts
new file mode 100644
index 0000000000..cf51dec4d2
--- /dev/null
+++ b/src/server/api/private/signup.ts
@@ -0,0 +1,146 @@
+import * as uuid from 'uuid';
+import * as Koa from 'koa';
+import * as bcrypt from 'bcryptjs';
+import { generate as generateKeypair } from '../../../crypto_key';
+import recaptcha = require('recaptcha-promise');
+import User, { IUser, validateUsername, validatePassword, pack } from '../../../models/user';
+import generateUserToken from '../common/generate-native-user-token';
+import config from '../../../config';
+
+recaptcha.init({
+	secret_key: config.recaptcha.secret_key
+});
+
+const home = {
+	left: [
+		'profile',
+		'calendar',
+		'activity',
+		'rss',
+		'trends',
+		'photo-stream',
+		'version'
+	],
+	right: [
+		'broadcast',
+		'notifications',
+		'users',
+		'polls',
+		'server',
+		'donation',
+		'nav',
+		'tips'
+	]
+};
+
+export default async (ctx: Koa.Context) => {
+	// Verify recaptcha
+	// ただしテスト時はこの機構は障害となるため無効にする
+	if (process.env.NODE_ENV !== 'test') {
+		const success = await recaptcha(ctx.request.body['g-recaptcha-response']);
+
+		if (!success) {
+			ctx.throw(400, 'recaptcha-failed');
+			return;
+		}
+	}
+
+	const username = ctx.request.body['username'];
+	const password = ctx.request.body['password'];
+
+	// Validate username
+	if (!validateUsername(username)) {
+		ctx.status = 400;
+		return;
+	}
+
+	// Validate password
+	if (!validatePassword(password)) {
+		ctx.status = 400;
+		return;
+	}
+
+	// Fetch exist user that same username
+	const usernameExist = await User
+		.count({
+			usernameLower: username.toLowerCase(),
+			host: null
+		}, {
+			limit: 1
+		});
+
+	// Check username already used
+	if (usernameExist !== 0) {
+		ctx.status = 400;
+		return;
+	}
+
+	// Generate hash of password
+	const salt = await bcrypt.genSalt(8);
+	const hash = await bcrypt.hash(password, salt);
+
+	// Generate secret
+	const secret = generateUserToken();
+
+	//#region Construct home data
+	const homeData = [];
+
+	home.left.forEach(widget => {
+		homeData.push({
+			name: widget,
+			id: uuid(),
+			place: 'left',
+			data: {}
+		});
+	});
+
+	home.right.forEach(widget => {
+		homeData.push({
+			name: widget,
+			id: uuid(),
+			place: 'right',
+			data: {}
+		});
+	});
+	//#endregion
+
+	// Create account
+	const account: IUser = await User.insert({
+		avatarId: null,
+		bannerId: null,
+		createdAt: new Date(),
+		description: null,
+		followersCount: 0,
+		followingCount: 0,
+		name: null,
+		notesCount: 0,
+		driveCapacity: 1024 * 1024 * 128, // 128MiB
+		username: username,
+		usernameLower: username.toLowerCase(),
+		host: null,
+		keypair: generateKeypair(),
+		token: secret,
+		email: null,
+		links: null,
+		password: hash,
+		profile: {
+			bio: null,
+			birthday: null,
+			blood: null,
+			gender: null,
+			handedness: null,
+			height: null,
+			location: null,
+			weight: null
+		},
+		settings: {
+			autoWatch: true
+		},
+		clientSettings: {
+			home: homeData
+		}
+	});
+
+	// Response
+	ctx.body = await pack(account);
+};
diff --git a/src/server/api/service/github.ts b/src/server/api/service/github.ts
new file mode 100644
index 0000000000..cd9760a36d
--- /dev/null
+++ b/src/server/api/service/github.ts
@@ -0,0 +1,156 @@
+import * as EventEmitter from 'events';
+import * as Router from 'koa-router';
+import * as request from 'request';
+const crypto = require('crypto');
+
+import User, { IUser } from '../../../models/user';
+import createNote from '../../../services/note/create';
+import config from '../../../config';
+
+const handler = new EventEmitter();
+
+let bot: IUser;
+
+const post = async text => {
+	if (bot == null) {
+		const account = await User.findOne({
+			usernameLower: config.github_bot.username.toLowerCase()
+		});
+
+		if (account == null) {
+			console.warn(`GitHub hook bot specified, but not found: @${config.github_bot.username}`);
+			return;
+		} else {
+			bot = account;
+		}
+	}
+
+	createNote(bot, { text });
+};
+
+// Init router
+const router = new Router();
+
+if (config.github_bot != null) {
+	const secret = config.github_bot.hook_secret;
+
+	router.post('/hooks/github', ctx => {
+		const body = JSON.stringify(ctx.request.body);
+		const hash = crypto.createHmac('sha1', secret).update(body).digest('hex');
+		const sig1 = new Buffer(ctx.headers['x-hub-signature']);
+		const sig2 = new Buffer(`sha1=${hash}`);
+
+		// シグネチャ比較
+		if (sig1.equals(sig2)) {
+			handler.emit(ctx.headers['x-github-event'], ctx.request.body);
+			ctx.status = 204;
+		} else {
+			ctx.status = 400;
+		}
+	});
+}
+
+module.exports = router;
+
+handler.on('status', event => {
+	const state = event.state;
+	switch (state) {
+		case 'error':
+		case 'failure':
+			const commit = event.commit;
+			const parent = commit.parents[0];
+
+			// Fetch parent status
+			request({
+				url: `${parent.url}/statuses`,
+				headers: {
+					'User-Agent': 'misskey'
+				}
+			}, (err, res, body) => {
+				if (err) {
+					console.error(err);
+					return;
+				}
+				const parentStatuses = JSON.parse(body);
+				const parentState = parentStatuses[0].state;
+				const stillFailed = parentState == 'failure' || parentState == 'error';
+				if (stillFailed) {
+					post(`**⚠️BUILD STILL FAILED⚠️**: ?[${commit.commit.message}](${commit.html_url})`);
+				} else {
+					post(`**🚨BUILD FAILED🚨**: →→→?[${commit.commit.message}](${commit.html_url})←←←`);
+				}
+			});
+			break;
+	}
+});
+
+handler.on('push', event => {
+	const ref = event.ref;
+	switch (ref) {
+		case 'refs/heads/master':
+			const pusher = event.pusher;
+			const compare = event.compare;
+			const commits = event.commits;
+			post([
+				`Pushed by **${pusher.name}** with ?[${commits.length} commit${commits.length > 1 ? 's' : ''}](${compare}):`,
+				commits.reverse().map(commit => `・[?[${commit.id.substr(0, 7)}](${commit.url})] ${commit.message.split('\n')[0]}`).join('\n'),
+			].join('\n'));
+			break;
+		case 'refs/heads/release':
+			const commit = event.commits[0];
+			post(`RELEASED: ${commit.message}`);
+			break;
+	}
+});
+
+handler.on('issues', event => {
+	const issue = event.issue;
+	const action = event.action;
+	let title: string;
+	switch (action) {
+		case 'opened': title = 'Issue opened'; break;
+		case 'closed': title = 'Issue closed'; break;
+		case 'reopened': title = 'Issue reopened'; break;
+		default: return;
+	}
+	post(`${title}: <${issue.number}>「${issue.title}」\n${issue.html_url}`);
+});
+
+handler.on('issue_comment', event => {
+	const issue = event.issue;
+	const comment = event.comment;
+	const action = event.action;
+	let text: string;
+	switch (action) {
+		case 'created': text = `Commented to「${issue.title}」:${comment.user.login}「${comment.body}」\n${comment.html_url}`; break;
+		default: return;
+	}
+	post(text);
+});
+
+handler.on('watch', event => {
+	const sender = event.sender;
+	post(`⭐️ Starred by **${sender.login}** ⭐️`);
+});
+
+handler.on('fork', event => {
+	const repo = event.forkee;
+	post(`🍴 Forked:\n${repo.html_url} 🍴`);
+});
+
+handler.on('pull_request', event => {
+	const pr = event.pull_request;
+	const action = event.action;
+	let text: string;
+	switch (action) {
+		case 'opened': text = `New Pull Request:「${pr.title}」\n${pr.html_url}`; break;
+		case 'reopened': text = `Pull Request Reopened:「${pr.title}」\n${pr.html_url}`; break;
+		case 'closed':
+			text = pr.merged
+				? `Pull Request Merged!:「${pr.title}」\n${pr.html_url}`
+				: `Pull Request Closed:「${pr.title}」\n${pr.html_url}`;
+			break;
+		default: return;
+	}
+	post(text);
+});
diff --git a/src/server/api/service/twitter.ts b/src/server/api/service/twitter.ts
new file mode 100644
index 0000000000..284ae7ee22
--- /dev/null
+++ b/src/server/api/service/twitter.ts
@@ -0,0 +1,185 @@
+import * as Koa from 'koa';
+import * as Router from 'koa-router';
+import * as uuid from 'uuid';
+import autwh from 'autwh';
+import redis from '../../../db/redis';
+import User, { pack, ILocalUser } from '../../../models/user';
+import event from '../../../publishers/stream';
+import config from '../../../config';
+import signin from '../common/signin';
+
+function getUserToken(ctx: Koa.Context) {
+	return ((ctx.headers['cookie'] || '').match(/i=(!\w+)/) || [null, null])[1];
+}
+
+function compareOrigin(ctx: Koa.Context) {
+	function normalizeUrl(url: string) {
+		return url[url.length - 1] === '/' ? url.substr(0, url.length - 1) : url;
+	}
+
+	const referer = ctx.headers['referer'];
+
+	return (normalizeUrl(referer) == normalizeUrl(config.url));
+}
+
+// Init router
+const router = new Router();
+
+router.get('/disconnect/twitter', async ctx => {
+	if (!compareOrigin(ctx)) {
+		ctx.throw(400, 'invalid origin');
+		return;
+	}
+
+	const userToken = getUserToken(ctx);
+	if (userToken == null) {
+		ctx.throw(400, 'signin required');
+		return;
+	}
+
+	const user = await User.findOneAndUpdate({
+		host: null,
+		'token': userToken
+	}, {
+		$set: {
+			'twitter': null
+		}
+	});
+
+	ctx.body = `Twitterの連携を解除しました :v:`;
+
+	// Publish i updated event
+	event(user._id, 'i_updated', await pack(user, user, {
+		detail: true,
+		includeSecrets: true
+	}));
+});
+
+if (config.twitter == null) {
+	router.get('/connect/twitter', ctx => {
+		ctx.body = '現在Twitterへ接続できません (このインスタンスではTwitterはサポートされていません)';
+	});
+
+	router.get('/signin/twitter', ctx => {
+		ctx.body = '現在Twitterへ接続できません (このインスタンスではTwitterはサポートされていません)';
+	});
+} else {
+	const twAuth = autwh({
+		consumerKey: config.twitter.consumer_key,
+		consumerSecret: config.twitter.consumer_secret,
+		callbackUrl: `${config.url}/api/tw/cb`
+	});
+
+	router.get('/connect/twitter', async ctx => {
+		if (!compareOrigin(ctx)) {
+			ctx.throw(400, 'invalid origin');
+			return;
+		}
+
+		const userToken = getUserToken(ctx);
+		if (userToken == null) {
+			ctx.throw(400, 'signin required');
+			return;
+		}
+
+		const twCtx = await twAuth.begin();
+		redis.set(userToken, JSON.stringify(twCtx));
+		ctx.redirect(twCtx.url);
+	});
+
+	router.get('/signin/twitter', async ctx => {
+		const twCtx = await twAuth.begin();
+
+		const sessid = uuid();
+
+		redis.set(sessid, JSON.stringify(twCtx));
+
+		const expires = 1000 * 60 * 60; // 1h
+		ctx.cookies.set('signin_with_twitter_session_id', sessid, {
+			path: '/',
+			domain: config.host,
+			secure: config.url.startsWith('https'),
+			httpOnly: true,
+			expires: new Date(Date.now() + expires),
+			maxAge: expires
+		});
+
+		ctx.redirect(twCtx.url);
+	});
+
+	router.get('/tw/cb', async ctx => {
+		const userToken = getUserToken(ctx);
+
+		if (userToken == null) {
+			const sessid = ctx.cookies.get('signin_with_twitter_session_id');
+
+			if (sessid == null) {
+				ctx.throw(400, 'invalid session');
+				return;
+			}
+
+			const get = new Promise<any>((res, rej) => {
+				redis.get(sessid, async (_, twCtx) => {
+					res(twCtx);
+				});
+			});
+
+			const twCtx = await get;
+
+			const result = await twAuth.done(JSON.parse(twCtx), ctx.query.oauth_verifier);
+
+			const user = await User.findOne({
+				host: null,
+				'twitter.userId': result.userId
+			}) as ILocalUser;
+
+			if (user == null) {
+				ctx.throw(404, `@${result.screenName}と連携しているMisskeyアカウントはありませんでした...`);
+				return;
+			}
+
+			signin(ctx, user, true);
+		} else {
+			const verifier = ctx.query.oauth_verifier;
+
+			if (verifier == null) {
+				ctx.throw(400, 'invalid session');
+				return;
+			}
+
+			const get = new Promise<any>((res, rej) => {
+				redis.get(userToken, async (_, twCtx) => {
+					res(twCtx);
+				});
+			});
+
+			const twCtx = await get;
+
+			const result = await twAuth.done(JSON.parse(twCtx), verifier);
+
+			const user = await User.findOneAndUpdate({
+				host: null,
+				token: userToken
+			}, {
+				$set: {
+					twitter: {
+						accessToken: result.accessToken,
+						accessTokenSecret: result.accessTokenSecret,
+						userId: result.userId,
+						screenName: result.screenName
+					}
+				}
+			});
+
+			ctx.body = `Twitter: @${result.screenName} を、Misskey: @${user.username} に接続しました！`;
+
+			// Publish i updated event
+			event(user._id, 'i_updated', await pack(user, user, {
+				detail: true,
+				includeSecrets: true
+			}));
+		}
+	});
+}
+
+module.exports = router;
diff --git a/src/server/api/stream/channel.ts b/src/server/api/stream/channel.ts
new file mode 100644
index 0000000000..cb04278237
--- /dev/null
+++ b/src/server/api/stream/channel.ts
@@ -0,0 +1,14 @@
+import * as websocket from 'websocket';
+import * as redis from 'redis';
+import { ParsedUrlQuery } from 'querystring';
+
+export default function(request: websocket.request, connection: websocket.connection, subscriber: redis.RedisClient): void {
+	const q = request.resourceURL.query as ParsedUrlQuery;
+	const channel = q.channel;
+
+	// Subscribe channel stream
+	subscriber.subscribe(`misskey:channel-stream:${channel}`);
+	subscriber.on('message', (_, data) => {
+		connection.send(data);
+	});
+}
diff --git a/src/server/api/stream/drive.ts b/src/server/api/stream/drive.ts
new file mode 100644
index 0000000000..c97ab80dcc
--- /dev/null
+++ b/src/server/api/stream/drive.ts
@@ -0,0 +1,10 @@
+import * as websocket from 'websocket';
+import * as redis from 'redis';
+
+export default function(request: websocket.request, connection: websocket.connection, subscriber: redis.RedisClient, user: any): void {
+	// Subscribe drive stream
+	subscriber.subscribe(`misskey:drive-stream:${user._id}`);
+	subscriber.on('message', (_, data) => {
+		connection.send(data);
+	});
+}
diff --git a/src/server/api/stream/global-timeline.ts b/src/server/api/stream/global-timeline.ts
new file mode 100644
index 0000000000..f31ce17752
--- /dev/null
+++ b/src/server/api/stream/global-timeline.ts
@@ -0,0 +1,39 @@
+import * as websocket from 'websocket';
+import * as redis from 'redis';
+
+import { IUser } from '../../../models/user';
+import Mute from '../../../models/mute';
+
+export default async function(
+	request: websocket.request,
+	connection: websocket.connection,
+	subscriber: redis.RedisClient,
+	user: IUser
+) {
+	// Subscribe stream
+	subscriber.subscribe(`misskey:global-timeline`);
+
+	const mute = await Mute.find({ muterId: user._id });
+	const mutedUserIds = mute.map(m => m.muteeId.toString());
+
+	subscriber.on('message', async (_, data) => {
+		const note = JSON.parse(data);
+
+		//#region 流れてきたNoteがミュートしているユーザーが関わるものだったら無視する
+		if (mutedUserIds.indexOf(note.userId) != -1) {
+			return;
+		}
+		if (note.reply != null && mutedUserIds.indexOf(note.reply.userId) != -1) {
+			return;
+		}
+		if (note.renote != null && mutedUserIds.indexOf(note.renote.userId) != -1) {
+			return;
+		}
+		//#endregion
+
+		connection.send(JSON.stringify({
+			type: 'note',
+			body: note
+		}));
+	});
+}
diff --git a/src/server/api/stream/home.ts b/src/server/api/stream/home.ts
new file mode 100644
index 0000000000..54fde2d776
--- /dev/null
+++ b/src/server/api/stream/home.ts
@@ -0,0 +1,114 @@
+import * as websocket from 'websocket';
+import * as redis from 'redis';
+import * as debug from 'debug';
+
+import User, { IUser } from '../../../models/user';
+import Mute from '../../../models/mute';
+import { pack as packNote } from '../../../models/note';
+import readNotification from '../common/read-notification';
+import call from '../call';
+import { IApp } from '../../../models/app';
+
+const log = debug('misskey');
+
+export default async function(
+	request: websocket.request,
+	connection: websocket.connection,
+	subscriber: redis.RedisClient,
+	user: IUser,
+	app: IApp
+) {
+	// Subscribe Home stream channel
+	subscriber.subscribe(`misskey:user-stream:${user._id}`);
+
+	const mute = await Mute.find({ muterId: user._id });
+	const mutedUserIds = mute.map(m => m.muteeId.toString());
+
+	subscriber.on('message', async (channel, data) => {
+		switch (channel.split(':')[1]) {
+			case 'user-stream':
+				try {
+					const x = JSON.parse(data);
+
+					//#region 流れてきたメッセージがミュートしているユーザーが関わるものだったら無視する
+					if (x.type == 'note') {
+						if (mutedUserIds.includes(x.body.userId)) {
+							return;
+						}
+						if (x.body.reply != null && mutedUserIds.includes(x.body.reply.userId)) {
+							return;
+						}
+						if (x.body.renote != null && mutedUserIds.includes(x.body.renote.userId)) {
+							return;
+						}
+					} else if (x.type == 'notification') {
+						if (mutedUserIds.includes(x.body.userId)) {
+							return;
+						}
+					}
+					//#endregion
+
+					connection.send(data);
+				} catch (e) {
+					connection.send(data);
+				}
+				break;
+
+			case 'note-stream':
+				const noteId = channel.split(':')[2];
+				log(`RECEIVED: ${noteId} ${data} by @${user.username}`);
+				const note = await packNote(noteId, user, {
+					detail: true
+				});
+				connection.send(JSON.stringify({
+					type: 'note-updated',
+					body: {
+						note: note
+					}
+				}));
+				break;
+		}
+	});
+
+	connection.on('message', async data => {
+		const msg = JSON.parse(data.utf8Data);
+
+		switch (msg.type) {
+			case 'api':
+				// 新鮮なデータを利用するためにユーザーをフェッチ
+				call(msg.endpoint, await User.findOne({ _id: user._id }), app, msg.data).then(res => {
+					connection.send(JSON.stringify({
+						type: `api-res:${msg.id}`,
+						body: { res }
+					}));
+				}).catch(e => {
+					connection.send(JSON.stringify({
+						type: `api-res:${msg.id}`,
+						body: { e }
+					}));
+				});
+				break;
+
+			case 'alive':
+				// Update lastUsedAt
+				User.update({ _id: user._id }, {
+					$set: {
+						'lastUsedAt': new Date()
+					}
+				});
+				break;
+
+			case 'read_notification':
+				if (!msg.id) return;
+				readNotification(user._id, msg.id);
+				break;
+
+			case 'capture':
+				if (!msg.id) return;
+				const noteId = msg.id;
+				log(`CAPTURE: ${noteId} by @${user.username}`);
+				subscriber.subscribe(`misskey:note-stream:${noteId}`);
+				break;
+		}
+	});
+}
diff --git a/src/server/api/stream/local-timeline.ts b/src/server/api/stream/local-timeline.ts
new file mode 100644
index 0000000000..a790ba878b
--- /dev/null
+++ b/src/server/api/stream/local-timeline.ts
@@ -0,0 +1,39 @@
+import * as websocket from 'websocket';
+import * as redis from 'redis';
+
+import { IUser } from '../../../models/user';
+import Mute from '../../../models/mute';
+
+export default async function(
+	request: websocket.request,
+	connection: websocket.connection,
+	subscriber: redis.RedisClient,
+	user: IUser
+) {
+	// Subscribe stream
+	subscriber.subscribe(`misskey:local-timeline`);
+
+	const mute = await Mute.find({ muterId: user._id });
+	const mutedUserIds = mute.map(m => m.muteeId.toString());
+
+	subscriber.on('message', async (_, data) => {
+		const note = JSON.parse(data);
+
+		//#region 流れてきたNoteがミュートしているユーザーが関わるものだったら無視する
+		if (mutedUserIds.indexOf(note.userId) != -1) {
+			return;
+		}
+		if (note.reply != null && mutedUserIds.indexOf(note.reply.userId) != -1) {
+			return;
+		}
+		if (note.renote != null && mutedUserIds.indexOf(note.renote.userId) != -1) {
+			return;
+		}
+		//#endregion
+
+		connection.send(JSON.stringify({
+			type: 'note',
+			body: note
+		}));
+	});
+}
diff --git a/src/server/api/stream/messaging-index.ts b/src/server/api/stream/messaging-index.ts
new file mode 100644
index 0000000000..c1b2fbc806
--- /dev/null
+++ b/src/server/api/stream/messaging-index.ts
@@ -0,0 +1,10 @@
+import * as websocket from 'websocket';
+import * as redis from 'redis';
+
+export default function(request: websocket.request, connection: websocket.connection, subscriber: redis.RedisClient, user: any): void {
+	// Subscribe messaging index stream
+	subscriber.subscribe(`misskey:messaging-index-stream:${user._id}`);
+	subscriber.on('message', (_, data) => {
+		connection.send(data);
+	});
+}
diff --git a/src/server/api/stream/messaging.ts b/src/server/api/stream/messaging.ts
new file mode 100644
index 0000000000..3e6c2cd509
--- /dev/null
+++ b/src/server/api/stream/messaging.ts
@@ -0,0 +1,26 @@
+import * as websocket from 'websocket';
+import * as redis from 'redis';
+import read from '../common/read-messaging-message';
+import { ParsedUrlQuery } from 'querystring';
+
+export default function(request: websocket.request, connection: websocket.connection, subscriber: redis.RedisClient, user: any): void {
+	const q = request.resourceURL.query as ParsedUrlQuery;
+	const otherparty = q.otherparty as string;
+
+	// Subscribe messaging stream
+	subscriber.subscribe(`misskey:messaging-stream:${user._id}-${otherparty}`);
+	subscriber.on('message', (_, data) => {
+		connection.send(data);
+	});
+
+	connection.on('message', async (data) => {
+		const msg = JSON.parse(data.utf8Data);
+
+		switch (msg.type) {
+			case 'read':
+				if (!msg.id) return;
+				read(user._id, otherparty, msg.id);
+				break;
+		}
+	});
+}
diff --git a/src/server/api/stream/othello-game.ts b/src/server/api/stream/othello-game.ts
new file mode 100644
index 0000000000..841e542610
--- /dev/null
+++ b/src/server/api/stream/othello-game.ts
@@ -0,0 +1,333 @@
+import * as websocket from 'websocket';
+import * as redis from 'redis';
+import * as CRC32 from 'crc-32';
+import OthelloGame, { pack } from '../../../models/othello-game';
+import { publishOthelloGameStream } from '../../../publishers/stream';
+import Othello from '../../../othello/core';
+import * as maps from '../../../othello/maps';
+import { ParsedUrlQuery } from 'querystring';
+
+export default function(request: websocket.request, connection: websocket.connection, subscriber: redis.RedisClient, user?: any): void {
+	const q = request.resourceURL.query as ParsedUrlQuery;
+	const gameId = q.game;
+
+	// Subscribe game stream
+	subscriber.subscribe(`misskey:othello-game-stream:${gameId}`);
+	subscriber.on('message', (_, data) => {
+		connection.send(data);
+	});
+
+	connection.on('message', async (data) => {
+		const msg = JSON.parse(data.utf8Data);
+
+		switch (msg.type) {
+			case 'accept':
+				accept(true);
+				break;
+
+			case 'cancel-accept':
+				accept(false);
+				break;
+
+			case 'update-settings':
+				if (msg.settings == null) return;
+				updateSettings(msg.settings);
+				break;
+
+			case 'init-form':
+				if (msg.body == null) return;
+				initForm(msg.body);
+				break;
+
+			case 'update-form':
+				if (msg.id == null || msg.value === undefined) return;
+				updateForm(msg.id, msg.value);
+				break;
+
+			case 'message':
+				if (msg.body == null) return;
+				message(msg.body);
+				break;
+
+			case 'set':
+				if (msg.pos == null) return;
+				set(msg.pos);
+				break;
+
+			case 'check':
+				if (msg.crc32 == null) return;
+				check(msg.crc32);
+				break;
+		}
+	});
+
+	async function updateSettings(settings) {
+		const game = await OthelloGame.findOne({ _id: gameId });
+
+		if (game.isStarted) return;
+		if (!game.user1Id.equals(user._id) && !game.user2Id.equals(user._id)) return;
+		if (game.user1Id.equals(user._id) && game.user1Accepted) return;
+		if (game.user2Id.equals(user._id) && game.user2Accepted) return;
+
+		await OthelloGame.update({ _id: gameId }, {
+			$set: {
+				settings
+			}
+		});
+
+		publishOthelloGameStream(gameId, 'update-settings', settings);
+	}
+
+	async function initForm(form) {
+		const game = await OthelloGame.findOne({ _id: gameId });
+
+		if (game.isStarted) return;
+		if (!game.user1Id.equals(user._id) && !game.user2Id.equals(user._id)) return;
+
+		const set = game.user1Id.equals(user._id) ? {
+			form1: form
+		} : {
+			form2: form
+		};
+
+		await OthelloGame.update({ _id: gameId }, {
+			$set: set
+		});
+
+		publishOthelloGameStream(gameId, 'init-form', {
+			userId: user._id,
+			form
+		});
+	}
+
+	async function updateForm(id, value) {
+		const game = await OthelloGame.findOne({ _id: gameId });
+
+		if (game.isStarted) return;
+		if (!game.user1Id.equals(user._id) && !game.user2Id.equals(user._id)) return;
+
+		const form = game.user1Id.equals(user._id) ? game.form2 : game.form1;
+
+		const item = form.find(i => i.id == id);
+
+		if (item == null) return;
+
+		item.value = value;
+
+		const set = game.user1Id.equals(user._id) ? {
+			form2: form
+		} : {
+			form1: form
+		};
+
+		await OthelloGame.update({ _id: gameId }, {
+			$set: set
+		});
+
+		publishOthelloGameStream(gameId, 'update-form', {
+			userId: user._id,
+			id,
+			value
+		});
+	}
+
+	async function message(message) {
+		message.id = Math.random();
+		publishOthelloGameStream(gameId, 'message', {
+			userId: user._id,
+			message
+		});
+	}
+
+	async function accept(accept: boolean) {
+		const game = await OthelloGame.findOne({ _id: gameId });
+
+		if (game.isStarted) return;
+
+		let bothAccepted = false;
+
+		if (game.user1Id.equals(user._id)) {
+			await OthelloGame.update({ _id: gameId }, {
+				$set: {
+					user1Accepted: accept
+				}
+			});
+
+			publishOthelloGameStream(gameId, 'change-accepts', {
+				user1: accept,
+				user2: game.user2Accepted
+			});
+
+			if (accept && game.user2Accepted) bothAccepted = true;
+		} else if (game.user2Id.equals(user._id)) {
+			await OthelloGame.update({ _id: gameId }, {
+				$set: {
+					user2Accepted: accept
+				}
+			});
+
+			publishOthelloGameStream(gameId, 'change-accepts', {
+				user1: game.user1Accepted,
+				user2: accept
+			});
+
+			if (accept && game.user1Accepted) bothAccepted = true;
+		} else {
+			return;
+		}
+
+		if (bothAccepted) {
+			// 3秒後、まだacceptされていたらゲーム開始
+			setTimeout(async () => {
+				const freshGame = await OthelloGame.findOne({ _id: gameId });
+				if (freshGame == null || freshGame.isStarted || freshGame.isEnded) return;
+				if (!freshGame.user1Accepted || !freshGame.user2Accepted) return;
+
+				let bw: number;
+				if (freshGame.settings.bw == 'random') {
+					bw = Math.random() > 0.5 ? 1 : 2;
+				} else {
+					bw = freshGame.settings.bw as number;
+				}
+
+				function getRandomMap() {
+					const mapCount = Object.entries(maps).length;
+					const rnd = Math.floor(Math.random() * mapCount);
+					return Object.entries(maps).find((x, i) => i == rnd)[1].data;
+				}
+
+				const map = freshGame.settings.map != null ? freshGame.settings.map : getRandomMap();
+
+				await OthelloGame.update({ _id: gameId }, {
+					$set: {
+						startedAt: new Date(),
+						isStarted: true,
+						black: bw,
+						'settings.map': map
+					}
+				});
+
+				//#region 盤面に最初から石がないなどして始まった瞬間に勝敗が決定する場合があるのでその処理
+				const o = new Othello(map, {
+					isLlotheo: freshGame.settings.isLlotheo,
+					canPutEverywhere: freshGame.settings.canPutEverywhere,
+					loopedBoard: freshGame.settings.loopedBoard
+				});
+
+				if (o.isEnded) {
+					let winner;
+					if (o.winner === true) {
+						winner = freshGame.black == 1 ? freshGame.user1Id : freshGame.user2Id;
+					} else if (o.winner === false) {
+						winner = freshGame.black == 1 ? freshGame.user2Id : freshGame.user1Id;
+					} else {
+						winner = null;
+					}
+
+					await OthelloGame.update({
+						_id: gameId
+					}, {
+						$set: {
+							isEnded: true,
+							winnerId: winner
+						}
+					});
+
+					publishOthelloGameStream(gameId, 'ended', {
+						winnerId: winner,
+						game: await pack(gameId, user)
+					});
+				}
+				//#endregion
+
+				publishOthelloGameStream(gameId, 'started', await pack(gameId, user));
+			}, 3000);
+		}
+	}
+
+	// 石を打つ
+	async function set(pos) {
+		const game = await OthelloGame.findOne({ _id: gameId });
+
+		if (!game.isStarted) return;
+		if (game.isEnded) return;
+		if (!game.user1Id.equals(user._id) && !game.user2Id.equals(user._id)) return;
+
+		const o = new Othello(game.settings.map, {
+			isLlotheo: game.settings.isLlotheo,
+			canPutEverywhere: game.settings.canPutEverywhere,
+			loopedBoard: game.settings.loopedBoard
+		});
+
+		game.logs.forEach(log => {
+			o.put(log.color, log.pos);
+		});
+
+		const myColor =
+			(game.user1Id.equals(user._id) && game.black == 1) || (game.user2Id.equals(user._id) && game.black == 2)
+				? true
+				: false;
+
+		if (!o.canPut(myColor, pos)) return;
+		o.put(myColor, pos);
+
+		let winner;
+		if (o.isEnded) {
+			if (o.winner === true) {
+				winner = game.black == 1 ? game.user1Id : game.user2Id;
+			} else if (o.winner === false) {
+				winner = game.black == 1 ? game.user2Id : game.user1Id;
+			} else {
+				winner = null;
+			}
+		}
+
+		const log = {
+			at: new Date(),
+			color: myColor,
+			pos
+		};
+
+		const crc32 = CRC32.str(game.logs.map(x => x.pos.toString()).join('') + pos.toString());
+
+		await OthelloGame.update({
+			_id: gameId
+		}, {
+			$set: {
+				crc32,
+				isEnded: o.isEnded,
+				winnerId: winner
+			},
+			$push: {
+				logs: log
+			}
+		});
+
+		publishOthelloGameStream(gameId, 'set', Object.assign(log, {
+			next: o.turn
+		}));
+
+		if (o.isEnded) {
+			publishOthelloGameStream(gameId, 'ended', {
+				winnerId: winner,
+				game: await pack(gameId, user)
+			});
+		}
+	}
+
+	async function check(crc32) {
+		const game = await OthelloGame.findOne({ _id: gameId });
+
+		if (!game.isStarted) return;
+
+		// 互換性のため
+		if (game.crc32 == null) return;
+
+		if (crc32 !== game.crc32) {
+			connection.send(JSON.stringify({
+				type: 'rescue',
+				body: await pack(game, user)
+			}));
+		}
+	}
+}
diff --git a/src/server/api/stream/othello.ts b/src/server/api/stream/othello.ts
new file mode 100644
index 0000000000..fa62b05836
--- /dev/null
+++ b/src/server/api/stream/othello.ts
@@ -0,0 +1,29 @@
+import * as mongo from 'mongodb';
+import * as websocket from 'websocket';
+import * as redis from 'redis';
+import Matching, { pack } from '../../../models/othello-matching';
+import publishUserStream from '../../../publishers/stream';
+
+export default function(request: websocket.request, connection: websocket.connection, subscriber: redis.RedisClient, user: any): void {
+	// Subscribe othello stream
+	subscriber.subscribe(`misskey:othello-stream:${user._id}`);
+	subscriber.on('message', (_, data) => {
+		connection.send(data);
+	});
+
+	connection.on('message', async (data) => {
+		const msg = JSON.parse(data.utf8Data);
+
+		switch (msg.type) {
+			case 'ping':
+				if (msg.id == null) return;
+				const matching = await Matching.findOne({
+					parentId: user._id,
+					childId: new mongo.ObjectID(msg.id)
+				});
+				if (matching == null) return;
+				publishUserStream(matching.childId, 'othello_invited', await pack(matching, matching.childId));
+				break;
+		}
+	});
+}
diff --git a/src/server/api/stream/requests.ts b/src/server/api/stream/requests.ts
new file mode 100644
index 0000000000..d7bb5e6c5c
--- /dev/null
+++ b/src/server/api/stream/requests.ts
@@ -0,0 +1,19 @@
+import * as websocket from 'websocket';
+import Xev from 'xev';
+
+const ev = new Xev();
+
+export default function(request: websocket.request, connection: websocket.connection): void {
+	const onRequest = request => {
+		connection.send(JSON.stringify({
+			type: 'request',
+			body: request
+		}));
+	};
+
+	ev.addListener('request', onRequest);
+
+	connection.on('close', () => {
+		ev.removeListener('request', onRequest);
+	});
+}
diff --git a/src/server/api/stream/server.ts b/src/server/api/stream/server.ts
new file mode 100644
index 0000000000..4ca2ad1b10
--- /dev/null
+++ b/src/server/api/stream/server.ts
@@ -0,0 +1,19 @@
+import * as websocket from 'websocket';
+import Xev from 'xev';
+
+const ev = new Xev();
+
+export default function(request: websocket.request, connection: websocket.connection): void {
+	const onStats = stats => {
+		connection.send(JSON.stringify({
+			type: 'stats',
+			body: stats
+		}));
+	};
+
+	ev.addListener('stats', onStats);
+
+	connection.on('close', () => {
+		ev.removeListener('stats', onStats);
+	});
+}
diff --git a/src/server/api/stream/user-list.ts b/src/server/api/stream/user-list.ts
new file mode 100644
index 0000000000..ba03b97860
--- /dev/null
+++ b/src/server/api/stream/user-list.ts
@@ -0,0 +1,14 @@
+import * as websocket from 'websocket';
+import * as redis from 'redis';
+import { ParsedUrlQuery } from 'querystring';
+
+export default function(request: websocket.request, connection: websocket.connection, subscriber: redis.RedisClient, user: any): void {
+	const q = request.resourceURL.query as ParsedUrlQuery;
+	const listId = q.listId as string;
+
+	// Subscribe stream
+	subscriber.subscribe(`misskey:user-list-stream:${listId}`);
+	subscriber.on('message', (_, data) => {
+		connection.send(data);
+	});
+}
diff --git a/src/server/api/streaming.ts b/src/server/api/streaming.ts
new file mode 100644
index 0000000000..e4884ed7c4
--- /dev/null
+++ b/src/server/api/streaming.ts
@@ -0,0 +1,87 @@
+import * as http from 'http';
+import * as websocket from 'websocket';
+import * as redis from 'redis';
+import config from '../../config';
+
+import homeStream from './stream/home';
+import localTimelineStream from './stream/local-timeline';
+import globalTimelineStream from './stream/global-timeline';
+import userListStream from './stream/user-list';
+import driveStream from './stream/drive';
+import messagingStream from './stream/messaging';
+import messagingIndexStream from './stream/messaging-index';
+import othelloGameStream from './stream/othello-game';
+import othelloStream from './stream/othello';
+import serverStream from './stream/server';
+import requestsStream from './stream/requests';
+import channelStream from './stream/channel';
+import { ParsedUrlQuery } from 'querystring';
+import authenticate from './authenticate';
+
+module.exports = (server: http.Server) => {
+	/**
+	 * Init websocket server
+	 */
+	const ws = new websocket.server({
+		httpServer: server
+	});
+
+	ws.on('request', async (request) => {
+		const connection = request.accept();
+
+		if (request.resourceURL.pathname === '/server') {
+			serverStream(request, connection);
+			return;
+		}
+
+		if (request.resourceURL.pathname === '/requests') {
+			requestsStream(request, connection);
+			return;
+		}
+
+		// Connect to Redis
+		const subscriber = redis.createClient(
+			config.redis.port, config.redis.host);
+
+		connection.on('close', () => {
+			subscriber.unsubscribe();
+			subscriber.quit();
+		});
+
+		if (request.resourceURL.pathname === '/channel') {
+			channelStream(request, connection, subscriber);
+			return;
+		}
+
+		const q = request.resourceURL.query as ParsedUrlQuery;
+		const [user, app] = await authenticate(q.i as string);
+
+		if (request.resourceURL.pathname === '/othello-game') {
+			othelloGameStream(request, connection, subscriber, user);
+			return;
+		}
+
+		if (user == null) {
+			connection.send('authentication-failed');
+			connection.close();
+			return;
+		}
+
+		const channel: any =
+			request.resourceURL.pathname === '/' ? homeStream :
+			request.resourceURL.pathname === '/local-timeline' ? localTimelineStream :
+			request.resourceURL.pathname === '/global-timeline' ? globalTimelineStream :
+			request.resourceURL.pathname === '/user-list' ? userListStream :
+			request.resourceURL.pathname === '/drive' ? driveStream :
+			request.resourceURL.pathname === '/messaging' ? messagingStream :
+			request.resourceURL.pathname === '/messaging-index' ? messagingIndexStream :
+			request.resourceURL.pathname === '/othello' ? othelloStream :
+			null;
+
+		if (channel !== null) {
+			channel(request, connection, subscriber, user, app);
+		} else {
+			connection.close();
+		}
+	});
+};