rudeshark.net/src/server/api/service/github.ts

417 lines
10 KiB
TypeScript
Raw Normal View History

2017-02-11 22:27:47 +01:00
import * as EventEmitter from 'events';
2018-11-04 11:17:30 +01:00
import * as Koa from 'koa';
2018-04-12 23:06:18 +02:00
import * as Router from 'koa-router';
2018-04-09 10:38:22 +02:00
import * as request from 'request';
2018-11-04 11:17:30 +01:00
import { OAuth2 } from 'oauth';
import User, { IUser, pack, ILocalUser } from '../../../models/user';
2018-04-09 10:38:22 +02:00
import createNote from '../../../services/note/create';
2018-04-02 06:15:53 +02:00
import config from '../../../config';
2018-11-04 11:17:30 +01:00
import { publishMainStream } from '../../../stream';
import redis from '../../../db/redis';
import uuid = require('uuid');
import signin from '../common/signin';
const crypto = require('crypto');
2017-01-31 16:12:49 +01:00
2018-04-12 23:06:18 +02:00
const handler = new EventEmitter();
2017-01-31 16:12:49 +01:00
2018-04-12 23:06:18 +02:00
let bot: IUser;
2017-01-31 16:43:06 +01:00
2018-08-05 06:44:44 +02:00
const post = async (text: string, home = true) => {
2017-01-31 16:43:06 +01:00
if (bot == null) {
2018-04-12 23:06:18 +02:00
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;
}
2017-01-31 16:43:06 +01:00
}
2018-08-05 06:44:44 +02:00
createNote(bot, { text, visibility: home ? 'home' : 'public' });
2018-04-12 23:06:18 +02:00
};
2018-11-04 11:17:30 +01:00
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.endsWith('/') ? url.substr(0, url.length - 1) : url : '';
}
const referer = ctx.headers['referer'];
return (normalizeUrl(referer) == normalizeUrl(config.url));
}
2018-04-12 23:06:18 +02:00
// Init router
const router = new Router();
2017-01-31 16:43:06 +01:00
2018-11-04 11:17:30 +01:00
router.get('/disconnect/github', async ctx => {
if (!compareOrigin(ctx)) {
ctx.throw(400, 'invalid origin');
return;
}
const userToken = getUserToken(ctx);
if (!userToken) {
ctx.throw(400, 'signin required');
return;
}
const user = await User.findOneAndUpdate({
host: null,
'token': userToken
}, {
$set: {
'github': null
}
});
ctx.body = `GitHubの連携を解除しました :v:`;
// Publish i updated event
publishMainStream(user._id, 'meUpdated', await pack(user, user, {
detail: true,
includeSecrets: true
}));
});
if (!config.github || !redis) {
router.get('/connect/github', ctx => {
ctx.body = '現在GitHubへ接続できません (このインスタンスではGitHubはサポートされていません)';
});
router.get('/signin/github', ctx => {
ctx.body = '現在GitHubへ接続できません (このインスタンスではGitHubはサポートされていません)';
});
} else {
const oauth2 = new OAuth2(
config.github.client_id,
config.github.client_secret,
'https://github.com/',
'login/oauth/authorize',
'login/oauth/access_token');
router.get('/connect/github', async ctx => {
if (!compareOrigin(ctx)) {
ctx.throw(400, 'invalid origin');
return;
}
const userToken = getUserToken(ctx);
if (!userToken) {
ctx.throw(400, 'signin required');
return;
}
const params = {
redirect_uri: `${config.url}:8089/api/gh/cb`,
scope: ['read:user'],
state: uuid()
};
redis.set(userToken, JSON.stringify(params));
ctx.redirect(oauth2.getAuthorizeUrl(params));
});
router.get('/signin/github', async ctx => {
const sessid = uuid();
const params = {
redirect_uri: `${config.url}:8089/api/gh/cb`,
scope: ['read:user'],
state: uuid()
};
const expires = 1000 * 60 * 60; // 1h
ctx.cookies.set('signin_with_github_session_id', sessid, {
path: '/',
domain: config.host,
secure: config.url.startsWith('https'),
httpOnly: true,
expires: new Date(Date.now() + expires),
maxAge: expires
});
redis.set(sessid, JSON.stringify(params));
ctx.redirect(oauth2.getAuthorizeUrl(params));
});
router.get('/gh/cb', async ctx => {
const userToken = getUserToken(ctx);
if (!userToken) {
const sessid = ctx.cookies.get('signin_with_github_session_id');
if (!sessid) {
ctx.throw(400, 'invalid session');
return;
}
const code = ctx.query.code;
if (!code) {
ctx.throw(400, 'invalid session');
return;
}
const { redirect_uri, state } = await new Promise<any>((res, rej) => {
redis.get(sessid, async (_, state) => {
res(JSON.parse(state));
});
});
if (ctx.query.state !== state) {
ctx.throw(400, 'invalid session');
return;
}
const { accessToken } = await new Promise<any>((res, rej) =>
oauth2.getOAuthAccessToken(
code,
{ redirect_uri },
(err, accessToken, refresh, result) => {
if (err)
rej(err);
else if (result.error)
rej(result.error);
else
res({ accessToken });
}));
const { login, id } = await new Promise<any>((res, rej) =>
request({
url: 'https://api.github.com/user',
headers: {
'Accept': 'application/vnd.github.v3+json',
'Authorization': `bearer ${accessToken}`,
'User-Agent': config.user_agent
}
}, (err, response, body) => {
if (err)
rej(err);
else
res(JSON.parse(body));
}));
if (!login || !id) {
ctx.throw(400, 'invalid session');
return;
}
const user = await User.findOne({
host: null,
'github.id': id
}) as ILocalUser;
if (!user) {
ctx.throw(404, `@${login}と連携しているMisskeyアカウントはありませんでした...`);
return;
}
signin(ctx, user, true);
} else {
const code = ctx.query.code;
if (!code) {
ctx.throw(400, 'invalid session');
return;
}
const { redirect_uri, state } = await new Promise<any>((res, rej) => {
redis.get(userToken, async (_, state) => {
res(JSON.parse(state));
});
});
if (ctx.query.state !== state) {
ctx.throw(400, 'invalid session');
return;
}
const { accessToken } = await new Promise<any>((res, rej) =>
oauth2.getOAuthAccessToken(
code,
{ redirect_uri },
(err, accessToken, refresh, result) => {
if (err)
rej(err);
else if (result.error)
rej(result.error);
else
res({ accessToken });
}));
const { login, id } = await new Promise<any>((res, rej) =>
request({
url: 'https://api.github.com/user',
headers: {
'Accept': 'application/vnd.github.v3+json',
'Authorization': `bearer ${accessToken}`,
'User-Agent': config.user_agent
}
}, (err, response, body) => {
if (err)
rej(err);
else
res(JSON.parse(body));
}));
if (!login || !id) {
ctx.throw(400, 'invalid session');
return;
}
const user = await User.findOneAndUpdate({
host: null,
token: userToken
}, {
$set: {
github: {
accessToken,
id,
login
}
}
});
ctx.body = `GitHub: @${login} を、Misskey: @${user.username} に接続しました!`;
// Publish i updated event
publishMainStream(user._id, 'meUpdated', await pack(user, user, {
detail: true,
includeSecrets: true
}));
}
});
}
if (config.github_bot) {
2018-04-12 23:06:18 +02:00
const secret = config.github_bot.hook_secret;
2017-01-31 16:12:49 +01:00
2018-04-12 23:06:18 +02:00
router.post('/hooks/github', ctx => {
2018-04-13 02:44:00 +02:00
const body = JSON.stringify(ctx.request.body);
const hash = crypto.createHmac('sha1', secret).update(body).digest('hex');
2018-04-12 23:06:18 +02:00
const sig1 = new Buffer(ctx.headers['x-hub-signature']);
2018-04-13 02:44:00 +02:00
const sig2 = new Buffer(`sha1=${hash}`);
// シグネチャ比較
2018-04-12 23:06:18 +02:00
if (sig1.equals(sig2)) {
2018-04-13 02:44:00 +02:00
handler.emit(ctx.headers['x-github-event'], ctx.request.body);
2018-04-12 23:06:18 +02:00
ctx.status = 204;
2018-04-09 10:38:22 +02:00
} else {
2018-04-12 23:06:18 +02:00
ctx.status = 400;
2018-04-09 10:38:22 +02:00
}
2017-02-11 22:27:47 +01:00
});
2018-04-12 23:06:18 +02:00
}
2017-01-31 16:12:49 +01:00
2018-04-12 23:06:18 +02:00
module.exports = router;
2017-03-17 17:42:43 +01:00
2018-04-12 23:06:18 +02:00
handler.on('status', event => {
const state = event.state;
switch (state) {
case 'error':
case 'failure':
const commit = event.commit;
const parent = commit.parents[0];
2017-01-31 16:43:06 +01:00
2018-04-12 23:06:18 +02:00
// Fetch parent status
request({
url: `${parent.url}/statuses`,
2018-10-13 06:13:15 +02:00
proxy: config.proxy,
2018-04-12 23:06:18 +02:00
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;
}
});
2017-01-31 20:25:02 +01:00
2018-04-12 23:06:18 +02:00
handler.on('push', event => {
const ref = event.ref;
switch (ref) {
case 'refs/heads/master':
const pusher = event.pusher;
const compare = event.compare;
2018-06-18 02:54:53 +02:00
const commits: any[] = event.commits;
2018-04-12 23:06:18 +02:00
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;
}
});
2017-01-31 20:25:02 +01:00
2018-04-12 23:06:18 +02:00
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}`);
});
2017-02-07 15:52:58 +01:00
2018-04-12 23:06:18 +02:00
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);
});
2017-01-31 20:25:02 +01:00
2018-04-12 23:06:18 +02:00
handler.on('watch', event => {
const sender = event.sender;
2018-08-05 06:44:44 +02:00
post(`(((⭐️))) Starred by **${sender.login}** (((⭐️)))`, false);
2018-04-12 23:06:18 +02:00
});
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);
});