2016-12-29 07:49:51 +09:00
|
|
|
/**
|
|
|
|
* Core Server
|
|
|
|
*/
|
|
|
|
|
2023-01-13 13:40:33 +09:00
|
|
|
import cluster from "node:cluster";
|
|
|
|
import * as fs from "node:fs";
|
|
|
|
import * as http from "node:http";
|
|
|
|
import Koa from "koa";
|
|
|
|
import Router from "@koa/router";
|
|
|
|
import mount from "koa-mount";
|
|
|
|
import koaLogger from "koa-logger";
|
|
|
|
import * as slow from "koa-slow";
|
|
|
|
|
|
|
|
import { IsNull } from "typeorm";
|
|
|
|
import config from "@/config/index.js";
|
|
|
|
import Logger from "@/services/logger.js";
|
|
|
|
import { UserProfiles, Users } from "@/models/index.js";
|
|
|
|
import { genIdenticon } from "@/misc/gen-identicon.js";
|
|
|
|
import { createTemp } from "@/misc/create-temp.js";
|
|
|
|
import { publishMainStream } from "@/services/stream.js";
|
|
|
|
import * as Acct from "@/misc/acct.js";
|
|
|
|
import { envOption } from "@/env.js";
|
2023-02-10 07:21:50 +09:00
|
|
|
const { koaBody } = require('koa-body');
|
2023-02-08 06:56:07 +09:00
|
|
|
import megalodon, { MegalodonInterface } from 'megalodon';
|
2023-01-13 13:40:33 +09:00
|
|
|
import activityPub from "./activitypub.js";
|
|
|
|
import nodeinfo from "./nodeinfo.js";
|
|
|
|
import wellKnown from "./well-known.js";
|
|
|
|
import apiServer from "./api/index.js";
|
|
|
|
import fileServer from "./file/index.js";
|
|
|
|
import proxyServer from "./proxy/index.js";
|
|
|
|
import webServer from "./web/index.js";
|
|
|
|
import { initializeStreamingServer } from "./api/streaming.js";
|
|
|
|
|
|
|
|
export const serverLogger = new Logger("server", "gray", false);
|
2017-01-17 08:06:39 +09:00
|
|
|
|
2018-04-13 06:06:18 +09:00
|
|
|
// Init app
|
2018-04-13 00:51:55 +09:00
|
|
|
const app = new Koa();
|
|
|
|
app.proxy = true;
|
2017-11-13 19:58:29 +09:00
|
|
|
|
2023-01-13 13:40:33 +09:00
|
|
|
if (!["production", "test"].includes(process.env.NODE_ENV || "")) {
|
2018-04-19 18:03:46 +09:00
|
|
|
// Logger
|
2023-01-13 13:40:33 +09:00
|
|
|
app.use(
|
|
|
|
koaLogger((str) => {
|
|
|
|
serverLogger.info(str);
|
|
|
|
}),
|
|
|
|
);
|
2018-04-26 11:46:42 +09:00
|
|
|
|
|
|
|
// Delay
|
2021-10-08 21:24:05 +09:00
|
|
|
if (envOption.slow) {
|
2023-01-13 13:40:33 +09:00
|
|
|
app.use(
|
|
|
|
slow({
|
|
|
|
delay: 3000,
|
|
|
|
}),
|
|
|
|
);
|
2019-02-04 10:03:49 +09:00
|
|
|
}
|
2018-04-19 18:03:46 +09:00
|
|
|
}
|
|
|
|
|
2018-04-13 00:51:55 +09:00
|
|
|
// HSTS
|
|
|
|
// 6months (15552000sec)
|
2023-01-13 13:40:33 +09:00
|
|
|
if (config.url.startsWith("https") && !config.disableHsts) {
|
2018-04-13 07:34:27 +09:00
|
|
|
app.use(async (ctx, next) => {
|
2023-01-13 13:40:33 +09:00
|
|
|
ctx.set("strict-transport-security", "max-age=15552000; preload");
|
2018-04-13 07:34:27 +09:00
|
|
|
await next();
|
2018-04-12 05:54:54 +09:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2023-01-13 13:40:33 +09:00
|
|
|
app.use(mount("/api", apiServer));
|
|
|
|
app.use(mount("/files", fileServer));
|
|
|
|
app.use(mount("/proxy", proxyServer));
|
2018-04-13 06:17:14 +09:00
|
|
|
|
2018-04-13 00:51:55 +09:00
|
|
|
// Init router
|
|
|
|
const router = new Router();
|
2017-01-07 23:57:45 +09:00
|
|
|
|
2018-04-13 00:51:55 +09:00
|
|
|
// Routing
|
|
|
|
router.use(activityPub.routes());
|
2019-02-05 17:42:55 +09:00
|
|
|
router.use(nodeinfo.routes());
|
|
|
|
router.use(wellKnown.routes());
|
2018-04-13 06:17:14 +09:00
|
|
|
|
2023-01-13 13:40:33 +09:00
|
|
|
router.get("/avatar/@:acct", async (ctx) => {
|
2021-11-12 02:02:25 +09:00
|
|
|
const { username, host } = Acct.parse(ctx.params.acct);
|
2021-10-24 21:02:50 +09:00
|
|
|
const user = await Users.findOne({
|
2022-03-26 15:34:00 +09:00
|
|
|
where: {
|
|
|
|
usernameLower: username.toLowerCase(),
|
2023-01-13 13:40:33 +09:00
|
|
|
host: host == null || host === config.host ? IsNull() : host,
|
2022-03-26 15:34:00 +09:00
|
|
|
isSuspended: false,
|
|
|
|
},
|
2023-01-13 13:40:33 +09:00
|
|
|
relations: ["avatar"],
|
2021-10-24 21:02:50 +09:00
|
|
|
});
|
|
|
|
|
|
|
|
if (user) {
|
2022-04-17 21:18:18 +09:00
|
|
|
ctx.redirect(Users.getAvatarUrlSync(user));
|
2021-10-24 21:02:50 +09:00
|
|
|
} else {
|
2023-01-13 13:40:33 +09:00
|
|
|
ctx.redirect("/static-assets/user-unknown.png");
|
2021-10-24 21:02:50 +09:00
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2023-01-13 13:40:33 +09:00
|
|
|
router.get("/identicon/:x", async (ctx) => {
|
2022-05-25 16:50:22 +09:00
|
|
|
const [temp, cleanup] = await createTemp();
|
2022-01-16 10:45:48 +09:00
|
|
|
await genIdenticon(ctx.params.x, fs.createWriteStream(temp));
|
2023-01-13 13:40:33 +09:00
|
|
|
ctx.set("Content-Type", "image/png");
|
|
|
|
ctx.body = fs.createReadStream(temp).on("close", () => cleanup());
|
2019-04-15 20:37:21 +09:00
|
|
|
});
|
|
|
|
|
2023-01-13 13:40:33 +09:00
|
|
|
router.get("/verify-email/:code", async (ctx) => {
|
2022-03-26 15:34:00 +09:00
|
|
|
const profile = await UserProfiles.findOneBy({
|
2021-12-09 23:58:30 +09:00
|
|
|
emailVerifyCode: ctx.params.code,
|
2019-04-07 21:50:36 +09:00
|
|
|
});
|
2018-11-29 16:23:45 +09:00
|
|
|
|
2019-04-10 15:04:27 +09:00
|
|
|
if (profile != null) {
|
2023-01-13 13:40:33 +09:00
|
|
|
ctx.body = "Verify succeeded!";
|
2018-11-29 16:23:45 +09:00
|
|
|
ctx.status = 200;
|
|
|
|
|
2023-01-13 13:40:33 +09:00
|
|
|
await UserProfiles.update(
|
|
|
|
{ userId: profile.userId },
|
|
|
|
{
|
|
|
|
emailVerified: true,
|
|
|
|
emailVerifyCode: null,
|
|
|
|
},
|
|
|
|
);
|
|
|
|
|
|
|
|
publishMainStream(
|
|
|
|
profile.userId,
|
|
|
|
"meUpdated",
|
|
|
|
await Users.pack(
|
|
|
|
profile.userId,
|
|
|
|
{ id: profile.userId },
|
|
|
|
{
|
|
|
|
detail: true,
|
|
|
|
includeSecrets: true,
|
|
|
|
},
|
|
|
|
),
|
|
|
|
);
|
2018-11-29 16:23:45 +09:00
|
|
|
} else {
|
|
|
|
ctx.status = 404;
|
|
|
|
}
|
2023-02-08 06:56:07 +09:00
|
|
|
});
|
|
|
|
|
|
|
|
router.get("/oauth/authorize", async (ctx) => {
|
|
|
|
const client_id = ctx.request.query.client_id;
|
|
|
|
console.log(ctx.request.req);
|
|
|
|
ctx.redirect(Buffer.from(client_id?.toString() || '', 'base64').toString());
|
|
|
|
});
|
|
|
|
|
2023-02-10 07:21:50 +09:00
|
|
|
router.get("/oauth/token", koaBody(), async (ctx) => {
|
|
|
|
const body: any = ctx.request.body;
|
2023-02-08 06:56:07 +09:00
|
|
|
const BASE_URL = `${ctx.request.protocol}://${ctx.request.hostname}`;
|
|
|
|
const generator = (megalodon as any).default;
|
|
|
|
const client = generator('misskey', BASE_URL, null) as MegalodonInterface;
|
2023-02-10 07:21:50 +09:00
|
|
|
const m = body.code.match(/^[a-zA-Z0-9-]+/);
|
|
|
|
if (!m.length) return { error: 'Invalid code' }
|
2023-02-08 06:56:07 +09:00
|
|
|
try {
|
2023-02-10 07:21:50 +09:00
|
|
|
const atData = await client.fetchAccessToken(null, body.client_secret, m[0]);
|
|
|
|
ctx.body = {
|
|
|
|
access_token: atData.accessToken,
|
|
|
|
token_type: 'Bearer',
|
|
|
|
scope: 'read write follow',
|
|
|
|
created_at: new Date().getTime() / 1000
|
|
|
|
};
|
2023-02-08 06:56:07 +09:00
|
|
|
} catch (err: any) {
|
|
|
|
console.error(err);
|
|
|
|
ctx.status = 401;
|
|
|
|
ctx.body = err.response.data;
|
|
|
|
}
|
2018-11-29 16:23:45 +09:00
|
|
|
});
|
|
|
|
|
2018-04-13 00:51:55 +09:00
|
|
|
// Register router
|
|
|
|
app.use(router.routes());
|
2016-12-29 07:49:51 +09:00
|
|
|
|
2022-02-27 11:07:39 +09:00
|
|
|
app.use(mount(webServer));
|
2018-04-13 07:34:27 +09:00
|
|
|
|
2018-03-29 01:20:40 +09:00
|
|
|
function createServer() {
|
2022-03-08 23:23:18 +09:00
|
|
|
return http.createServer(app.callback());
|
2018-03-29 01:20:40 +09:00
|
|
|
}
|
2016-12-29 07:49:51 +09:00
|
|
|
|
2019-01-23 13:35:22 +09:00
|
|
|
// For testing
|
|
|
|
export const startServer = () => {
|
|
|
|
const server = createServer();
|
|
|
|
|
2022-02-27 11:07:39 +09:00
|
|
|
initializeStreamingServer(server);
|
2019-01-23 13:35:22 +09:00
|
|
|
|
|
|
|
server.listen(config.port);
|
|
|
|
|
|
|
|
return server;
|
|
|
|
};
|
|
|
|
|
2023-01-13 13:40:33 +09:00
|
|
|
export default () =>
|
|
|
|
new Promise((resolve) => {
|
|
|
|
const server = createServer();
|
|
|
|
|
|
|
|
initializeStreamingServer(server);
|
|
|
|
|
|
|
|
server.on("error", (e) => {
|
|
|
|
switch ((e as any).code) {
|
|
|
|
case "EACCES":
|
|
|
|
serverLogger.error(
|
|
|
|
`You do not have permission to listen on port ${config.port}.`,
|
|
|
|
);
|
|
|
|
break;
|
|
|
|
case "EADDRINUSE":
|
|
|
|
serverLogger.error(
|
|
|
|
`Port ${config.port} is already in use by another process.`,
|
|
|
|
);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
serverLogger.error(e);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cluster.isWorker) {
|
|
|
|
process.send!("listenFailed");
|
|
|
|
} else {
|
|
|
|
// disableClustering
|
|
|
|
process.exit(1);
|
|
|
|
}
|
|
|
|
});
|
2017-01-17 07:51:27 +09:00
|
|
|
|
2023-01-13 13:40:33 +09:00
|
|
|
// @ts-ignore
|
|
|
|
server.listen(config.port, resolve);
|
2022-05-19 11:49:07 +09:00
|
|
|
});
|