Fix issue #19: Add unified campaign sync
This commit is contained in:
254
backend/src/services/service-links.js
Normal file
254
backend/src/services/service-links.js
Normal file
@@ -0,0 +1,254 @@
|
||||
const crypto = require('node:crypto');
|
||||
const jwt = require('jsonwebtoken');
|
||||
|
||||
const ServiceLinkRequest = require('../models/ServiceLinkRequest');
|
||||
const Campaign = require('../models/Campaign');
|
||||
const keys = require('./keys');
|
||||
|
||||
// How long a sign-up link waits for somebody to open it.
|
||||
const LINK_TTL_MS = 10 * 60 * 1000;
|
||||
// How long the Discord bot can still confirm an authorization it was away for.
|
||||
const NOTIFICATION_WINDOW_MS = 15 * 60 * 1000;
|
||||
// The token the Obsidian plugin gets back is its long-lived credential: a plugin cannot ask
|
||||
// somebody to open the sign-up link again every 48 hours. It carries the id of the link so that
|
||||
// revoking the link works right away — see services/passport.js.
|
||||
const OBSIDIAN_TOKEN_TTL = '365d';
|
||||
|
||||
// Every service that connects to a campaign does it the same way: it asks the
|
||||
// backend for a sign-up link, shows it to the person sitting in front of it,
|
||||
// and picks its credential up once a Dragonroll user has signed in through that
|
||||
// link and chosen a campaign. `botOnly` services are the ones that can prove
|
||||
// who they are to the backend; the others can only be trusted with their own
|
||||
// link, which is why what they get from a link is decided by the user.
|
||||
const SERVICES = {
|
||||
foundry: { name: 'Foundry VTT' },
|
||||
discord: { name: 'Discord', botOnly: true },
|
||||
obsidian: { name: 'Obsidian' },
|
||||
};
|
||||
|
||||
function isService(value) {
|
||||
return Object.prototype.hasOwnProperty.call(SERVICES, value);
|
||||
}
|
||||
|
||||
function serviceName(service) {
|
||||
return SERVICES[service]?.name || service;
|
||||
}
|
||||
|
||||
function isBotOnly(service) {
|
||||
return SERVICES[service]?.botOnly === true;
|
||||
}
|
||||
|
||||
function codeHash(code) {
|
||||
return crypto.createHash('sha256').update(String(code ?? '').trim()).digest('hex');
|
||||
}
|
||||
|
||||
function newLinkCode() {
|
||||
return crypto.randomBytes(32).toString('base64url');
|
||||
}
|
||||
|
||||
function frontendBaseUrl() {
|
||||
return (process.env.DRAGONROLL_FRONTEND_URL || 'http://localhost:3000').trim().replace(/\/+$/, '');
|
||||
}
|
||||
|
||||
// The sign-up link a service shows: it opens the Dragonroll page where somebody
|
||||
// signs in and picks the campaign. The code travels in the fragment, so the
|
||||
// browser never sends it to the server.
|
||||
function signUpLinkUrl(service, code) {
|
||||
return `${frontendBaseUrl()}/link/authorize?service=${encodeURIComponent(service)}#code=${encodeURIComponent(code)}`;
|
||||
}
|
||||
|
||||
// The bot talks to the backend with a shared secret instead of a login, so a
|
||||
// Discord server cannot be claimed by somebody who merely knows its id.
|
||||
function isDiscordBot(req) {
|
||||
const configuredSecret = process.env.DRAGONROLL_DISCORD_BOT_SECRET?.trim() || '';
|
||||
const suppliedSecret = req.get('x-dragonroll-discord-bot-secret') || '';
|
||||
const expected = Buffer.from(configuredSecret);
|
||||
const supplied = Buffer.from(suppliedSecret);
|
||||
|
||||
return !!expected.length
|
||||
&& expected.length === supplied.length
|
||||
&& crypto.timingSafeEqual(expected, supplied);
|
||||
}
|
||||
|
||||
function requireDiscordBot(req, res, next) {
|
||||
if (!isDiscordBot(req)) {
|
||||
return res.status(401).json({ status: 'error', msg: 'errors.unauthorized' });
|
||||
}
|
||||
return next();
|
||||
}
|
||||
|
||||
function readText(value, max) {
|
||||
return typeof value === 'string' ? value.trim().slice(0, max) : '';
|
||||
}
|
||||
|
||||
// Whatever else a service says about itself: the Foundry system it runs, the
|
||||
// Discord user id behind the person who asked... Values are kept short and
|
||||
// plain, because they come from a service and end up shown to a user.
|
||||
function readMeta(source) {
|
||||
const meta = {};
|
||||
for (const [key, value] of Object.entries(source).slice(0, MAX_META_ENTRIES)) {
|
||||
if (value === null || value === undefined || typeof value === 'boolean') {
|
||||
if (typeof value === 'boolean') meta[key] = value;
|
||||
continue;
|
||||
}
|
||||
if (typeof value !== 'string' && typeof value !== 'number') continue;
|
||||
meta[key] = String(value).trim().slice(0, MAX_META_VALUE_LENGTH);
|
||||
}
|
||||
return meta;
|
||||
}
|
||||
|
||||
// How a service describes itself: which world/server/vault is asking, on whose
|
||||
// behalf, and the little that goes with it.
|
||||
function readTarget(body) {
|
||||
const source = body?.target && typeof body.target === 'object' ? body.target : {};
|
||||
|
||||
const target = {
|
||||
targetId: readText(source.id, 120),
|
||||
targetName: readText(source.name, 200),
|
||||
targetUser: readText(source.user, 120),
|
||||
targetMeta: source.meta && typeof source.meta === 'object' && !Array.isArray(source.meta)
|
||||
? readMeta(source.meta)
|
||||
: {}
|
||||
};
|
||||
|
||||
if (typeof target.targetMeta.url === 'string') {
|
||||
try {
|
||||
const url = new URL(target.targetMeta.url);
|
||||
target.targetMeta.url = url.protocol === 'http:' || url.protocol === 'https:' ? url.origin : '';
|
||||
} catch {
|
||||
target.targetMeta.url = '';
|
||||
}
|
||||
}
|
||||
return target;
|
||||
}
|
||||
|
||||
function linkIsExpired(request) {
|
||||
return request?.state === 'pending' && (!request.expiresAt || request.expiresAt <= new Date());
|
||||
}
|
||||
|
||||
// A service asking again reuses its own row: one world, one Discord server and
|
||||
// one vault each have a single link, and asking for it replaces the last one.
|
||||
async function startServiceLink(service, target) {
|
||||
const code = newLinkCode();
|
||||
const expiresAt = new Date(Date.now() + LINK_TTL_MS);
|
||||
const request = await ServiceLinkRequest.findOneAndUpdate(
|
||||
{ service: service, targetId: target.targetId },
|
||||
{
|
||||
$set: {
|
||||
service: service,
|
||||
targetId: target.targetId,
|
||||
targetName: target.targetName,
|
||||
targetUser: target.targetUser,
|
||||
targetMeta: target.targetMeta,
|
||||
codeHash: codeHash(code),
|
||||
state: 'pending',
|
||||
expiresAt: expiresAt
|
||||
},
|
||||
$unset: {
|
||||
campaign: 1,
|
||||
dragonrollUser: 1,
|
||||
credentials: 1,
|
||||
linkedAt: 1,
|
||||
pickedUpAt: 1,
|
||||
notifiedAt: 1
|
||||
}
|
||||
},
|
||||
{ new: true, upsert: true, setDefaultsOnInsert: true }
|
||||
);
|
||||
|
||||
return { request, code, url: signUpLinkUrl(service, code), expiresAt };
|
||||
}
|
||||
|
||||
async function findServiceLinkByCode(code) {
|
||||
if (!code) return null;
|
||||
return ServiceLinkRequest.findOne({ codeHash: codeHash(code) }).select('+credentials').lean();
|
||||
}
|
||||
|
||||
// The credential that belongs to a link is handed over once and then dropped:
|
||||
// whoever loses it starts the link again from the service, which is where they
|
||||
// got the link from in the first place.
|
||||
async function takeServiceLinkCredentials(request) {
|
||||
const credentials = request?.credentials || null;
|
||||
if (!credentials) return null;
|
||||
|
||||
await ServiceLinkRequest.updateOne(
|
||||
{ _id: request._id },
|
||||
{ $set: { pickedUpAt: new Date() }, $unset: { credentials: 1 } }
|
||||
);
|
||||
return credentials;
|
||||
}
|
||||
|
||||
// The user who owns the campaign picked it for this link.
|
||||
async function completeServiceLink(request, campaign, user, credentials = null) {
|
||||
request.campaign = campaign._id;
|
||||
request.dragonrollUser = user.id;
|
||||
request.state = 'linked';
|
||||
request.linkedAt = new Date();
|
||||
request.pickedUpAt = null;
|
||||
request.notifiedAt = null;
|
||||
request.credentials = credentials || undefined;
|
||||
// An answered link is the record of a live connection: it stays until the
|
||||
// service re-links or the campaign unlinks it.
|
||||
request.expiresAt = null;
|
||||
await request.save();
|
||||
return request;
|
||||
}
|
||||
|
||||
// A campaign dropping a service: the link stops being valid, and the service
|
||||
// finds that out the next time it asks.
|
||||
async function revokeServiceLink(service, campaignId) {
|
||||
const result = await ServiceLinkRequest.updateMany(
|
||||
{ service: service, campaign: campaignId, state: 'linked' },
|
||||
{
|
||||
$set: { state: 'revoked', campaign: null },
|
||||
$unset: { credentials: 1, linkedAt: 1 }
|
||||
}
|
||||
);
|
||||
return result.matchedCount;
|
||||
}
|
||||
|
||||
// What a campaign has connected to it, newest link first and one row per
|
||||
// service, so the campaign settings can list its services together.
|
||||
async function listLinkedServices(campaignId) {
|
||||
const links = await ServiceLinkRequest.find({ campaign: campaignId, state: 'linked' })
|
||||
.sort({ linkedAt: -1 })
|
||||
.lean();
|
||||
|
||||
const seen = new Set();
|
||||
const services = [];
|
||||
for (const link of links) {
|
||||
if (seen.has(link.service)) continue;
|
||||
seen.add(link.service);
|
||||
services.push({
|
||||
service: link.service,
|
||||
name: serviceName(link.service),
|
||||
targetId: link.targetId || '',
|
||||
targetName: link.targetName || '',
|
||||
targetUser: link.targetUser || '',
|
||||
dragonrollUser: link.dragonrollUser || null,
|
||||
linkedAt: link.linkedAt
|
||||
});
|
||||
}
|
||||
return services;
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
LINK_TTL_MS,
|
||||
NOTIFICATION_WINDOW_MS,
|
||||
SERVICES,
|
||||
codeHash,
|
||||
completeServiceLink,
|
||||
findServiceLinkByCode,
|
||||
isBotOnly,
|
||||
isDiscordBot,
|
||||
isService,
|
||||
linkIsExpired,
|
||||
listLinkedServices,
|
||||
readTarget,
|
||||
requireDiscordBot,
|
||||
revokeServiceLink,
|
||||
serviceName,
|
||||
signUpLinkUrl,
|
||||
startServiceLink,
|
||||
takeServiceLinkCredentials
|
||||
};
|
||||
Reference in New Issue
Block a user